@ionic/core

  • Version 5.6.8
  • Published
  • 14.5 MB
  • 3 dependencies
  • MIT license

Install

npm i @ionic/core
yarn add @ionic/core
pnpm add @ionic/core

Overview

Base components for Ionic

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Namespaces

Variables

variable actionSheetController

const actionSheetController: {
create(options: ActionSheetOptions): Promise<HTMLIonActionSheetElement>;
dismiss(
data?: any,
role?: string | undefined,
id?: string | undefined
): Promise<boolean>;
getTop(): Promise<HTMLIonActionSheetElement | undefined>;
};

    variable alertController

    const alertController: {
    create(options: AlertOptions): Promise<HTMLIonAlertElement>;
    dismiss(
    data?: any,
    role?: string | undefined,
    id?: string | undefined
    ): Promise<boolean>;
    getTop(): Promise<HTMLIonAlertElement | undefined>;
    };

      variable config

      const config: Config;

        variable isPlatform

        const isPlatform: IsPlatformSignature;

          variable LIFECYCLE_DID_ENTER

          const LIFECYCLE_DID_ENTER: string;

            variable LIFECYCLE_DID_LEAVE

            const LIFECYCLE_DID_LEAVE: string;

              variable LIFECYCLE_WILL_ENTER

              const LIFECYCLE_WILL_ENTER: string;

                variable LIFECYCLE_WILL_LEAVE

                const LIFECYCLE_WILL_LEAVE: string;

                  variable LIFECYCLE_WILL_UNLOAD

                  const LIFECYCLE_WILL_UNLOAD: string;

                    variable loadingController

                    const loadingController: {
                    create(options: LoadingOptions): Promise<HTMLIonLoadingElement>;
                    dismiss(
                    data?: any,
                    role?: string | undefined,
                    id?: string | undefined
                    ): Promise<boolean>;
                    getTop(): Promise<HTMLIonLoadingElement | undefined>;
                    };
                      const menuController: {
                      registerAnimation: (name: string, animation: AnimationBuilder) => void;
                      get: (
                      menu?: string | null | undefined
                      ) => Promise<HTMLIonMenuElement | undefined>;
                      getMenus: () => Promise<HTMLIonMenuElement[]>;
                      getOpen: () => Promise<HTMLIonMenuElement | undefined>;
                      isEnabled: (menu?: string | null | undefined) => Promise<boolean>;
                      swipeGesture: (
                      shouldEnable: boolean,
                      menu?: string | null | undefined
                      ) => Promise<HTMLIonMenuElement | undefined>;
                      isAnimating: () => Promise<boolean>;
                      isOpen: (menu?: string | null | undefined) => Promise<boolean>;
                      enable: (
                      shouldEnable: boolean,
                      menu?: string | null | undefined
                      ) => Promise<HTMLIonMenuElement | undefined>;
                      toggle: (menu?: string | null | undefined) => Promise<boolean>;
                      close: (menu?: string | null | undefined) => Promise<boolean>;
                      open: (menu?: string | null | undefined) => Promise<boolean>;
                      _getOpenSync: () => HTMLIonMenuElement | undefined;
                      _createAnimation: (type: string, menuCmp: MenuI) => any;
                      _register: (menu: MenuI) => void;
                      _unregister: (menu: MenuI) => void;
                      _setOpen: (
                      menu: MenuI,
                      shouldOpen: boolean,
                      animated: boolean
                      ) => Promise<boolean>;
                      _setActiveMenu: (menu: MenuI) => void;
                      };

                        variable modalController

                        const modalController: {
                        create(
                        options: ModalOptions<import('../interface').ComponentRef>
                        ): Promise<HTMLIonModalElement>;
                        dismiss(
                        data?: any,
                        role?: string | undefined,
                        id?: string | undefined
                        ): Promise<boolean>;
                        getTop(): Promise<HTMLIonModalElement | undefined>;
                        };

                          variable pickerController

                          const pickerController: {
                          create(options: PickerOptions): Promise<HTMLIonPickerElement>;
                          dismiss(
                          data?: any,
                          role?: string | undefined,
                          id?: string | undefined
                          ): Promise<boolean>;
                          getTop(): Promise<HTMLIonPickerElement | undefined>;
                          };

                            variable popoverController

                            const popoverController: {
                            create(
                            options: PopoverOptions<import('../interface').ComponentRef>
                            ): Promise<HTMLIonPopoverElement>;
                            dismiss(
                            data?: any,
                            role?: string | undefined,
                            id?: string | undefined
                            ): Promise<boolean>;
                            getTop(): Promise<HTMLIonPopoverElement | undefined>;
                            };

                              variable toastController

                              const toastController: {
                              create(options: ToastOptions): Promise<HTMLIonToastElement>;
                              dismiss(
                              data?: any,
                              role?: string | undefined,
                              id?: string | undefined
                              ): Promise<boolean>;
                              getTop(): Promise<HTMLIonToastElement | undefined>;
                              };

                                Functions

                                function componentOnReady

                                componentOnReady: (el: any, callback: any) => void;
                                • Waits for a component to be ready for both custom element and non-custom element builds. If non-custom element build, el.componentOnReady will be used. For custom element builds, we wait a frame so that the inner contents of the component have a chance to render.

                                  Use this utility rather than calling el.componentOnReady yourself.

                                function configFromSession

                                configFromSession: (win: Window) => any;

                                  function configFromURL

                                  configFromURL: (win: Window) => any;

                                    function createAnimation

                                    createAnimation: (animationId?: string | undefined) => Animation;

                                      function createGesture

                                      createGesture: (config: GestureConfig) => Gesture;

                                        function getMode

                                        getMode: () => Mode;

                                          function getPlatforms

                                          getPlatforms: (
                                          win?: any
                                          ) => (
                                          | 'ios'
                                          | 'ipad'
                                          | 'iphone'
                                          | 'android'
                                          | 'phablet'
                                          | 'tablet'
                                          | 'cordova'
                                          | 'capacitor'
                                          | 'electron'
                                          | 'pwa'
                                          | 'mobile'
                                          | 'mobileweb'
                                          | 'desktop'
                                          | 'hybrid'
                                          )[];

                                            function getTimeGivenProgression

                                            getTimeGivenProgression: (
                                            p0: number[],
                                            p1: number[],
                                            p2: number[],
                                            p3: number[],
                                            progression: number
                                            ) => number[];
                                            • EXPERIMENTAL Given a cubic-bezier curve, get the x value (time) given the y value (progression). Ex: cubic-bezier(0.32, 0.72, 0, 1); P0: (0, 0) P1: (0.32, 0.72) P2: (0, 1) P3: (1, 1)

                                              If you give a cubic bezier curve that never reaches the provided progression, this function will return an empty array.

                                            function initialize

                                            initialize: (userConfig?: IonicConfig) => void;

                                              function iosTransitionAnimation

                                              iosTransitionAnimation: (
                                              navEl: HTMLElement,
                                              opts: TransitionOptions
                                              ) => Animation;

                                                function mdTransitionAnimation

                                                mdTransitionAnimation: (_: HTMLElement, opts: TransitionOptions) => Animation;

                                                  function saveConfig

                                                  saveConfig: (win: Window, c: any) => void;

                                                    function setupConfig

                                                    setupConfig: (config: IonicConfig) => any;

                                                      Classes

                                                      class Config

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

                                                              method reset

                                                              reset: (configObj: IonicConfig) => void;

                                                                method set

                                                                set: (key: keyof IonicConfig, value: any) => void;

                                                                  class IonicSafeString

                                                                  class IonicSafeString {}

                                                                    constructor

                                                                    constructor(value: string);

                                                                      property value

                                                                      value: string;

                                                                        class ViewController

                                                                        class ViewController {}

                                                                          constructor

                                                                          constructor(component: any, params: ComponentProps<null>);

                                                                            property animationBuilder

                                                                            animationBuilder?: AnimationBuilder;

                                                                              property component

                                                                              component: any;

                                                                                property delegate

                                                                                delegate?: FrameworkDelegate;

                                                                                  property element

                                                                                  element?: HTMLElement;

                                                                                    property nav

                                                                                    nav?: any;

                                                                                      property params

                                                                                      params: ComponentProps<null>;

                                                                                        property state

                                                                                        state: number;

                                                                                          method init

                                                                                          init: (container: HTMLElement) => Promise<void>;

                                                                                            Interfaces

                                                                                            interface ActionSheetButton

                                                                                            interface ActionSheetButton {}

                                                                                              property cssClass

                                                                                              cssClass?: string | string[];

                                                                                                property handler

                                                                                                handler?: () => boolean | void | Promise<boolean | void>;

                                                                                                  property icon

                                                                                                  icon?: string;

                                                                                                    property role

                                                                                                    role?: 'cancel' | 'destructive' | 'selected' | string;

                                                                                                      property text

                                                                                                      text?: string;

                                                                                                        interface ActionSheetOptions

                                                                                                        interface ActionSheetOptions {}

                                                                                                          property animated

                                                                                                          animated?: boolean;

                                                                                                            property backdropDismiss

                                                                                                            backdropDismiss?: boolean;

                                                                                                              property buttons

                                                                                                              buttons: (ActionSheetButton | string)[];

                                                                                                                property cssClass

                                                                                                                cssClass?: string | string[];

                                                                                                                  property enterAnimation

                                                                                                                  enterAnimation?: AnimationBuilder;

                                                                                                                    property header

                                                                                                                    header?: string;

                                                                                                                      property id

                                                                                                                      id?: string;

                                                                                                                        property keyboardClose

                                                                                                                        keyboardClose?: boolean;

                                                                                                                          property leaveAnimation

                                                                                                                          leaveAnimation?: AnimationBuilder;

                                                                                                                            property mode

                                                                                                                            mode?: Mode;

                                                                                                                              property subHeader

                                                                                                                              subHeader?: string;

                                                                                                                                property translucent

                                                                                                                                translucent?: boolean;

                                                                                                                                  interface AlertButton

                                                                                                                                  interface AlertButton {}

                                                                                                                                    property cssClass

                                                                                                                                    cssClass?: string | string[];

                                                                                                                                      property handler

                                                                                                                                      handler?: (
                                                                                                                                      value: any
                                                                                                                                      ) =>
                                                                                                                                      | boolean
                                                                                                                                      | void
                                                                                                                                      | {
                                                                                                                                      [key: string]: any;
                                                                                                                                      };

                                                                                                                                        property role

                                                                                                                                        role?: string;

                                                                                                                                          property text

                                                                                                                                          text: string;

                                                                                                                                            interface AlertInput

                                                                                                                                            interface AlertInput {}

                                                                                                                                              property attributes

                                                                                                                                              attributes?: AlertInputAttributes | AlertTextareaAttributes;

                                                                                                                                                property checked

                                                                                                                                                checked?: boolean;

                                                                                                                                                  property cssClass

                                                                                                                                                  cssClass?: string | string[];

                                                                                                                                                    property disabled

                                                                                                                                                    disabled?: boolean;

                                                                                                                                                      property handler

                                                                                                                                                      handler?: (input: AlertInput) => void;

                                                                                                                                                        property id

                                                                                                                                                        id?: string;

                                                                                                                                                          property label

                                                                                                                                                          label?: string;

                                                                                                                                                            property max

                                                                                                                                                            max?: string | number;

                                                                                                                                                              property min

                                                                                                                                                              min?: string | number;

                                                                                                                                                                property name

                                                                                                                                                                name?: string;

                                                                                                                                                                  property placeholder

                                                                                                                                                                  placeholder?: string;

                                                                                                                                                                    property tabindex

                                                                                                                                                                    tabindex?: number;

                                                                                                                                                                      property type

                                                                                                                                                                      type?: TextFieldTypes | 'checkbox' | 'radio' | 'textarea';

                                                                                                                                                                        property value

                                                                                                                                                                        value?: any;

                                                                                                                                                                          interface AlertInputAttributes

                                                                                                                                                                          interface AlertInputAttributes
                                                                                                                                                                          extends JSXBase.InputHTMLAttributes<HTMLInputElement> {}

                                                                                                                                                                            interface AlertOptions

                                                                                                                                                                            interface AlertOptions {}

                                                                                                                                                                              property animated

                                                                                                                                                                              animated?: boolean;

                                                                                                                                                                                property backdropDismiss

                                                                                                                                                                                backdropDismiss?: boolean;

                                                                                                                                                                                  property buttons

                                                                                                                                                                                  buttons?: (AlertButton | string)[];

                                                                                                                                                                                    property cssClass

                                                                                                                                                                                    cssClass?: string | string[];

                                                                                                                                                                                      property enterAnimation

                                                                                                                                                                                      enterAnimation?: AnimationBuilder;

                                                                                                                                                                                        property header

                                                                                                                                                                                        header?: string;

                                                                                                                                                                                          property id

                                                                                                                                                                                          id?: string;

                                                                                                                                                                                            property inputs

                                                                                                                                                                                            inputs?: AlertInput[];

                                                                                                                                                                                              property keyboardClose

                                                                                                                                                                                              keyboardClose?: boolean;

                                                                                                                                                                                                property leaveAnimation

                                                                                                                                                                                                leaveAnimation?: AnimationBuilder;

                                                                                                                                                                                                  property message

                                                                                                                                                                                                  message?: string | IonicSafeString;

                                                                                                                                                                                                    property mode

                                                                                                                                                                                                    mode?: Mode;

                                                                                                                                                                                                      property subHeader

                                                                                                                                                                                                      subHeader?: string;

                                                                                                                                                                                                        property translucent

                                                                                                                                                                                                        translucent?: boolean;

                                                                                                                                                                                                          interface AlertTextareaAttributes

                                                                                                                                                                                                          interface AlertTextareaAttributes
                                                                                                                                                                                                          extends JSXBase.TextareaHTMLAttributes<HTMLTextAreaElement> {}

                                                                                                                                                                                                            interface Animation

                                                                                                                                                                                                            interface Animation {}

                                                                                                                                                                                                              property childAnimations

                                                                                                                                                                                                              childAnimations: Animation[];

                                                                                                                                                                                                                property elements

                                                                                                                                                                                                                elements: HTMLElement[];

                                                                                                                                                                                                                  property id

                                                                                                                                                                                                                  id: string | undefined;

                                                                                                                                                                                                                    property parentAnimation

                                                                                                                                                                                                                    parentAnimation: Animation | undefined;

                                                                                                                                                                                                                      method addAnimation

                                                                                                                                                                                                                      addAnimation: (animationToAdd: Animation | Animation[]) => Animation;
                                                                                                                                                                                                                      • Group one or more animations together to be controlled by a parent animation.

                                                                                                                                                                                                                      method addElement

                                                                                                                                                                                                                      addElement: (el: Element | Element[] | Node | Node[] | NodeList) => Animation;
                                                                                                                                                                                                                      • Add one or more elements to the animation

                                                                                                                                                                                                                      method afterAddClass

                                                                                                                                                                                                                      afterAddClass: (className: string | string[]) => Animation;
                                                                                                                                                                                                                      • Add CSS class to the animation's elements after the animation ends.

                                                                                                                                                                                                                      method afterAddRead

                                                                                                                                                                                                                      afterAddRead: (readFn: () => void) => Animation;
                                                                                                                                                                                                                      • Add a function that performs a DOM read to be run after the animation end

                                                                                                                                                                                                                      method afterAddWrite

                                                                                                                                                                                                                      afterAddWrite: (writeFn: () => void) => Animation;
                                                                                                                                                                                                                      • Add a function that performs a DOM write to be run after the animation end

                                                                                                                                                                                                                      method afterClearStyles

                                                                                                                                                                                                                      afterClearStyles: (propertyNames: string[]) => Animation;
                                                                                                                                                                                                                      • Clear CSS inline styles from the animation's elements after the animation ends.

                                                                                                                                                                                                                      method afterRemoveClass

                                                                                                                                                                                                                      afterRemoveClass: (className: string | string[]) => Animation;
                                                                                                                                                                                                                      • Remove CSS class from the animation's elements after the animation ends.

                                                                                                                                                                                                                      method afterStyles

                                                                                                                                                                                                                      afterStyles: (styles: { [property: string]: any }) => Animation;
                                                                                                                                                                                                                      • Set CSS inline styles to the animation's elements after the animation ends.

                                                                                                                                                                                                                      method beforeAddClass

                                                                                                                                                                                                                      beforeAddClass: (className: string | string[]) => Animation;
                                                                                                                                                                                                                      • Add a class to the animation's elements before the animation starts

                                                                                                                                                                                                                      method beforeAddRead

                                                                                                                                                                                                                      beforeAddRead: (readFn: () => void) => Animation;
                                                                                                                                                                                                                      • Add a function that performs a DOM read to be run before the animation starts

                                                                                                                                                                                                                      method beforeAddWrite

                                                                                                                                                                                                                      beforeAddWrite: (writeFn: () => void) => Animation;
                                                                                                                                                                                                                      • Add a function that performs a DOM write to be run before the animation starts

                                                                                                                                                                                                                      method beforeClearStyles

                                                                                                                                                                                                                      beforeClearStyles: (propertyNames: string[]) => Animation;
                                                                                                                                                                                                                      • Clear CSS inline styles from the animation's elements before the animation begins.

                                                                                                                                                                                                                      method beforeRemoveClass

                                                                                                                                                                                                                      beforeRemoveClass: (className: string | string[]) => Animation;
                                                                                                                                                                                                                      • Remove a class from the animation's elements before the animation starts

                                                                                                                                                                                                                      method beforeStyles

                                                                                                                                                                                                                      beforeStyles: (styles: { [property: string]: any }) => Animation;
                                                                                                                                                                                                                      • Set CSS inline styles to the animation's elements before the animation begins.

                                                                                                                                                                                                                      method delay

                                                                                                                                                                                                                      delay: (delay: number | undefined) => Animation;
                                                                                                                                                                                                                      • Sets when an animation starts (in milliseconds).

                                                                                                                                                                                                                      method destroy

                                                                                                                                                                                                                      destroy: (clearStyleSheets?: boolean) => void;
                                                                                                                                                                                                                      • Destroy the animation and all child animations.

                                                                                                                                                                                                                      method direction

                                                                                                                                                                                                                      direction: (direction: AnimationDirection | undefined) => Animation;
                                                                                                                                                                                                                      • Sets whether the animation should play forwards, backwards, or alternating back and forth.

                                                                                                                                                                                                                      method duration

                                                                                                                                                                                                                      duration: (duration: number | undefined) => Animation;
                                                                                                                                                                                                                      • Sets the length of time the animation takes to complete one cycle.

                                                                                                                                                                                                                      method easing

                                                                                                                                                                                                                      easing: (easing: string | undefined) => Animation;
                                                                                                                                                                                                                      • Sets how the animation progresses through the duration of each cycle.

                                                                                                                                                                                                                      method fill

                                                                                                                                                                                                                      fill: (fill: AnimationFill | undefined) => Animation;
                                                                                                                                                                                                                      • Sets how the animation applies styles to its elements before and after the animation's execution.

                                                                                                                                                                                                                      method from

                                                                                                                                                                                                                      from: (property: string, value: any) => Animation;

                                                                                                                                                                                                                        method fromTo

                                                                                                                                                                                                                        fromTo: (property: string, fromValue: any, toValue: any) => Animation;

                                                                                                                                                                                                                          method getDelay

                                                                                                                                                                                                                          getDelay: () => number;
                                                                                                                                                                                                                          • Gets the animation's delay in milliseconds.

                                                                                                                                                                                                                          method getDirection

                                                                                                                                                                                                                          getDirection: () => AnimationDirection;
                                                                                                                                                                                                                          • Returns the animation's direction.

                                                                                                                                                                                                                          method getDuration

                                                                                                                                                                                                                          getDuration: () => number;
                                                                                                                                                                                                                          • Gets the animation's duration in milliseconds.

                                                                                                                                                                                                                          method getEasing

                                                                                                                                                                                                                          getEasing: () => string;
                                                                                                                                                                                                                          • Returns the animation's easing.

                                                                                                                                                                                                                          method getFill

                                                                                                                                                                                                                          getFill: () => AnimationFill;
                                                                                                                                                                                                                          • Returns the animation's fill mode.

                                                                                                                                                                                                                          method getIterations

                                                                                                                                                                                                                          getIterations: () => number;
                                                                                                                                                                                                                          • Gets the number of iterations the animation will run.

                                                                                                                                                                                                                          method getKeyframes

                                                                                                                                                                                                                          getKeyframes: () => AnimationKeyFrames;
                                                                                                                                                                                                                          • Get an array of keyframes for the animation.

                                                                                                                                                                                                                          method getWebAnimations

                                                                                                                                                                                                                          getWebAnimations: () => any[];
                                                                                                                                                                                                                          • Returns the raw Web Animations object for all elements in an Animation. This will return an empty array on browsers that do not support the Web Animations API.

                                                                                                                                                                                                                          method iterations

                                                                                                                                                                                                                          iterations: (iterations: number) => Animation;
                                                                                                                                                                                                                          • Sets the number of times the animation cycle should be played before stopping.

                                                                                                                                                                                                                          method keyframes

                                                                                                                                                                                                                          keyframes: (keyframes: AnimationKeyFrames) => Animation;
                                                                                                                                                                                                                          • Set the keyframes for the animation.

                                                                                                                                                                                                                          method onFinish

                                                                                                                                                                                                                          onFinish: (
                                                                                                                                                                                                                          callback: AnimationLifecycle,
                                                                                                                                                                                                                          opts?: AnimationCallbackOptions
                                                                                                                                                                                                                          ) => Animation;
                                                                                                                                                                                                                          • Add a callback to be run upon the animation ending

                                                                                                                                                                                                                          method pause

                                                                                                                                                                                                                          pause: () => void;
                                                                                                                                                                                                                          • Pauses the animation

                                                                                                                                                                                                                          method play

                                                                                                                                                                                                                          play: (opts?: AnimationPlayOptions) => Promise<void>;
                                                                                                                                                                                                                          • Play the animation

                                                                                                                                                                                                                            If the sync options is true, the animation will play synchronously. This is the equivalent of running the animation with a duration of 0ms.

                                                                                                                                                                                                                          method progressEnd

                                                                                                                                                                                                                          progressEnd: (playTo: 0 | 1 | undefined, step: number, dur?: number) => void;

                                                                                                                                                                                                                            method progressStart

                                                                                                                                                                                                                            progressStart: (forceLinearEasing: boolean, step?: number) => void;

                                                                                                                                                                                                                              method progressStep

                                                                                                                                                                                                                              progressStep: (step: number) => void;

                                                                                                                                                                                                                                method stop

                                                                                                                                                                                                                                stop: () => void;
                                                                                                                                                                                                                                • Stop the animation and reset all elements to their initial state

                                                                                                                                                                                                                                method to

                                                                                                                                                                                                                                to: (property: string, value: any) => Animation;

                                                                                                                                                                                                                                  interface AnimationCallbackOptions

                                                                                                                                                                                                                                  interface AnimationCallbackOptions {}

                                                                                                                                                                                                                                    property oneTimeCallback

                                                                                                                                                                                                                                    oneTimeCallback: boolean;

                                                                                                                                                                                                                                      interface BackButtonEventDetail

                                                                                                                                                                                                                                      interface BackButtonEventDetail {}

                                                                                                                                                                                                                                        method register

                                                                                                                                                                                                                                        register: (
                                                                                                                                                                                                                                        priority: number,
                                                                                                                                                                                                                                        handler: (processNextHandler: () => void) => Promise<any> | void
                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                          interface Cell

                                                                                                                                                                                                                                          interface Cell {}

                                                                                                                                                                                                                                            property height

                                                                                                                                                                                                                                            height: number;

                                                                                                                                                                                                                                              property i

                                                                                                                                                                                                                                              i: number;

                                                                                                                                                                                                                                                property index

                                                                                                                                                                                                                                                index: number;

                                                                                                                                                                                                                                                  property reads

                                                                                                                                                                                                                                                  reads: number;

                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                    type: CellType;

                                                                                                                                                                                                                                                      property value

                                                                                                                                                                                                                                                      value: any;

                                                                                                                                                                                                                                                        property visible

                                                                                                                                                                                                                                                        visible: boolean;

                                                                                                                                                                                                                                                          interface CheckboxChangeEventDetail

                                                                                                                                                                                                                                                          interface CheckboxChangeEventDetail {}

                                                                                                                                                                                                                                                            property checked

                                                                                                                                                                                                                                                            checked: boolean;

                                                                                                                                                                                                                                                              property value

                                                                                                                                                                                                                                                              value: any;

                                                                                                                                                                                                                                                                interface DatetimeChangeEventDetail

                                                                                                                                                                                                                                                                interface DatetimeChangeEventDetail {}

                                                                                                                                                                                                                                                                  property value

                                                                                                                                                                                                                                                                  value: string | undefined | null;

                                                                                                                                                                                                                                                                    interface FrameworkDelegate

                                                                                                                                                                                                                                                                    interface FrameworkDelegate {}

                                                                                                                                                                                                                                                                      method attachViewToDom

                                                                                                                                                                                                                                                                      attachViewToDom: (
                                                                                                                                                                                                                                                                      container: any,
                                                                                                                                                                                                                                                                      component: any,
                                                                                                                                                                                                                                                                      propsOrDataObj?: any,
                                                                                                                                                                                                                                                                      cssClasses?: string[]
                                                                                                                                                                                                                                                                      ) => Promise<HTMLElement>;

                                                                                                                                                                                                                                                                        method removeViewFromDom

                                                                                                                                                                                                                                                                        removeViewFromDom: (container: any, component: any) => Promise<void>;

                                                                                                                                                                                                                                                                          interface Gesture

                                                                                                                                                                                                                                                                          interface Gesture {}

                                                                                                                                                                                                                                                                            method destroy

                                                                                                                                                                                                                                                                            destroy: () => void;

                                                                                                                                                                                                                                                                              method enable

                                                                                                                                                                                                                                                                              enable: (enable?: boolean) => void;

                                                                                                                                                                                                                                                                                interface GestureConfig

                                                                                                                                                                                                                                                                                interface GestureConfig {}

                                                                                                                                                                                                                                                                                  property blurOnStart

                                                                                                                                                                                                                                                                                  blurOnStart?: boolean;

                                                                                                                                                                                                                                                                                    property canStart

                                                                                                                                                                                                                                                                                    canStart?: GestureCallback;

                                                                                                                                                                                                                                                                                      property direction

                                                                                                                                                                                                                                                                                      direction?: 'x' | 'y';

                                                                                                                                                                                                                                                                                        property disableScroll

                                                                                                                                                                                                                                                                                        disableScroll?: boolean;

                                                                                                                                                                                                                                                                                          property el

                                                                                                                                                                                                                                                                                          el: Node;

                                                                                                                                                                                                                                                                                            property gestureName

                                                                                                                                                                                                                                                                                            gestureName: string;

                                                                                                                                                                                                                                                                                              property gesturePriority

                                                                                                                                                                                                                                                                                              gesturePriority?: number;

                                                                                                                                                                                                                                                                                                property maxAngle

                                                                                                                                                                                                                                                                                                maxAngle?: number;

                                                                                                                                                                                                                                                                                                  property notCaptured

                                                                                                                                                                                                                                                                                                  notCaptured?: GestureCallback;

                                                                                                                                                                                                                                                                                                    property onEnd

                                                                                                                                                                                                                                                                                                    onEnd?: GestureCallback;

                                                                                                                                                                                                                                                                                                      property onMove

                                                                                                                                                                                                                                                                                                      onMove?: GestureCallback;

                                                                                                                                                                                                                                                                                                        property onStart

                                                                                                                                                                                                                                                                                                        onStart?: GestureCallback;

                                                                                                                                                                                                                                                                                                          property onWillStart

                                                                                                                                                                                                                                                                                                          onWillStart?: (_: GestureDetail) => Promise<void>;

                                                                                                                                                                                                                                                                                                            property passive

                                                                                                                                                                                                                                                                                                            passive?: boolean;

                                                                                                                                                                                                                                                                                                              property threshold

                                                                                                                                                                                                                                                                                                              threshold?: number;

                                                                                                                                                                                                                                                                                                                interface GestureDetail

                                                                                                                                                                                                                                                                                                                interface GestureDetail {}

                                                                                                                                                                                                                                                                                                                  property currentTime

                                                                                                                                                                                                                                                                                                                  currentTime: number;

                                                                                                                                                                                                                                                                                                                    property currentX

                                                                                                                                                                                                                                                                                                                    currentX: number;

                                                                                                                                                                                                                                                                                                                      property currentY

                                                                                                                                                                                                                                                                                                                      currentY: number;

                                                                                                                                                                                                                                                                                                                        property data

                                                                                                                                                                                                                                                                                                                        data?: any;

                                                                                                                                                                                                                                                                                                                          property deltaX

                                                                                                                                                                                                                                                                                                                          deltaX: number;

                                                                                                                                                                                                                                                                                                                            property deltaY

                                                                                                                                                                                                                                                                                                                            deltaY: number;

                                                                                                                                                                                                                                                                                                                              property event

                                                                                                                                                                                                                                                                                                                              event: UIEvent;

                                                                                                                                                                                                                                                                                                                                property startTime

                                                                                                                                                                                                                                                                                                                                startTime: number;

                                                                                                                                                                                                                                                                                                                                  property startX

                                                                                                                                                                                                                                                                                                                                  startX: number;

                                                                                                                                                                                                                                                                                                                                    property startY

                                                                                                                                                                                                                                                                                                                                    startY: number;

                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                      type: string;

                                                                                                                                                                                                                                                                                                                                        property velocityX

                                                                                                                                                                                                                                                                                                                                        velocityX: number;

                                                                                                                                                                                                                                                                                                                                          property velocityY

                                                                                                                                                                                                                                                                                                                                          velocityY: number;

                                                                                                                                                                                                                                                                                                                                            interface HTMLIonOverlayElement

                                                                                                                                                                                                                                                                                                                                            interface HTMLIonOverlayElement extends HTMLStencilElement {}

                                                                                                                                                                                                                                                                                                                                              property backdropDismiss

                                                                                                                                                                                                                                                                                                                                              backdropDismiss?: boolean;

                                                                                                                                                                                                                                                                                                                                                property lastFocus

                                                                                                                                                                                                                                                                                                                                                lastFocus?: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                  property overlayIndex

                                                                                                                                                                                                                                                                                                                                                  overlayIndex: number;

                                                                                                                                                                                                                                                                                                                                                    method dismiss

                                                                                                                                                                                                                                                                                                                                                    dismiss: (data?: any, role?: string) => Promise<boolean>;

                                                                                                                                                                                                                                                                                                                                                      interface HTMLStencilElement

                                                                                                                                                                                                                                                                                                                                                      interface HTMLStencilElement extends HTMLElement {}

                                                                                                                                                                                                                                                                                                                                                        method componentOnReady

                                                                                                                                                                                                                                                                                                                                                        componentOnReady: () => Promise<this>;

                                                                                                                                                                                                                                                                                                                                                          interface InputChangeEventDetail

                                                                                                                                                                                                                                                                                                                                                          interface InputChangeEventDetail {}

                                                                                                                                                                                                                                                                                                                                                            property value

                                                                                                                                                                                                                                                                                                                                                            value: string | undefined | null;

                                                                                                                                                                                                                                                                                                                                                              interface IonicConfig

                                                                                                                                                                                                                                                                                                                                                              interface IonicConfig {}

                                                                                                                                                                                                                                                                                                                                                                property actionSheetEnter

                                                                                                                                                                                                                                                                                                                                                                actionSheetEnter?: AnimationBuilder;
                                                                                                                                                                                                                                                                                                                                                                • Provides a custom enter animation for all ion-action-sheet, overriding the default "animation".

                                                                                                                                                                                                                                                                                                                                                                property actionSheetLeave

                                                                                                                                                                                                                                                                                                                                                                actionSheetLeave?: AnimationBuilder;
                                                                                                                                                                                                                                                                                                                                                                • Provides a custom leave animation for all ion-action-sheet, overriding the default "animation".

                                                                                                                                                                                                                                                                                                                                                                property alertEnter

                                                                                                                                                                                                                                                                                                                                                                alertEnter?: AnimationBuilder;
                                                                                                                                                                                                                                                                                                                                                                • Provides a custom enter animation for all ion-alert, overriding the default "animation".

                                                                                                                                                                                                                                                                                                                                                                property alertLeave

                                                                                                                                                                                                                                                                                                                                                                alertLeave?: AnimationBuilder;
                                                                                                                                                                                                                                                                                                                                                                • Provides a custom leave animation for all ion-alert, overriding the default "animation".

                                                                                                                                                                                                                                                                                                                                                                property animated

                                                                                                                                                                                                                                                                                                                                                                animated?: boolean;
                                                                                                                                                                                                                                                                                                                                                                • When it's set to false, disables all animation and transition across the app. Can be useful to make ionic smoother in slow devices, when animations can't run smoothly.

                                                                                                                                                                                                                                                                                                                                                                property backButtonDefaultHref

                                                                                                                                                                                                                                                                                                                                                                backButtonDefaultHref?: string;
                                                                                                                                                                                                                                                                                                                                                                • Overrides the default defaultHref in all <ion-back-button> components.

                                                                                                                                                                                                                                                                                                                                                                property backButtonIcon

                                                                                                                                                                                                                                                                                                                                                                backButtonIcon?: string;
                                                                                                                                                                                                                                                                                                                                                                • Overrides the default icon in all <ion-back-button> components.

                                                                                                                                                                                                                                                                                                                                                                property backButtonText

                                                                                                                                                                                                                                                                                                                                                                backButtonText?: string;
                                                                                                                                                                                                                                                                                                                                                                • Overrides the default text in all <ion-back-button> components.

                                                                                                                                                                                                                                                                                                                                                                property experimentalTransitionShadow

                                                                                                                                                                                                                                                                                                                                                                experimentalTransitionShadow?: boolean;
                                                                                                                                                                                                                                                                                                                                                                • EXPERIMENTAL: Adds a page shadow to transitioning pages on iOS. Disabled by default.

                                                                                                                                                                                                                                                                                                                                                                property hardwareBackButton

                                                                                                                                                                                                                                                                                                                                                                hardwareBackButton?: boolean;
                                                                                                                                                                                                                                                                                                                                                                • Wherever ionic will respond to hardware go back buttons in an Android device. Defaults to true when ionic runs in a mobile device.

                                                                                                                                                                                                                                                                                                                                                                property hideCaretOnScroll

                                                                                                                                                                                                                                                                                                                                                                hideCaretOnScroll?: boolean;

                                                                                                                                                                                                                                                                                                                                                                  property infiniteLoadingSpinner

                                                                                                                                                                                                                                                                                                                                                                  infiniteLoadingSpinner?: SpinnerTypes | null;
                                                                                                                                                                                                                                                                                                                                                                  • Overrides the default spinner type in all <ion-infinite-scroll-content> components.

                                                                                                                                                                                                                                                                                                                                                                  property inputBlurring

                                                                                                                                                                                                                                                                                                                                                                  inputBlurring?: boolean;

                                                                                                                                                                                                                                                                                                                                                                    property inputShims

                                                                                                                                                                                                                                                                                                                                                                    inputShims?: boolean;

                                                                                                                                                                                                                                                                                                                                                                      property keyboardHeight

                                                                                                                                                                                                                                                                                                                                                                      keyboardHeight?: number;

                                                                                                                                                                                                                                                                                                                                                                        property loadingEnter

                                                                                                                                                                                                                                                                                                                                                                        loadingEnter?: AnimationBuilder;
                                                                                                                                                                                                                                                                                                                                                                        • Provides a custom enter animation for all ion-loading, overriding the default "animation".

                                                                                                                                                                                                                                                                                                                                                                        property loadingLeave

                                                                                                                                                                                                                                                                                                                                                                        loadingLeave?: AnimationBuilder;
                                                                                                                                                                                                                                                                                                                                                                        • Provides a custom leave animation for all ion-loading, overriding the default "animation".

                                                                                                                                                                                                                                                                                                                                                                        property loadingSpinner

                                                                                                                                                                                                                                                                                                                                                                        loadingSpinner?: SpinnerTypes | null;
                                                                                                                                                                                                                                                                                                                                                                        • Overrides the default spinner for all ion-loading overlays, ie. the ones created with ion-loading-controller.

                                                                                                                                                                                                                                                                                                                                                                        property menuIcon

                                                                                                                                                                                                                                                                                                                                                                        menuIcon?: string;
                                                                                                                                                                                                                                                                                                                                                                        • Overrides the default icon in all <ion-menu-button> components.

                                                                                                                                                                                                                                                                                                                                                                        property menuType

                                                                                                                                                                                                                                                                                                                                                                        menuType?: string;
                                                                                                                                                                                                                                                                                                                                                                        • Overrides the default menu type for all <ion-menu> components. By default the menu type is chosen based in the app's mode.

                                                                                                                                                                                                                                                                                                                                                                        property modalEnter

                                                                                                                                                                                                                                                                                                                                                                        modalEnter?: AnimationBuilder;
                                                                                                                                                                                                                                                                                                                                                                        • Provides a custom enter animation for all ion-modal, overriding the default "animation".

                                                                                                                                                                                                                                                                                                                                                                        property modalLeave

                                                                                                                                                                                                                                                                                                                                                                        modalLeave?: AnimationBuilder;
                                                                                                                                                                                                                                                                                                                                                                        • Provides a custom leave animation for all ion-modal, overriding the default "animation".

                                                                                                                                                                                                                                                                                                                                                                        property mode

                                                                                                                                                                                                                                                                                                                                                                        mode?: Mode;
                                                                                                                                                                                                                                                                                                                                                                        • The mode determines which platform styles to use for the whole application.

                                                                                                                                                                                                                                                                                                                                                                        property navAnimation

                                                                                                                                                                                                                                                                                                                                                                        navAnimation?: AnimationBuilder;
                                                                                                                                                                                                                                                                                                                                                                        • Overrides the default "animation" of all ion-nav and ion-router-outlet across the whole application. This prop allows to replace the default transition and provide a custom one that applies to all navigation outlets.

                                                                                                                                                                                                                                                                                                                                                                        property persistConfig

                                                                                                                                                                                                                                                                                                                                                                        persistConfig?: boolean;

                                                                                                                                                                                                                                                                                                                                                                          property pickerEnter

                                                                                                                                                                                                                                                                                                                                                                          pickerEnter?: AnimationBuilder;
                                                                                                                                                                                                                                                                                                                                                                          • Provides a custom enter animation for all ion-picker, overriding the default "animation".

                                                                                                                                                                                                                                                                                                                                                                          property pickerLeave

                                                                                                                                                                                                                                                                                                                                                                          pickerLeave?: AnimationBuilder;
                                                                                                                                                                                                                                                                                                                                                                          • Provides a custom leave animation for all ion-picker, overriding the default "animation".

                                                                                                                                                                                                                                                                                                                                                                          property popoverEnter

                                                                                                                                                                                                                                                                                                                                                                          popoverEnter?: AnimationBuilder;
                                                                                                                                                                                                                                                                                                                                                                          • Provides a custom enter animation for all ion-popover, overriding the default "animation".

                                                                                                                                                                                                                                                                                                                                                                          property popoverLeave

                                                                                                                                                                                                                                                                                                                                                                          popoverLeave?: AnimationBuilder;
                                                                                                                                                                                                                                                                                                                                                                          • Provides a custom leave animation for all ion-popover, overriding the default "animation".

                                                                                                                                                                                                                                                                                                                                                                          property refreshingIcon

                                                                                                                                                                                                                                                                                                                                                                          refreshingIcon?: string;
                                                                                                                                                                                                                                                                                                                                                                          • Overrides the default icon in all <ion-refresh-content> components.

                                                                                                                                                                                                                                                                                                                                                                          property refreshingSpinner

                                                                                                                                                                                                                                                                                                                                                                          refreshingSpinner?: SpinnerTypes | null;
                                                                                                                                                                                                                                                                                                                                                                          • Overrides the default spinner type in all <ion-refresh-content> components.

                                                                                                                                                                                                                                                                                                                                                                          property rippleEffect

                                                                                                                                                                                                                                                                                                                                                                          rippleEffect?: boolean;
                                                                                                                                                                                                                                                                                                                                                                          • When it's set to false, it disables all material-design ripple-effects across the app. Defaults to true.

                                                                                                                                                                                                                                                                                                                                                                          property sanitizerEnabled

                                                                                                                                                                                                                                                                                                                                                                          sanitizerEnabled?: boolean;
                                                                                                                                                                                                                                                                                                                                                                          • If true, Ionic will enable a basic DOM sanitizer on component properties that accept custom HTML.

                                                                                                                                                                                                                                                                                                                                                                          property scrollAssist

                                                                                                                                                                                                                                                                                                                                                                          scrollAssist?: boolean;

                                                                                                                                                                                                                                                                                                                                                                            property scrollPadding

                                                                                                                                                                                                                                                                                                                                                                            scrollPadding?: boolean;

                                                                                                                                                                                                                                                                                                                                                                              property spinner

                                                                                                                                                                                                                                                                                                                                                                              spinner?: SpinnerTypes;
                                                                                                                                                                                                                                                                                                                                                                              • Overrides the default spinner in all <ion-spinner> components. By default the spinner type is chosen based in the mode (ios or md).

                                                                                                                                                                                                                                                                                                                                                                              property statusTap

                                                                                                                                                                                                                                                                                                                                                                              statusTap?: boolean;
                                                                                                                                                                                                                                                                                                                                                                              • Whenever clicking the top status bar should cause the scroll to top in an application. Defaults to true when ionic runs in a mobile device.

                                                                                                                                                                                                                                                                                                                                                                              property swipeBackEnabled

                                                                                                                                                                                                                                                                                                                                                                              swipeBackEnabled?: boolean;
                                                                                                                                                                                                                                                                                                                                                                              • Global switch that disables or enables "swipe-to-go-back" gesture across all ion-nav in your application.

                                                                                                                                                                                                                                                                                                                                                                              property tabButtonLayout

                                                                                                                                                                                                                                                                                                                                                                              tabButtonLayout?: TabButtonLayout;
                                                                                                                                                                                                                                                                                                                                                                              • Overrides the default "layout" of all ion-bar-button across the whole application.

                                                                                                                                                                                                                                                                                                                                                                              property toastEnter

                                                                                                                                                                                                                                                                                                                                                                              toastEnter?: AnimationBuilder;
                                                                                                                                                                                                                                                                                                                                                                              • Provides a custom enter animation for all ion-toast, overriding the default "animation".

                                                                                                                                                                                                                                                                                                                                                                              property toastLeave

                                                                                                                                                                                                                                                                                                                                                                              toastLeave?: AnimationBuilder;
                                                                                                                                                                                                                                                                                                                                                                              • Provides a custom leave animation for all ion-toast, overriding the default "animation".

                                                                                                                                                                                                                                                                                                                                                                              interface ItemReorderEventDetail

                                                                                                                                                                                                                                                                                                                                                                              interface ItemReorderEventDetail {}

                                                                                                                                                                                                                                                                                                                                                                                property complete

                                                                                                                                                                                                                                                                                                                                                                                complete: (data?: boolean | any[]) => any;

                                                                                                                                                                                                                                                                                                                                                                                  property from

                                                                                                                                                                                                                                                                                                                                                                                  from: number;

                                                                                                                                                                                                                                                                                                                                                                                    property to

                                                                                                                                                                                                                                                                                                                                                                                    to: number;

                                                                                                                                                                                                                                                                                                                                                                                      interface KeyboardEventDetail

                                                                                                                                                                                                                                                                                                                                                                                      interface KeyboardEventDetail {}

                                                                                                                                                                                                                                                                                                                                                                                        property keyboardHeight

                                                                                                                                                                                                                                                                                                                                                                                        keyboardHeight: number;

                                                                                                                                                                                                                                                                                                                                                                                          interface LoadingOptions

                                                                                                                                                                                                                                                                                                                                                                                          interface LoadingOptions {}

                                                                                                                                                                                                                                                                                                                                                                                            property animated

                                                                                                                                                                                                                                                                                                                                                                                            animated?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                              property backdropDismiss

                                                                                                                                                                                                                                                                                                                                                                                              backdropDismiss?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                property cssClass

                                                                                                                                                                                                                                                                                                                                                                                                cssClass?: string | string[];

                                                                                                                                                                                                                                                                                                                                                                                                  property duration

                                                                                                                                                                                                                                                                                                                                                                                                  duration?: number;

                                                                                                                                                                                                                                                                                                                                                                                                    property enterAnimation

                                                                                                                                                                                                                                                                                                                                                                                                    enterAnimation?: AnimationBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                      property id

                                                                                                                                                                                                                                                                                                                                                                                                      id?: string;

                                                                                                                                                                                                                                                                                                                                                                                                        property keyboardClose

                                                                                                                                                                                                                                                                                                                                                                                                        keyboardClose?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                          property leaveAnimation

                                                                                                                                                                                                                                                                                                                                                                                                          leaveAnimation?: AnimationBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                            property message

                                                                                                                                                                                                                                                                                                                                                                                                            message?: string | IonicSafeString;

                                                                                                                                                                                                                                                                                                                                                                                                              property mode

                                                                                                                                                                                                                                                                                                                                                                                                              mode?: Mode;

                                                                                                                                                                                                                                                                                                                                                                                                                property showBackdrop

                                                                                                                                                                                                                                                                                                                                                                                                                showBackdrop?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                  property spinner

                                                                                                                                                                                                                                                                                                                                                                                                                  spinner?: SpinnerTypes | null;

                                                                                                                                                                                                                                                                                                                                                                                                                    property translucent

                                                                                                                                                                                                                                                                                                                                                                                                                    translucent?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                      interface MenuChangeEventDetail {}
                                                                                                                                                                                                                                                                                                                                                                                                                        disabled: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                          open: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                            interface MenuControllerI {}
                                                                                                                                                                                                                                                                                                                                                                                                                              getMenus: () => Promise<HTMLIonMenuElement[]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                getOpenSync: () => HTMLIonMenuElement | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                  interface MenuI {}
                                                                                                                                                                                                                                                                                                                                                                                                                                    backdropEl?: HTMLElement;
                                                                                                                                                                                                                                                                                                                                                                                                                                      contentEl?: HTMLElement;
                                                                                                                                                                                                                                                                                                                                                                                                                                        disabled: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                          el: HTMLIonMenuElement;
                                                                                                                                                                                                                                                                                                                                                                                                                                            isAnimating: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                              isEndSide: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                menuCtrl?: MenuControllerI;
                                                                                                                                                                                                                                                                                                                                                                                                                                                  menuId?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                    menuInnerEl?: HTMLElement;
                                                                                                                                                                                                                                                                                                                                                                                                                                                      side: Side;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        width: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                          close: (animated?: boolean) => Promise<boolean>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                            isActive: () => Promise<boolean>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                              open: (animated?: boolean) => Promise<boolean>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                setOpen: (shouldOpen: boolean, animated?: boolean) => Promise<boolean>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  toggle: (animated?: boolean) => Promise<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ModalOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ModalOptions<T extends ComponentRef = ComponentRef> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property animated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      animated?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property backdropDismiss

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        backdropDismiss?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property component

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          component: T;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property componentProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            componentProps?: ComponentProps<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property cssClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              cssClass?: string | string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property delegate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                delegate?: FrameworkDelegate;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property enterAnimation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  enterAnimation?: AnimationBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    id?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property keyboardClose

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      keyboardClose?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property leaveAnimation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        leaveAnimation?: AnimationBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property mode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          mode?: Mode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property presentingElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            presentingElement?: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property showBackdrop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              showBackdrop?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property swipeToClose

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                swipeToClose?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface NavComponentWithProps<T = any> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    component: NavComponent;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      componentProps?: ComponentProps<T> | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface NavOptions extends RouterOutletOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          delegate?: FrameworkDelegate;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            progressAnimation?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              updateURL?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                viewIsReady?: (enteringEl: HTMLElement) => Promise<any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface NavOutlet {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getRouteId: () => Promise<RouteID | undefined>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      setRouteId: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      id: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      params: ComponentProps | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      direction: RouterDirection,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      animation?: AnimationBuilder
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<RouteWrite>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface NavResult {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          direction?: NavDirection;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            enteringView?: ViewController;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              hasCompleted: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                leavingView?: ViewController;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  requiresTransition: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface OverlayController

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface OverlayController {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      create: (opts?: any) => Promise<HTMLElement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method dismiss

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        dismiss: (data?: any, role?: string, id?: string) => Promise<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getTop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getTop: () => Promise<HTMLIonOverlayElement | undefined>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface OverlayEventDetail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface OverlayEventDetail<T = any> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              data?: T;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property role

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                role?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface OverlayInterface

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface OverlayInterface {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property animated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    animated: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property didDismiss

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      didDismiss: EventEmitter<OverlayEventDetail>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property didPresent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        didPresent: EventEmitter<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property el

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          el: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property enterAnimation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            enterAnimation?: AnimationBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property keyboardClose

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              keyboardClose: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property leaveAnimation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                leaveAnimation?: AnimationBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property overlayIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  overlayIndex: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property presented

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    presented: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property willDismiss

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      willDismiss: EventEmitter<OverlayEventDetail>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property willPresent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        willPresent: EventEmitter<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method dismiss

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          dismiss: (data?: any, role?: string) => Promise<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method present

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            present: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ParsedRoute

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ParsedRoute {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property queryString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                queryString?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property segments

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  segments: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface PickerButton

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface PickerButton {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property cssClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      cssClass?: string | string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property handler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        handler?: (value: any) => boolean | void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property role

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          role?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property text

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            text?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface PickerColumn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface PickerColumn {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property align

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                align?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property columnWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  columnWidth?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property cssClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cssClass?: string | string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        options: PickerColumnOption[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property optionsWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          optionsWidth?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property prefix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            prefix?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property prefixWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              prefixWidth?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property prevSelected

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                prevSelected?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property refresh

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  refresh?: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property selectedIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    selectedIndex?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property suffix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      suffix?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property suffixWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        suffixWidth?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface PickerColumnOption

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface PickerColumnOption {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property disabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            disabled?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property duration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              duration?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property selected

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                selected?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property text

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  text?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property transform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    transform?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      value?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface PickerOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface PickerOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property animated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          animated?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property backdropDismiss

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            backdropDismiss?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property buttons

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              buttons?: PickerButton[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property columns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                columns: PickerColumn[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property cssClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  cssClass?: string | string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property enterAnimation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    enterAnimation?: AnimationBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      id?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property keyboardClose

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        keyboardClose?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property leaveAnimation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          leaveAnimation?: AnimationBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property mode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            mode?: Mode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property showBackdrop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              showBackdrop?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface PopoverOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface PopoverOptions<T extends ComponentRef = ComponentRef> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property animated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  animated?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property backdropDismiss

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    backdropDismiss?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property component

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      component: T;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property componentProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        componentProps?: ComponentProps<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property cssClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          cssClass?: string | string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property delegate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            delegate?: FrameworkDelegate;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property enterAnimation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              enterAnimation?: AnimationBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property event

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                event?: Event;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  id?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property keyboardClose

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    keyboardClose?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property leaveAnimation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      leaveAnimation?: AnimationBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property mode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        mode?: Mode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property showBackdrop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          showBackdrop?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property translucent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            translucent?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface RadioChangeEventDetail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface RadioChangeEventDetail {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property checked

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                checked: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  value: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface RadioGroupChangeEventDetail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface RadioGroupChangeEventDetail {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      value: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface RangeChangeEventDetail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface RangeChangeEventDetail {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          value: RangeValue;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface RefresherEventDetail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface RefresherEventDetail {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method complete

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              complete: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface RouteEntry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface RouteEntry {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property beforeEnter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  beforeEnter?: NavigationHookCallback;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property beforeLeave

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    beforeLeave?: NavigationHookCallback;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property params

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        params:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          path: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface RouteID

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface RouteID {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property element

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              element: HTMLElement | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property params

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  params?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface RouteNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface RouteNode extends RouteEntry {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property children

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      children: RouteTree;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface RouteRedirect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface RouteRedirect {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property from

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          from: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property to

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            to?: ParsedRoute;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface RouterEventDetail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface RouterEventDetail {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property from

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                from: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property redirectedFrom

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  redirectedFrom: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property to

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    to: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface RouterOutletOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface RouterOutletOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property animated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        animated?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property animationBuilder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          animationBuilder?: AnimationBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property deepWait

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            deepWait?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property direction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              direction?: NavDirection;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property duration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                duration?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property easing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  easing?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property keyboardClose

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    keyboardClose?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property mode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      mode?: Mode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property progressAnimation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        progressAnimation?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property showGoBack

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          showGoBack?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property skipIfBusy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            skipIfBusy?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface RouteWrite

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface RouteWrite {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property changed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                changed: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property element

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  element: HTMLElement | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property markVisible

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    markVisible?: () => void | Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ScrollBaseDetail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ScrollBaseDetail {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property isScrolling

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isScrolling: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ScrollDetail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ScrollDetail extends GestureDetail, ScrollBaseDetail {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property scrollLeft

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            scrollLeft: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property scrollTop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              scrollTop: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface SearchbarChangeEventDetail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface SearchbarChangeEventDetail {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  value: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SegmentChangeEventDetail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SegmentChangeEventDetail {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      value: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface SelectChangeEventDetail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface SelectChangeEventDetail<T = any> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          value: T;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface SelectPopoverOption

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface SelectPopoverOption {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property checked

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              checked: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property cssClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                cssClass?: string | string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property disabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  disabled: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property handler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    handler?: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property text

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      text: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        value: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface SpinnerConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface SpinnerConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property circles

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            circles?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property dur

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              dur: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property elmDuration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                elmDuration?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property fn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  fn: (dur: number, index: number, total: number) => SpinnerData;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property lines

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    lines?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface SpinnerConfigs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface SpinnerConfigs {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [spinnerName: string]: SpinnerConfig;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface SpinnerData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface SpinnerData {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property cx

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            cx?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property cy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              cy?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property r

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                r?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property style

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  style: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property transform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    transform?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property viewBox

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      viewBox?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property y1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        y1?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property y2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          y2?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface StyleEventDetail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface StyleEventDetail {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [styleName: string]: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface SwipeGestureHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface SwipeGestureHandler {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method canStart

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  canStart: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method onEnd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onEnd: (shouldComplete: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method onStart

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onStart: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TabBarChangedEventDetail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TabBarChangedEventDetail {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property tab

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          tab?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface TabButtonClickEventDetail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface TabButtonClickEventDetail {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property href

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              href?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property selected

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                selected: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property tab

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  tab: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface TextareaChangeEventDetail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface TextareaChangeEventDetail {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      value: string | undefined | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ToastButton

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ToastButton {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property cssClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          cssClass?: string | string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property handler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            handler?: () => boolean | void | Promise<boolean | void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property icon

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              icon?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property role

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                role?: 'cancel' | string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property side

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  side?: 'start' | 'end';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property text

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    text?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ToastOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ToastOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property animated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        animated?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property buttons

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          buttons?: (ToastButton | string)[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property color

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            color?: Color;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property cssClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              cssClass?: string | string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property duration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                duration?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property enterAnimation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  enterAnimation?: AnimationBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property header

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    header?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      id?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property keyboardClose

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        keyboardClose?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property leaveAnimation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          leaveAnimation?: AnimationBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property message

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            message?: string | IonicSafeString;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property mode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              mode?: Mode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property position

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                position?: 'top' | 'bottom' | 'middle';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property translucent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  translucent?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ToggleChangeEventDetail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ToggleChangeEventDetail {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property checked

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      checked: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        value: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface TransitionInstruction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface TransitionInstruction {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property done

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            done?: TransitionDoneFn;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property enteringRequiresTransition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              enteringRequiresTransition?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property insertStart

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                insertStart?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property insertViews

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  insertViews?: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property leavingRequiresTransition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    leavingRequiresTransition?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property opts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      opts: NavOptions | undefined | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property reject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        reject?: (rejectReason: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property removeCount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          removeCount?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property removeStart

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            removeStart?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property removeView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              removeView?: ViewController;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property resolve

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                resolve?: (hasCompleted: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface VirtualNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface VirtualNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property cell

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cell: Cell;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property change

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      change: NodeChange;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property d

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        d: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property top

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          top: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property visible

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            visible: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type AnimationBuilder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type AnimationBuilder = (baseEl: any, opts?: any) => Animation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type AnimationDirection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type AnimationDirection = 'normal' | 'reverse' | 'alternate' | 'alternate-reverse';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type AnimationFill

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type AnimationFill = 'auto' | 'none' | 'forwards' | 'backwards' | 'both';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type AnimationKeyFrames

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type AnimationKeyFrames =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | [AnimationKeyFrameEdge, AnimationKeyFrameEdge]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | AnimationKeyFrame[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type AnimationLifecycle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type AnimationLifecycle = (currentStep: 0 | 1, animation: Animation) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type AutocompleteTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type AutocompleteTypes =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'on'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'off'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'name'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'honorific-prefix'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'given-name'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'additional-name'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'family-name'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'honorific-suffix'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'nickname'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'email'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'username'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'new-password'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'current-password'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'one-time-code'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'organization-title'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'organization'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'street-address'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'address-line1'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'address-line2'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'address-line3'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'address-level4'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'address-level3'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'address-level2'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'address-level1'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'country'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'country-name'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'postal-code'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'cc-name'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'cc-given-name'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'cc-additional-name'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'cc-family-name'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'cc-family-name'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'cc-number'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'cc-exp'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'cc-exp-month'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'cc-exp-year'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'cc-csc'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'cc-type'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'transaction-currency'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'transaction-amount'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'language'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'bday'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'bday-day'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'bday-month'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'bday-year'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'sex'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'tel'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'tel-country-code'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'tel-national'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'tel-area-code'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'tel-local'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'tel-extension'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'impp'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'url'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'photo';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type BackButtonEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type BackButtonEvent = CustomEvent<BackButtonEventDetail>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type CellType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type CellType = 'item' | 'header' | 'footer';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type Color

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type Color = PredefinedColors | string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ComponentProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ComponentProps<T = null> = { [key: string]: any };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ComponentRef

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ComponentRef = Function | HTMLElement | string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ComponentTags

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ComponentTags = string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CssClassMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CssClassMap = { [className: string]: boolean };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DatetimeOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DatetimeOptions = Partial<PickerOptions>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type DomRenderFn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type DomRenderFn = (dom: VirtualNode[]) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type FooterHeightFn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type FooterHeightFn = (item: any, index: number) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type HeaderFn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type HeaderFn = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              item: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              index: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              items: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => string | null | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type HeaderHeightFn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type HeaderHeightFn = (item: any, index: number) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ItemHeightFn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ItemHeightFn = (item: any, index: number) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ItemRenderFn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ItemRenderFn = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    el: HTMLElement | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cell: Cell,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    domIndex: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type KnobName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type KnobName = 'A' | 'B' | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Mode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Mode = 'ios' | 'md';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type NavComponent = ComponentRef | ViewController;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type NavDirection = 'back' | 'forward';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type NavOutletElement = NavOutlet & HTMLStencilElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type NodeChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type NodeChange = number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type OverlaySelect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type OverlaySelect =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | HTMLIonActionSheetElement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | HTMLIonAlertElement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | HTMLIonPopoverElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type Page = new (...args: any[]) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Platforms

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Platforms = keyof typeof PLATFORMS_MAP;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type PredefinedColors

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type PredefinedColors =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'primary'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'secondary'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'tertiary'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'success'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'warning'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'danger'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'light'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'medium'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'dark';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type RangeValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type RangeValue =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          lower: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          upper: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type RouteChain

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type RouteChain = RouteEntry[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type RouterDirection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type RouterDirection = 'forward' | 'back' | 'root';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type RouteTree

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type RouteTree = RouteNode[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ScrollCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ScrollCallback = (detail?: ScrollDetail) => boolean | void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type SegmentButtonLayout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type SegmentButtonLayout =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'icon-top'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'icon-start'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'icon-end'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'icon-bottom'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'icon-hide'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'label-hide';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type SelectCompareFn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type SelectCompareFn = (currentValue: any, compareValue: any) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SelectInterface

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SelectInterface = 'action-sheet' | 'popover' | 'alert';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Side

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Side = 'start' | 'end';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type SpinnerTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type SpinnerTypes = keyof typeof spinners;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type TabButtonLayout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type TabButtonLayout =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'icon-top'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'icon-start'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'icon-end'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'icon-bottom'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'icon-hide'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'label-hide';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type TextFieldTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type TextFieldTypes =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'date'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'email'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'number'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'password'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'search'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'tel'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'text'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'url'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'time'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'week'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'month'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'datetime-local';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type TransitionDoneFn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type TransitionDoneFn = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  hasCompleted: boolean,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  requiresTransition: boolean,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  enteringView?: ViewController,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  leavingView?: ViewController,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  direction?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => void;<