@ionic/angular 7.3.4-dev.11695654072.17597cce → 7.3.4-dev.11696436834.1e83c799

package/README.md

@@ -52,3 +52,23 @@ $ npx schematics @ionic/angular:ng-add
 
 
 You'll now be able to add ionic components to a vanilla Angular app setup.
+
+## Project Structure
+
+**common**
+
+This is where logic that is shared between lazy loaded and standalone components live. For example, the lazy loaded IonPopover and standalone IonPopover components extend from a base IonPopover implementation that exists in this directory.
+
+**Note:** This directory exposes internal APIs and is only accessed in the `standalone` and `src` submodules. Ionic developers should never import directly from `@ionic/angular/common`. Instead, they should import from `@ionic/angular` or `@ionic/angular/standalone`.
+
+**standalone**
+
+This is where the standalone component implementations live. It was added as a separate entry point to avoid any lazy loaded logic from accidentally being pulled in to the final build. Having a separate directory allows the lazy loaded implementation to remain accessible from `@ionic/angular` for backwards compatibility.
+
+Ionic developers can access this by importing from `@ionic/angular/standalone`.
+
+**src**
+
+This is where the lazy loaded component implementations live.
+
+Ionic developers can access this by importing from `@ionic/angular`.

package/app-initialize.d.ts

@@ -1,3 +1,3 @@
 import { NgZone } from '@angular/core';
-import { Config } from './providers/config';
+import type { Config } from '@ionic/angular/common';
 export declare const appInitialize: (config: Config, doc: Document, zone: NgZone) => () => any;

package/common/directives/control-value-accessors/index.d.ts

@@ -0,0 +1 @@
+export * from './value-accessor';

package/{directives → common/directives}/control-value-accessors/value-accessor.d.ts

