@ionic/core

  • Version 6.0.12
  • Published
  • 17.1 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 IonicSwiper

        const IonicSwiper: { name: string; on: { afterInit(swiper: any): void } };

          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 IonicSlides

                                                IonicSlides: (opts: any) => 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 AccordionGroupChangeEventDetail

                                                                                                interface AccordionGroupChangeEventDetail<T = any> {}

                                                                                                  property value

                                                                                                  value: T;

                                                                                                    interface AccordionGroupCustomEvent

                                                                                                    interface AccordionGroupCustomEvent<T = any> extends CustomEvent {}

                                                                                                      property detail

                                                                                                      detail: AccordionGroupChangeEventDetail<T>;

                                                                                                        property target

                                                                                                        target: HTMLIonAccordionGroupElement;

                                                                                                          interface ActionSheetAttributes

                                                                                                          interface ActionSheetAttributes extends JSXBase.HTMLAttributes<HTMLElement> {}

                                                                                                            interface ActionSheetButton

                                                                                                            interface ActionSheetButton<T = any> {}

                                                                                                              property cssClass

                                                                                                              cssClass?: string | string[];

                                                                                                                property data

                                                                                                                data?: T;

                                                                                                                  property handler

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

                                                                                                                    property icon

                                                                                                                    icon?: string;

                                                                                                                      property id

                                                                                                                      id?: 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 htmlAttributes

                                                                                                                                          htmlAttributes?: ActionSheetAttributes;

                                                                                                                                            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 AlertAttributes

                                                                                                                                                        interface AlertAttributes extends JSXBase.HTMLAttributes<HTMLElement> {}

                                                                                                                                                          interface AlertButton

                                                                                                                                                          interface AlertButton {}

                                                                                                                                                            property cssClass

                                                                                                                                                            cssClass?: string | string[];

                                                                                                                                                              property handler

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

                                                                                                                                                                property id

                                                                                                                                                                id?: string;

                                                                                                                                                                  property role

                                                                                                                                                                  role?: 'cancel' | 'destructive' | 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 htmlAttributes

                                                                                                                                                                                                                    htmlAttributes?: AlertAttributes;

                                                                                                                                                                                                                      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
                                                                                                                                                                                                                                                      ) => Animation;

                                                                                                                                                                                                                                                        method progressStart

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

                                                                                                                                                                                                                                                          method progressStep

                                                                                                                                                                                                                                                          progressStep: (step: number) => Animation;

                                                                                                                                                                                                                                                            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 BreadcrumbCollapsedClickEventDetail {}
                                                                                                                                                                                                                                                                        collapsedBreadcrumbs?: HTMLIonBreadcrumbElement[];
                                                                                                                                                                                                                                                                          ionShadowTarget?: HTMLElement;
                                                                                                                                                                                                                                                                            interface BreadcrumbCustomEvent extends CustomEvent {}
                                                                                                                                                                                                                                                                              detail: BreadcrumbCollapsedClickEventDetail;
                                                                                                                                                                                                                                                                                target: HTMLIonBreadcrumbElement;

                                                                                                                                                                                                                                                                                  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<T = any> {}

                                                                                                                                                                                                                                                                                                    property checked

                                                                                                                                                                                                                                                                                                    checked: boolean;

                                                                                                                                                                                                                                                                                                      property value

                                                                                                                                                                                                                                                                                                      value: T;

                                                                                                                                                                                                                                                                                                        interface CheckboxCustomEvent

                                                                                                                                                                                                                                                                                                        interface CheckboxCustomEvent<T = any> extends CustomEvent {}

                                                                                                                                                                                                                                                                                                          property detail

                                                                                                                                                                                                                                                                                                          detail: CheckboxChangeEventDetail<T>;

                                                                                                                                                                                                                                                                                                            property target

                                                                                                                                                                                                                                                                                                            target: HTMLIonCheckboxElement;

                                                                                                                                                                                                                                                                                                              interface DatetimeChangeEventDetail

                                                                                                                                                                                                                                                                                                              interface DatetimeChangeEventDetail {}

                                                                                                                                                                                                                                                                                                                property value

                                                                                                                                                                                                                                                                                                                value?: string | null;

                                                                                                                                                                                                                                                                                                                  interface DatetimeCustomEvent

                                                                                                                                                                                                                                                                                                                  interface DatetimeCustomEvent extends CustomEvent {}

                                                                                                                                                                                                                                                                                                                    property detail

                                                                                                                                                                                                                                                                                                                    detail: DatetimeChangeEventDetail;

                                                                                                                                                                                                                                                                                                                      property target

                                                                                                                                                                                                                                                                                                                      target: HTMLIonDatetimeElement;

                                                                                                                                                                                                                                                                                                                        interface DatetimeOptions

                                                                                                                                                                                                                                                                                                                        interface DatetimeOptions {}

                                                                                                                                                                                                                                                                                                                          property tmp

                                                                                                                                                                                                                                                                                                                          tmp?: string;

                                                                                                                                                                                                                                                                                                                            interface DatetimeParts

                                                                                                                                                                                                                                                                                                                            interface DatetimeParts {}

                                                                                                                                                                                                                                                                                                                              property ampm

                                                                                                                                                                                                                                                                                                                              ampm?: 'am' | 'pm';

                                                                                                                                                                                                                                                                                                                                property day

                                                                                                                                                                                                                                                                                                                                day: number | null;

                                                                                                                                                                                                                                                                                                                                  property dayOfWeek

                                                                                                                                                                                                                                                                                                                                  dayOfWeek?: number | null;

                                                                                                                                                                                                                                                                                                                                    property hour

                                                                                                                                                                                                                                                                                                                                    hour?: number;

                                                                                                                                                                                                                                                                                                                                      property minute

                                                                                                                                                                                                                                                                                                                                      minute?: number;

                                                                                                                                                                                                                                                                                                                                        property month

                                                                                                                                                                                                                                                                                                                                        month: number;

                                                                                                                                                                                                                                                                                                                                          property tzOffset

                                                                                                                                                                                                                                                                                                                                          tzOffset?: number;

                                                                                                                                                                                                                                                                                                                                            property year

                                                                                                                                                                                                                                                                                                                                            year: number;

                                                                                                                                                                                                                                                                                                                                              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;

                                                                                                                                                                                                                                                                                                                                                                                          index signature

                                                                                                                                                                                                                                                                                                                                                                                          [index: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                            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 InfiniteScrollCustomEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                      interface InfiniteScrollCustomEvent extends CustomEvent {}

                                                                                                                                                                                                                                                                                                                                                                                                                                        property target

                                                                                                                                                                                                                                                                                                                                                                                                                                        target: HTMLIonInfiniteScrollElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                          interface InputChangeEventDetail

                                                                                                                                                                                                                                                                                                                                                                                                                                          interface InputChangeEventDetail {}

                                                                                                                                                                                                                                                                                                                                                                                                                                            property value

                                                                                                                                                                                                                                                                                                                                                                                                                                            value: string | undefined | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                              interface InputCustomEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                              interface InputCustomEvent extends CustomEvent {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                property detail

                                                                                                                                                                                                                                                                                                                                                                                                                                                detail: InputChangeEventDetail;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property target

                                                                                                                                                                                                                                                                                                                                                                                                                                                  target: HTMLIonInputElement;

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                platform?: PlatformConfig;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Overrides the default platform detection methods.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                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 ItemReorderCustomEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ItemReorderCustomEvent extends CustomEvent {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property detail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      detail: ItemReorderEventDetail;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property target

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        target: HTMLIonReorderGroupElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ItemReorderEventDetail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ItemReorderEventDetail {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property complete

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property from

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              from: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property to

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                to: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ItemSlidingCustomEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ItemSlidingCustomEvent extends CustomEvent {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property target

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    target: HTMLIonItemSlidingElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface KeyboardEventDetail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface KeyboardEventDetail {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property keyboardHeight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        keyboardHeight: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface LoadingAttributes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface LoadingAttributes extends JSXBase.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            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 htmlAttributes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        htmlAttributes?: LoadingAttributes;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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 MenuCustomEvent<T = any> extends CustomEvent {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        detail: T;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          target: HTMLIonMenuElement;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            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 ModalAnimationOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ModalAnimationOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property backdropBreakpoint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                backdropBreakpoint?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property currentBreakpoint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  currentBreakpoint?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property presentingEl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    presentingEl?: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ModalAttributes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ModalAttributes extends JSXBase.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ModalOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ModalOptions<T extends ComponentRef = ComponentRef> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property animated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          animated?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property backdropBreakpoint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            backdropBreakpoint?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property backdropDismiss

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              backdropDismiss?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property breakpoints

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                breakpoints?: number[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property component

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  component: T;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property componentProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    componentProps?: ComponentProps<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property cssClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      cssClass?: string | string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property delegate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        delegate?: FrameworkDelegate;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property enterAnimation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          enterAnimation?: AnimationBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property handle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            handle?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property htmlAttributes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              htmlAttributes?: ModalAttributes;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                id?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property initialBreakpoint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  initialBreakpoint?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    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 NavCustomEvent extends CustomEvent {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        target: HTMLIonNavElement;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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 didDismissShorthand

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          didDismissShorthand?: EventEmitter<OverlayEventDetail>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property didPresent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            didPresent: EventEmitter<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property didPresentShorthand

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              didPresentShorthand?: 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 willDismissShorthand

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              willDismissShorthand?: EventEmitter<OverlayEventDetail>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property willPresent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                willPresent: EventEmitter<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property willPresentShorthand

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  willPresentShorthand?: EventEmitter<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method dismiss

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method present

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      present: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ParsedRoute

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ParsedRoute {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property queryString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          queryString?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Unparsed query string.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property segments

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          segments: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Parts of the route (non empty "/" separated parts of an URL).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface PickerAttributes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface PickerAttributes extends JSXBase.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            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 htmlAttributes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              htmlAttributes?: PickerAttributes;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                id?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property keyboardClose

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  keyboardClose?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property leaveAnimation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    leaveAnimation?: AnimationBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property mode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      mode?: Mode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property showBackdrop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        showBackdrop?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface PopoverAttributes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface PopoverAttributes extends JSXBase.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface PopoverInterface

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface PopoverInterface extends OverlayInterface {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property present

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              present: (event?: MouseEvent | TouchEvent | PointerEvent) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface PopoverOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface PopoverOptions<T extends ComponentRef = ComponentRef> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property alignment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  alignment?: PositionAlign;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property animated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    animated?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property arrow

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      arrow?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property backdropDismiss

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        backdropDismiss?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property component

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          component: T;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property componentProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            componentProps?: ComponentProps<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property cssClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              cssClass?: string | string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property delegate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                delegate?: FrameworkDelegate;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property dismissOnSelect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  dismissOnSelect?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property enterAnimation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    enterAnimation?: AnimationBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property event

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      event?: Event;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property htmlAttributes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        htmlAttributes?: PopoverAttributes;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          id?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property keyboardClose

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            keyboardClose?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property leaveAnimation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              leaveAnimation?: AnimationBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property mode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                mode?: Mode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property reference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  reference?: PositionReference;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property showBackdrop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    showBackdrop?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property side

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      side?: PositionSide;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property size

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        size?: PopoverSize;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property translucent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          translucent?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property trigger

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            trigger?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property triggerAction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              triggerAction?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface RadioGroupChangeEventDetail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface RadioGroupChangeEventDetail<T = any> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  value: T;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface RadioGroupCustomEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface RadioGroupCustomEvent<T = any> extends CustomEvent {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property detail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      detail: RadioGroupChangeEventDetail<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property target

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        target: HTMLIonRadioGroupElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface RangeChangeEventDetail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface RangeChangeEventDetail {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: RangeValue;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface RangeCustomEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface RangeCustomEvent extends CustomEvent {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property detail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                detail: RangeChangeEventDetail;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property target

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  target: HTMLIonRangeElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface RefresherCustomEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface RefresherCustomEvent extends CustomEvent {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property detail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      detail: RefresherEventDetail;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property target

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        target: HTMLIonRefresherElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface RefresherEventDetail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface RefresherEventDetail {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method complete

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            complete: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface RouteEntry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface RouteEntry {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property beforeEnter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                beforeEnter?: NavigationHookCallback;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property beforeLeave

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  beforeLeave?: NavigationHookCallback;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    id: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Component tag name or tab name.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property params

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property segments

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      segments: 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 RouterCustomEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface RouterCustomEvent extends CustomEvent {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property detail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      detail: RouterEventDetail;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property target

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        target: HTMLIonRouterElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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 ScrollBaseCustomEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ScrollBaseCustomEvent extends CustomEvent {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property detail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          detail: ScrollBaseDetail;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property target

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            target: HTMLIonContentElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ScrollBaseDetail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ScrollBaseDetail {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property isScrolling

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isScrolling: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ScrollCustomEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ScrollCustomEvent extends ScrollBaseCustomEvent {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property detail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    detail: ScrollDetail;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ScrollDetail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ScrollDetail extends GestureDetail, ScrollBaseDetail {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property scrollLeft

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        scrollLeft: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property scrollTop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          scrollTop: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface SearchbarChangeEventDetail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface SearchbarChangeEventDetail {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              value?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface SearchbarCustomEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface SearchbarCustomEvent extends CustomEvent {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property detail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  detail: SearchbarChangeEventDetail;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property target

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    target: HTMLIonSearchbarElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface SegmentChangeEventDetail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface SegmentChangeEventDetail {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        value?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface SegmentCustomEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface SegmentCustomEvent extends CustomEvent {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property detail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            detail: SegmentChangeEventDetail;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property target

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              target: HTMLIonSegmentElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface SelectChangeEventDetail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface SelectChangeEventDetail<T = any> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  value: T;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SelectCustomEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SelectCustomEvent<T = any> extends CustomEvent {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property detail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      detail: SelectChangeEventDetail<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property target

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        target: HTMLIonSelectElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface SelectPopoverOption

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface SelectPopoverOption {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property checked

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            checked: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property cssClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              cssClass?: string | string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property disabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                disabled: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property handler

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    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