@@ -3,12 +3,12 @@ import { ControlValueAccessor } from '@angular/forms';
 import * as i0 from "@angular/core";
 export declare class ValueAccessor implements ControlValueAccessor, AfterViewInit, OnDestroy {
     protected injector: Injector;
-    protected el: ElementRef;
+    protected elementRef: ElementRef;
     private onChange;
     private onTouched;
     protected lastValue: any;
     private statusChanges?;
-    constructor(injector: Injector, el: ElementRef);
+    constructor(injector: Injector, elementRef: ElementRef);
     writeValue(value: any): void;
     /**
      * Notifies the ControlValueAccessor of a change in the value of the control.

package/common/directives/navigation/back-button.d.ts

@@ -0,0 +1,26 @@
+import { ElementRef, NgZone, ChangeDetectorRef } from '@angular/core';
+import type { Components } from '@ionic/core';
+import type { AnimationBuilder } from '@ionic/core/components';
+import { Config } from '../../providers/config';
+import { NavController } from '../../providers/nav-controller';
+import { IonRouterOutlet } from './router-outlet';
+import * as i0 from "@angular/core";
+export declare interface IonBackButton extends Components.IonBackButton {
+}
+export declare class IonBackButton {
+    private routerOutlet;
+    private navCtrl;
+    private config;
+    private r;
+    protected z: NgZone;
+    defaultHref: string | undefined;
+    routerAnimation: AnimationBuilder | undefined;
+    protected el: HTMLElement;
+    constructor(routerOutlet: IonRouterOutlet, navCtrl: NavController, config: Config, r: ElementRef, z: NgZone, c: ChangeDetectorRef);
+    /**
+     * @internal
+     */
+    onClick(ev: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IonBackButton, [{ optional: true; }, null, null, null, null, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<IonBackButton, never, never, { "color": "color"; "defaultHref": "defaultHref"; "disabled": "disabled"; "icon": "icon"; "mode": "mode"; "routerAnimation": "routerAnimation"; "text": "text"; "type": "type"; }, {}, never, never, false>;
+}

package/common/directives/navigation/nav.d.ts

@@ -0,0 +1,13 @@
+import { ElementRef, Injector, EnvironmentInjector, NgZone, ChangeDetectorRef } from '@angular/core';
+import type { Components } from '@ionic/core';
+import { AngularDelegate } from '../../providers/angular-delegate';
+import * as i0 from "@angular/core";
+export declare interface IonNav extends Components.IonNav {
+}
+export declare class IonNav {
+    protected z: NgZone;
+    protected el: HTMLElement;
+    constructor(ref: ElementRef, environmentInjector: EnvironmentInjector, injector: Injector, angularDelegate: AngularDelegate, z: NgZone, c: ChangeDetectorRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<IonNav, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<IonNav, never, never, { "animated": "animated"; "animation": "animation"; "root": "root"; "rootParams": "rootParams"; "swipeGesture": "swipeGesture"; }, {}, never, never, false>;
+}

package/common/directives/navigation/router-link-delegate.d.ts

@@ -0,0 +1,50 @@
+import { LocationStrategy } from '@angular/common';
+import { ElementRef, OnChanges, OnInit } from '@angular/core';
+import { Router, RouterLink } from '@angular/router';
+import type { AnimationBuilder, RouterDirection } from '@ionic/core/components';
+import { NavController } from '../../providers/nav-controller';
+import * as i0 from "@angular/core";
+/**
+ * Adds support for Ionic routing directions and animations to the base Angular router link directive.
+ *
+ * When the router link is clicked, the directive will assign the direction and
+ * animation so that the routing integration will transition correctly.
+ */
+export declare class RouterLinkDelegateDirective implements OnInit, OnChanges {
+    private locationStrategy;
+    private navCtrl;
+    private elementRef;
+    private router;
+    private routerLink?;
+    routerDirection: RouterDirection;
+    routerAnimation?: AnimationBuilder;
+    constructor(locationStrategy: LocationStrategy, navCtrl: NavController, elementRef: ElementRef, router: Router, routerLink?: RouterLink | undefined);
+    ngOnInit(): void;
+    ngOnChanges(): void;
+    private updateTargetUrlAndHref;
+    /**
+     * @internal
+     */
+    onClick(ev: UIEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RouterLinkDelegateDirective, [null, null, null, null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RouterLinkDelegateDirective, ":not(a):not(area)[routerLink]", never, { "routerDirection": "routerDirection"; "routerAnimation": "routerAnimation"; }, {}, never, never, false>;
+}
+export declare class RouterLinkWithHrefDelegateDirective implements OnInit, OnChanges {
+    private locationStrategy;
+    private navCtrl;
+    private elementRef;
+    private router;
+    private routerLink?;
+    routerDirection: RouterDirection;
+    routerAnimation?: AnimationBuilder;
+    constructor(locationStrategy: LocationStrategy, navCtrl: NavController, elementRef: ElementRef, router: Router, routerLink?: RouterLink | undefined);
+    ngOnInit(): void;
+    ngOnChanges(): void;
+    private updateTargetUrlAndHref;
+    /**
+     * @internal
+     */
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RouterLinkWithHrefDelegateDirective, [null, null, null, null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RouterLinkWithHrefDelegateDirective, "a[routerLink],area[routerLink]", never, { "routerDirection": "routerDirection"; "routerAnimation": "routerAnimation"; }, {}, never, never, false>;
+}

package/common/directives/navigation/router-outlet.d.ts

@@ -0,0 +1,103 @@
+import { Location } from '@angular/common';
+import { ComponentRef, ElementRef, NgZone, OnDestroy, OnInit, EventEmitter, EnvironmentInjector } from '@angular/core';
+import type { Provider } from '@angular/core';
+import { OutletContext, Router, ActivatedRoute, Data } from '@angular/router';
+import type { AnimationBuilder } from '@ionic/core/components';
+import { RouteView, StackDidChangeEvent, StackWillChangeEvent } from './stack-utils';
+import * as i0 from "@angular/core";
+export declare class IonRouterOutlet implements OnDestroy, OnInit {
+    readonly parentOutlet?: IonRouterOutlet | undefined;
+    nativeEl: HTMLIonRouterOutletElement;
+    activatedView: RouteView | null;
+    tabsPrefix: string | undefined;
+    private _swipeGesture?;
+    private stackCtrl;
+    private proxyMap;
+    private currentActivatedRoute$;
+    private activated;
+    /** @internal */
+    get activatedComponentRef(): ComponentRef<any> | null;
+    private _activatedRoute;
+    /**
+     * The name of the outlet
+     */
+    name: string;
+    /** @internal */
+    stackWillChange: EventEmitter<StackWillChangeEvent>;
+    /** @internal */
+    stackDidChange: EventEmitter<StackDidChangeEvent>;
+    activateEvents: EventEmitter<any>;
+    deactivateEvents: EventEmitter<any>;
+    private parentContexts;
+    private location;
+    private environmentInjector;
+    private inputBinder;
+    /** @nodoc */
+    readonly supportsBindingToComponentInputs = true;
+    private config;
+    private navCtrl;
+    set animation(animation: AnimationBuilder);
+    set animated(animated: boolean);
+    set swipeGesture(swipe: boolean);
+    constructor(name: string, tabs: string, commonLocation: Location, elementRef: ElementRef, router: Router, zone: NgZone, activatedRoute: ActivatedRoute, parentOutlet?: IonRouterOutlet | undefined);
+    ngOnDestroy(): void;
+    getContext(): OutletContext | null;
+    ngOnInit(): void;
+    private initializeOutletWithName;
+    get isActivated(): boolean;
+    get component(): Record<string, unknown>;
+    get activatedRoute(): ActivatedRoute;
+    get activatedRouteData(): Data;
+    /**
+     * Called when the `RouteReuseStrategy` instructs to detach the subtree
+     */
+    detach(): ComponentRef<any>;
+    /**
+     * Called when the `RouteReuseStrategy` instructs to re-attach a previously detached subtree
+     */
+    attach(_ref: ComponentRef<any>, _activatedRoute: ActivatedRoute): void;
+    deactivate(): void;
+    activateWith(activatedRoute: ActivatedRoute, environmentInjector: EnvironmentInjector | null): void;
+    /**
+     * Returns `true` if there are pages in the stack to go back.
+     */
+    canGoBack(deep?: number, stackId?: string): boolean;
+    /**
+     * Resolves to `true` if it the outlet was able to sucessfully pop the last N pages.
+     */
+    pop(deep?: number, stackId?: string): Promise<boolean>;
+    /**
+     * Returns the URL of the active page of each stack.
+     */
+    getLastUrl(stackId?: string): string | undefined;
+    /**
+     * Returns the RouteView of the active page of each stack.
+     * @internal
+     */
+    getLastRouteView(stackId?: string): RouteView | undefined;
+    /**
+     * Returns the root view in the tab stack.
+     * @internal
+     */
+    getRootView(stackId?: string): RouteView | undefined;
+    /**
+     * Returns the active stack ID. In the context of ion-tabs, it means the active tab.
+     */
+    getActiveStackId(): string | undefined;
+    /**
+     * Since the activated route can change over the life time of a component in an ion router outlet, we create
+     * a proxy so that we can update the values over time as a user navigates back to components already in the stack.
+     */
+    private createActivatedRouteProxy;
+    /**
+     * Create a wrapped observable that will switch to the latest activated route matched by the given component
+     */
+    private proxyObservable;
+    /**
+     * Updates the activated route proxy for the given component to the new incoming router state
+     */
+    private updateActivatedRouteProxy;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IonRouterOutlet, [{ attribute: "name"; }, { attribute: "tabs"; optional: true; }, null, null, null, null, null, { optional: true; skipSelf: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<IonRouterOutlet, "ion-router-outlet", ["outlet"], { "animated": "animated"; "animation": "animation"; "mode": "mode"; "swipeGesture": "swipeGesture"; "name": "name"; }, { "stackWillChange": "stackWillChange"; "stackDidChange": "stackDidChange"; "activateEvents": "activate"; "deactivateEvents": "deactivate"; }, never, never, false>;
+}
+export declare const provideComponentInputBinding: () => Provider;

package/{directives → common/directives}/navigation/stack-utils.d.ts

@@ -1,6 +1,6 @@
 import { ComponentRef } from '@angular/core';
 import { ActivatedRoute, NavigationExtras, Router } from '@angular/router';
-import { AnimationBuilder, NavDirection, RouterDirection } from '@ionic/core';
+import type { AnimationBuilder, NavDirection, RouterDirection } from '@ionic/core/components';
 export declare const insertView: (views: RouteView[], view: RouteView, direction: RouterDirection) => RouteView[];
 export declare const getUrl: (router: Router, activatedRoute: ActivatedRoute) => string;
 export declare const isTabSwitch: (enteringView: RouteView, leavingView: RouteView | undefined) => boolean;

package/common/directives/navigation/tabs.d.ts

@@ -0,0 +1,74 @@
+import { AfterContentChecked, AfterContentInit, ElementRef, EventEmitter } from '@angular/core';
+import { NavController } from '../../providers/nav-controller';
+import { StackDidChangeEvent, StackWillChangeEvent } from './stack-utils';
+import * as i0 from "@angular/core";
+export declare class IonTabs implements AfterContentInit, AfterContentChecked {
+    private navCtrl;
+    /**
+     * Note: These must be redeclared on each child class since it needs
+     * access to generated components such as IonRouterOutlet and IonTabBar.
+     */
+    outlet: any;
+    tabBar: any;
+    tabBars: any;
+    tabsInner: ElementRef<HTMLDivElement>;
+    /**
+     * Emitted before the tab view is changed.
+     */
+    ionTabsWillChange: EventEmitter<{
+        tab: string;
+    }>;
+    /**
+     * Emitted after the tab view is changed.
+     */
+    ionTabsDidChange: EventEmitter<{
+        tab: string;
+    }>;
+    private tabBarSlot;
+    constructor(navCtrl: NavController);
+    ngAfterContentInit(): void;
+    ngAfterContentChecked(): void;
+    /**
+     * @internal
+     */
+    onStackWillChange({ enteringView, tabSwitch }: StackWillChangeEvent): void;
+    /**
+     * @internal
+     */
+    onStackDidChange({ enteringView, tabSwitch }: StackDidChangeEvent): void;
+    /**
+     * When a tab button is clicked, there are several scenarios:
+     * 1. If the selected tab is currently active (the tab button has been clicked
+     *    again), then it should go to the root view for that tab.
+     *
+     *   a. Get the saved root view from the router outlet. If the saved root view
+     *      matches the tabRootUrl, set the route view to this view including the
+     *      navigation extras.
+     *   b. If the saved root view from the router outlet does
+     *      not match, navigate to the tabRootUrl. No navigation extras are
+     *      included.
+     *
+     * 2. If the current tab tab is not currently selected, get the last route
+     *    view from the router outlet.
+     *
+     *   a. If the last route view exists, navigate to that view including any
+     *      navigation extras
+     *   b. If the last route view doesn't exist, then navigate
+     *      to the default tabRootUrl
+     */
+    select(tabOrEvent: string | CustomEvent): Promise<boolean> | undefined;
+    getSelected(): string | undefined;
+    /**
+     * Detects changes to the slot attribute of the tab bar.
+     *
+     * If the slot attribute has changed, then the tab bar
+     * should be relocated to the new slot position.
+     */
+    private detectSlotChanges;
+    /**
+     * Relocates the tab bar to the new slot position.
+     */
+    private relocateTabBar;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IonTabs, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<IonTabs, "ion-tabs", never, {}, { "ionTabsWillChange": "ionTabsWillChange"; "ionTabsDidChange": "ionTabsDidChange"; }, never, never, false>;
+}

package/common/index.d.ts

@@ -0,0 +1,28 @@
+export { ActionSheetController } from './providers/action-sheet-controller';
+export { AlertController } from './providers/alert-controller';
+export { LoadingController } from './providers/loading-controller';
+export { MenuController } from './providers/menu-controller';
+export { ModalController } from './providers/modal-controller';
+export { PickerController } from './providers/picker-controller';
+export { PopoverController } from './providers/popover-controller';
+export { ToastController } from './providers/toast-controller';
+export { AnimationController } from './providers/animation-controller';
+export { GestureController } from './providers/gesture-controller';
+export { DomController } from './providers/dom-controller';
+export { NavController } from './providers/nav-controller';
+export { Config, ConfigToken } from './providers/config';
+export { Platform } from './providers/platform';
+export { bindLifecycleEvents, AngularDelegate } from './providers/angular-delegate';
+export type { IonicWindow } from './types/interfaces';
+export { NavParams } from './directives/navigation/nav-params';
+export { IonPopover } from './overlays/popover';
+export { IonModal } from './overlays/modal';
+export { IonRouterOutlet, provideComponentInputBinding } from './directives/navigation/router-outlet';
+export { IonBackButton } from './directives/navigation/back-button';
+export { RouterLinkDelegateDirective, RouterLinkWithHrefDelegateDirective, } from './directives/navigation/router-link-delegate';
+export { IonNav } from './directives/navigation/nav';
+export { IonTabs } from './directives/navigation/tabs';
+export * from './directives/control-value-accessors';
+export { ProxyCmp } from './utils/proxy';
+export { IonicRouteStrategy } from './utils/routing';
+export { raf } from './utils/util';

package/common/overlays/modal.d.ts

@@ -0,0 +1,50 @@
+import { ChangeDetectorRef, ElementRef, EventEmitter, NgZone, TemplateRef } from '@angular/core';
+import type { Components, ModalBreakpointChangeEventDetail } from '@ionic/core/components';
+import * as i0 from "@angular/core";
+export declare interface IonModal extends Components.IonModal {
+    /**
+     * Emitted after the modal has presented.
+     **/
+    ionModalDidPresent: EventEmitter<CustomEvent>;
+    /**
+     * Emitted before the modal has presented.
+     */
+    ionModalWillPresent: EventEmitter<CustomEvent>;
+    /**
+     * Emitted before the modal has dismissed.
+     */
+    ionModalWillDismiss: EventEmitter<CustomEvent>;
+    /**
+     * Emitted after the modal has dismissed.
+     */
+    ionModalDidDismiss: EventEmitter<CustomEvent>;
+    /**
+     * Emitted after the modal breakpoint has changed.
+     */
+    ionBreakpointDidChange: EventEmitter<CustomEvent<ModalBreakpointChangeEventDetail>>;
+    /**
+     * Emitted after the modal has presented. Shorthand for ionModalDidPresent.
+     */
+    didPresent: EventEmitter<CustomEvent>;
+    /**
+     * Emitted before the modal has presented. Shorthand for ionModalWillPresent.
+     */
+    willPresent: EventEmitter<CustomEvent>;
+    /**
+     * Emitted before the modal has dismissed. Shorthand for ionModalWillDismiss.
+     */
+    willDismiss: EventEmitter<CustomEvent>;
+    /**
+     * Emitted after the modal has dismissed. Shorthand for ionModalDidDismiss.
+     */
+    didDismiss: EventEmitter<CustomEvent>;
+}
+export declare class IonModal {
+    protected z: NgZone;
+    template: TemplateRef<any>;
+    isCmpOpen: boolean;
+    protected el: HTMLElement;
+    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
+    static ɵfac: i0.ɵɵFactoryDeclaration<IonModal, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<IonModal, "ion-modal", never, { "animated": "animated"; "keepContentsMounted": "keepContentsMounted"; "backdropBreakpoint": "backdropBreakpoint"; "backdropDismiss": "backdropDismiss"; "breakpoints": "breakpoints"; "canDismiss": "canDismiss"; "cssClass": "cssClass"; "enterAnimation": "enterAnimation"; "event": "event"; "handle": "handle"; "handleBehavior": "handleBehavior"; "initialBreakpoint": "initialBreakpoint"; "isOpen": "isOpen"; "keyboardClose": "keyboardClose"; "leaveAnimation": "leaveAnimation"; "mode": "mode"; "presentingElement": "presentingElement"; "showBackdrop": "showBackdrop"; "translucent": "translucent"; "trigger": "trigger"; }, {}, ["template"], never, false>;
+}

package/common/overlays/popover.d.ts

@@ -0,0 +1,46 @@
+import { ChangeDetectorRef, ElementRef, EventEmitter, NgZone, TemplateRef } from '@angular/core';
+import type { Components } from '@ionic/core/components';
+import * as i0 from "@angular/core";
+export declare interface IonPopover extends Components.IonPopover {
+    /**
+     * Emitted after the popover has presented.
+     */
+    ionPopoverDidPresent: EventEmitter<CustomEvent>;
+    /**
+     * Emitted before the popover has presented.
+     */
+    ionPopoverWillPresent: EventEmitter<CustomEvent>;
+    /**
+     * Emitted after the popover has dismissed.
+     */
+    ionPopoverWillDismiss: EventEmitter<CustomEvent>;
+    /**
+     * Emitted after the popover has dismissed.
+     */
+    ionPopoverDidDismiss: EventEmitter<CustomEvent>;
+    /**
+     * Emitted after the popover has presented. Shorthand for ionPopoverDidPresent.
+     */
+    didPresent: EventEmitter<CustomEvent>;
+    /**
+     * Emitted before the popover has presented. Shorthand for ionPopoverWillPresent.
+     */
+    willPresent: EventEmitter<CustomEvent>;
+    /**
+     * Emitted after the popover has presented. Shorthand for ionPopoverWillDismiss.
+     */
+    willDismiss: EventEmitter<CustomEvent>;
+    /**
+     * Emitted after the popover has dismissed. Shorthand for ionPopoverDidDismiss.
+     */
+    didDismiss: EventEmitter<CustomEvent>;
+}
+export declare class IonPopover {
+    protected z: NgZone;
+    template: TemplateRef<any>;
+    isCmpOpen: boolean;
+    protected el: HTMLElement;
+    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
+    static ɵfac: i0.ɵɵFactoryDeclaration<IonPopover, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<IonPopover, "ion-popover", never, { "alignment": "alignment"; "animated": "animated"; "arrow": "arrow"; "keepContentsMounted": "keepContentsMounted"; "backdropDismiss": "backdropDismiss"; "cssClass": "cssClass"; "dismissOnSelect": "dismissOnSelect"; "enterAnimation": "enterAnimation"; "event": "event"; "isOpen": "isOpen"; "keyboardClose": "keyboardClose"; "leaveAnimation": "leaveAnimation"; "mode": "mode"; "showBackdrop": "showBackdrop"; "translucent": "translucent"; "trigger": "trigger"; "triggerAction": "triggerAction"; "reference": "reference"; "size": "size"; "side": "side"; }, {}, ["template"], never, false>;
+}

package/{providers → common/providers}/action-sheet-controller.d.ts

@@ -1,5 +1,5 @@
-import { ActionSheetOptions } from '@ionic/core';
-import { OverlayBaseController } from '../util/overlay';
+import type { ActionSheetOptions } from '@ionic/core/components';
+import { OverlayBaseController } from '../utils/overlay';
 import * as i0 from "@angular/core";
 export declare class ActionSheetController extends OverlayBaseController<ActionSheetOptions, HTMLIonActionSheetElement> {
     constructor();

package/{providers → common/providers}/alert-controller.d.ts

@@ -1,5 +1,5 @@
-import { AlertOptions } from '@ionic/core';
-import { OverlayBaseController } from '../util/overlay';
+import type { AlertOptions } from '@ionic/core/components';
+import { OverlayBaseController } from '../utils/overlay';
 import * as i0 from "@angular/core";
 export declare class AlertController extends OverlayBaseController<AlertOptions, HTMLIonAlertElement> {
     constructor();

package/{providers → common/providers}/angular-delegate.d.ts

@@ -1,5 +1,5 @@
 import { ApplicationRef, NgZone, Injector, EnvironmentInjector, ComponentRef } from '@angular/core';
-import { FrameworkDelegate } from '@ionic/core';
+import { FrameworkDelegate } from '@ionic/core/components';
 import * as i0 from "@angular/core";
 export declare class AngularDelegate {
     private zone;

package/{providers → common/providers}/animation-controller.d.ts

@@ -1,4 +1,4 @@
-import { Animation } from '@ionic/core';
+import type { Animation } from '@ionic/core/components';
 import * as i0 from "@angular/core";
 export declare class AnimationController {
     /**

package/{providers → common/providers}/config.d.ts

@@ -1,5 +1,5 @@
 import { InjectionToken } from '@angular/core';
-import { IonicConfig } from '@ionic/core';
+import type { IonicConfig } from '@ionic/core/components';
 import * as i0 from "@angular/core";
 export declare class Config {
     get(key: keyof IonicConfig, fallback?: any): any;

package/{providers → common/providers}/gesture-controller.d.ts

@@ -1,5 +1,5 @@
 import { NgZone } from '@angular/core';
-import { Gesture, GestureConfig } from '@ionic/core';
+import type { Gesture, GestureConfig } from '@ionic/core/components';
 import * as i0 from "@angular/core";
 export declare class GestureController {
     private zone;

package/{providers → common/providers}/loading-controller.d.ts

@@ -1,5 +1,5 @@
-import { LoadingOptions } from '@ionic/core';
-import { OverlayBaseController } from '../util/overlay';
+import type { LoadingOptions } from '@ionic/core/components';
+import { OverlayBaseController } from '../utils/overlay';
 import * as i0 from "@angular/core";
 export declare class LoadingController extends OverlayBaseController<LoadingOptions, HTMLIonLoadingElement> {
     constructor();

package/{providers → common/providers}/modal-controller.d.ts

@@ -1,5 +1,5 @@
-import { ModalOptions } from '@ionic/core';
-import { OverlayBaseController } from '../util/overlay';
+import type { ModalOptions } from '@ionic/core/components';
+import { OverlayBaseController } from '../utils/overlay';
 import * as i0 from "@angular/core";
 export declare class ModalController extends OverlayBaseController<ModalOptions, HTMLIonModalElement> {
     private angularDelegate;

package/{providers → common/providers}/nav-controller.d.ts

@@ -1,7 +1,7 @@
 import { Location } from '@angular/common';
 import { NavigationExtras, Router, UrlSerializer, UrlTree } from '@angular/router';
-import { AnimationBuilder, NavDirection, RouterDirection } from '@ionic/core';
-import { IonRouterOutlet } from '../directives/navigation/ion-router-outlet';
+import type { AnimationBuilder, NavDirection, RouterDirection } from '@ionic/core/components';
+import { IonRouterOutlet } from '../directives/navigation/router-outlet';
 import { Platform } from './platform';
 import * as i0 from "@angular/core";
 export interface AnimationOptions {

package/{providers → common/providers}/picker-controller.d.ts

@@ -1,5 +1,5 @@
-import { PickerOptions } from '@ionic/core';
-import { OverlayBaseController } from '../util/overlay';
+import type { PickerOptions } from '@ionic/core/components';
+import { OverlayBaseController } from '../utils/overlay';
 import * as i0 from "@angular/core";
 export declare class PickerController extends OverlayBaseController<PickerOptions, HTMLIonPickerElement> {
     constructor();

package/{providers → common/providers}/platform.d.ts

@@ -1,5 +1,5 @@
 import { NgZone } from '@angular/core';
-import { BackButtonEventDetail, Platforms } from '@ionic/core';
+import type { BackButtonEventDetail, Platforms } from '@ionic/core/components';
 import { Subscription, Subject } from 'rxjs';
 import * as i0 from "@angular/core";
 export interface BackButtonEmitter extends Subject<BackButtonEventDetail> {

package/{providers → common/providers}/popover-controller.d.ts

@@ -1,5 +1,5 @@
-import { PopoverOptions } from '@ionic/core';
-import { OverlayBaseController } from '../util/overlay';
+import type { PopoverOptions } from '@ionic/core/components';
+import { OverlayBaseController } from '../utils/overlay';
 import * as i0 from "@angular/core";
 export declare class PopoverController extends OverlayBaseController<PopoverOptions, HTMLIonPopoverElement> {
     private angularDelegate;

package/{providers → common/providers}/toast-controller.d.ts

@@ -1,5 +1,5 @@
-import { ToastOptions } from '@ionic/core';
-import { OverlayBaseController } from '../util/overlay';
+import type { ToastOptions } from '@ionic/core/components';
+import { OverlayBaseController } from '../utils/overlay';
 import * as i0 from "@angular/core";
 export declare class ToastController extends OverlayBaseController<ToastOptions, HTMLIonToastElement> {
     constructor();

package/{types → common/types}/interfaces.d.ts

@@ -6,7 +6,3 @@ export interface IonicWindow extends Window {
     Ionic: IonicGlobal;
     __zone_symbol__requestAnimationFrame?: (ts: FrameRequestCallback) => number;
 }
-export interface HTMLStencilElement extends HTMLElement {
-    componentOnReady?(): Promise<this>;
-    forceUpdate?(): void;
-}

package/common/utils/proxy.d.ts

@@ -0,0 +1,8 @@
+export declare const proxyInputs: (Cmp: any, inputs: string[]) => void;
+export declare const proxyMethods: (Cmp: any, methods: string[]) => void;
+export declare const proxyOutputs: (instance: any, el: any, events: string[]) => void;
+export declare function ProxyCmp(opts: {
+    defineCustomElementFn?: () => void;
+    inputs?: any;
+    methods?: any;
+}): (cls: any) => any;