@ionic/react 7.5.3-dev.11698858201.14165f23 → 7.5.3-dev.11699994454.1cbf1283

package/dist/types/components/proxies.d.ts

@@ -0,0 +1,66 @@
+/// <reference types="react" />
+import type { JSX } from '@ionic/core/components';
+export declare const IonAccordion: import("react").ForwardRefExoticComponent<JSX.IonAccordion & Omit<import("react").HTMLAttributes<HTMLIonAccordionElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonAccordionElement>>;
+export declare const IonAccordionGroup: import("react").ForwardRefExoticComponent<JSX.IonAccordionGroup & Omit<import("react").HTMLAttributes<HTMLIonAccordionGroupElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonAccordionGroupElement>>;
+export declare const IonAvatar: import("react").ForwardRefExoticComponent<JSX.IonAvatar & Omit<import("react").HTMLAttributes<HTMLIonAvatarElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonAvatarElement>>;
+export declare const IonBackdrop: import("react").ForwardRefExoticComponent<JSX.IonBackdrop & Omit<import("react").HTMLAttributes<HTMLIonBackdropElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonBackdropElement>>;
+export declare const IonBadge: import("react").ForwardRefExoticComponent<JSX.IonBadge & Omit<import("react").HTMLAttributes<HTMLIonBadgeElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonBadgeElement>>;
+export declare const IonBreadcrumbs: import("react").ForwardRefExoticComponent<JSX.IonBreadcrumbs & Omit<import("react").HTMLAttributes<HTMLIonBreadcrumbsElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonBreadcrumbsElement>>;
+export declare const IonButtons: import("react").ForwardRefExoticComponent<JSX.IonButtons & Omit<import("react").HTMLAttributes<HTMLIonButtonsElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonButtonsElement>>;
+export declare const IonCardContent: import("react").ForwardRefExoticComponent<JSX.IonCardContent & Omit<import("react").HTMLAttributes<HTMLIonCardContentElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonCardContentElement>>;
+export declare const IonCardHeader: import("react").ForwardRefExoticComponent<JSX.IonCardHeader & Omit<import("react").HTMLAttributes<HTMLIonCardHeaderElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonCardHeaderElement>>;
+export declare const IonCardSubtitle: import("react").ForwardRefExoticComponent<JSX.IonCardSubtitle & Omit<import("react").HTMLAttributes<HTMLIonCardSubtitleElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonCardSubtitleElement>>;
+export declare const IonCardTitle: import("react").ForwardRefExoticComponent<JSX.IonCardTitle & Omit<import("react").HTMLAttributes<HTMLIonCardTitleElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonCardTitleElement>>;
+export declare const IonCheckbox: import("react").ForwardRefExoticComponent<JSX.IonCheckbox & Omit<import("react").HTMLAttributes<HTMLIonCheckboxElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonCheckboxElement>>;
+export declare const IonChip: import("react").ForwardRefExoticComponent<JSX.IonChip & Omit<import("react").HTMLAttributes<HTMLIonChipElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonChipElement>>;
+export declare const IonCol: import("react").ForwardRefExoticComponent<JSX.IonCol & Omit<import("react").HTMLAttributes<HTMLIonColElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonColElement>>;
+export declare const IonContent: import("react").ForwardRefExoticComponent<JSX.IonContent & Omit<import("react").HTMLAttributes<HTMLIonContentElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonContentElement>>;
+export declare const IonDatetime: import("react").ForwardRefExoticComponent<JSX.IonDatetime & Omit<import("react").HTMLAttributes<HTMLIonDatetimeElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonDatetimeElement>>;
+export declare const IonDatetimeButton: import("react").ForwardRefExoticComponent<JSX.IonDatetimeButton & Omit<import("react").HTMLAttributes<HTMLIonDatetimeButtonElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonDatetimeButtonElement>>;
+export declare const IonFab: import("react").ForwardRefExoticComponent<JSX.IonFab & Omit<import("react").HTMLAttributes<HTMLIonFabElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonFabElement>>;
+export declare const IonFabList: import("react").ForwardRefExoticComponent<JSX.IonFabList & Omit<import("react").HTMLAttributes<HTMLIonFabListElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonFabListElement>>;
+export declare const IonFooter: import("react").ForwardRefExoticComponent<JSX.IonFooter & Omit<import("react").HTMLAttributes<HTMLIonFooterElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonFooterElement>>;
+export declare const IonGrid: import("react").ForwardRefExoticComponent<JSX.IonGrid & Omit<import("react").HTMLAttributes<HTMLIonGridElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonGridElement>>;
+export declare const IonHeader: import("react").ForwardRefExoticComponent<JSX.IonHeader & Omit<import("react").HTMLAttributes<HTMLIonHeaderElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonHeaderElement>>;
+export declare const IonImg: import("react").ForwardRefExoticComponent<JSX.IonImg & Omit<import("react").HTMLAttributes<HTMLIonImgElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonImgElement>>;
+export declare const IonInfiniteScroll: import("react").ForwardRefExoticComponent<JSX.IonInfiniteScroll & Omit<import("react").HTMLAttributes<HTMLIonInfiniteScrollElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonInfiniteScrollElement>>;
+export declare const IonInfiniteScrollContent: import("react").ForwardRefExoticComponent<JSX.IonInfiniteScrollContent & Omit<import("react").HTMLAttributes<HTMLIonInfiniteScrollContentElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonInfiniteScrollContentElement>>;
+export declare const IonInput: import("react").ForwardRefExoticComponent<JSX.IonInput & Omit<import("react").HTMLAttributes<HTMLIonInputElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonInputElement>>;
+export declare const IonItemDivider: import("react").ForwardRefExoticComponent<JSX.IonItemDivider & Omit<import("react").HTMLAttributes<HTMLIonItemDividerElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonItemDividerElement>>;
+export declare const IonItemGroup: import("react").ForwardRefExoticComponent<JSX.IonItemGroup & Omit<import("react").HTMLAttributes<HTMLIonItemGroupElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonItemGroupElement>>;
+export declare const IonItemOptions: import("react").ForwardRefExoticComponent<JSX.IonItemOptions & Omit<import("react").HTMLAttributes<HTMLIonItemOptionsElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonItemOptionsElement>>;
+export declare const IonItemSliding: import("react").ForwardRefExoticComponent<JSX.IonItemSliding & Omit<import("react").HTMLAttributes<HTMLIonItemSlidingElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonItemSlidingElement>>;
+export declare const IonLabel: import("react").ForwardRefExoticComponent<JSX.IonLabel & Omit<import("react").HTMLAttributes<HTMLIonLabelElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonLabelElement>>;
+export declare const IonList: import("react").ForwardRefExoticComponent<JSX.IonList & Omit<import("react").HTMLAttributes<HTMLIonListElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonListElement>>;
+export declare const IonListHeader: import("react").ForwardRefExoticComponent<JSX.IonListHeader & Omit<import("react").HTMLAttributes<HTMLIonListHeaderElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonListHeaderElement>>;
+export declare const IonMenu: import("react").ForwardRefExoticComponent<JSX.IonMenu & Omit<import("react").HTMLAttributes<HTMLIonMenuElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonMenuElement>>;
+export declare const IonMenuButton: import("react").ForwardRefExoticComponent<JSX.IonMenuButton & Omit<import("react").HTMLAttributes<HTMLIonMenuButtonElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonMenuButtonElement>>;
+export declare const IonMenuToggle: import("react").ForwardRefExoticComponent<JSX.IonMenuToggle & Omit<import("react").HTMLAttributes<HTMLIonMenuToggleElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonMenuToggleElement>>;
+export declare const IonNav: import("react").ForwardRefExoticComponent<JSX.IonNav & Omit<import("react").HTMLAttributes<HTMLIonNavElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonNavElement>>;
+export declare const IonNavLink: import("react").ForwardRefExoticComponent<JSX.IonNavLink & Omit<import("react").HTMLAttributes<HTMLIonNavLinkElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonNavLinkElement>>;
+export declare const IonNote: import("react").ForwardRefExoticComponent<JSX.IonNote & Omit<import("react").HTMLAttributes<HTMLIonNoteElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonNoteElement>>;
+export declare const IonProgressBar: import("react").ForwardRefExoticComponent<JSX.IonProgressBar & Omit<import("react").HTMLAttributes<HTMLIonProgressBarElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonProgressBarElement>>;
+export declare const IonRadio: import("react").ForwardRefExoticComponent<JSX.IonRadio & Omit<import("react").HTMLAttributes<HTMLIonRadioElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonRadioElement>>;
+export declare const IonRadioGroup: import("react").ForwardRefExoticComponent<JSX.IonRadioGroup & Omit<import("react").HTMLAttributes<HTMLIonRadioGroupElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonRadioGroupElement>>;
+export declare const IonRange: import("react").ForwardRefExoticComponent<JSX.IonRange & Omit<import("react").HTMLAttributes<HTMLIonRangeElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonRangeElement>>;
+export declare const IonRefresher: import("react").ForwardRefExoticComponent<JSX.IonRefresher & Omit<import("react").HTMLAttributes<HTMLIonRefresherElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonRefresherElement>>;
+export declare const IonRefresherContent: import("react").ForwardRefExoticComponent<JSX.IonRefresherContent & Omit<import("react").HTMLAttributes<HTMLIonRefresherContentElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonRefresherContentElement>>;
+export declare const IonReorder: import("react").ForwardRefExoticComponent<JSX.IonReorder & Omit<import("react").HTMLAttributes<HTMLIonReorderElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonReorderElement>>;
+export declare const IonReorderGroup: import("react").ForwardRefExoticComponent<JSX.IonReorderGroup & Omit<import("react").HTMLAttributes<HTMLIonReorderGroupElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonReorderGroupElement>>;
+export declare const IonRippleEffect: import("react").ForwardRefExoticComponent<JSX.IonRippleEffect & Omit<import("react").HTMLAttributes<HTMLIonRippleEffectElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonRippleEffectElement>>;
+export declare const IonRow: import("react").ForwardRefExoticComponent<JSX.IonRow & Omit<import("react").HTMLAttributes<HTMLIonRowElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonRowElement>>;
+export declare const IonSearchbar: import("react").ForwardRefExoticComponent<JSX.IonSearchbar & Omit<import("react").HTMLAttributes<HTMLIonSearchbarElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonSearchbarElement>>;
+export declare const IonSegment: import("react").ForwardRefExoticComponent<JSX.IonSegment & Omit<import("react").HTMLAttributes<HTMLIonSegmentElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonSegmentElement>>;
+export declare const IonSegmentButton: import("react").ForwardRefExoticComponent<JSX.IonSegmentButton & Omit<import("react").HTMLAttributes<HTMLIonSegmentButtonElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonSegmentButtonElement>>;
+export declare const IonSelect: import("react").ForwardRefExoticComponent<JSX.IonSelect & Omit<import("react").HTMLAttributes<HTMLIonSelectElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonSelectElement>>;
+export declare const IonSelectOption: import("react").ForwardRefExoticComponent<JSX.IonSelectOption & Omit<import("react").HTMLAttributes<HTMLIonSelectOptionElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonSelectOptionElement>>;
+export declare const IonSkeletonText: import("react").ForwardRefExoticComponent<JSX.IonSkeletonText & Omit<import("react").HTMLAttributes<HTMLIonSkeletonTextElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonSkeletonTextElement>>;
+export declare const IonSpinner: import("react").ForwardRefExoticComponent<JSX.IonSpinner & Omit<import("react").HTMLAttributes<HTMLIonSpinnerElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonSpinnerElement>>;
+export declare const IonSplitPane: import("react").ForwardRefExoticComponent<JSX.IonSplitPane & Omit<import("react").HTMLAttributes<HTMLIonSplitPaneElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonSplitPaneElement>>;
+export declare const IonTab: import("react").ForwardRefExoticComponent<JSX.IonTab & Omit<import("react").HTMLAttributes<HTMLIonTabElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonTabElement>>;
+export declare const IonText: import("react").ForwardRefExoticComponent<JSX.IonText & Omit<import("react").HTMLAttributes<HTMLIonTextElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonTextElement>>;
+export declare const IonTextarea: import("react").ForwardRefExoticComponent<JSX.IonTextarea & Omit<import("react").HTMLAttributes<HTMLIonTextareaElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonTextareaElement>>;
+export declare const IonThumbnail: import("react").ForwardRefExoticComponent<JSX.IonThumbnail & Omit<import("react").HTMLAttributes<HTMLIonThumbnailElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonThumbnailElement>>;
+export declare const IonTitle: import("react").ForwardRefExoticComponent<JSX.IonTitle & Omit<import("react").HTMLAttributes<HTMLIonTitleElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonTitleElement>>;
+export declare const IonToggle: import("react").ForwardRefExoticComponent<JSX.IonToggle & Omit<import("react").HTMLAttributes<HTMLIonToggleElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonToggleElement>>;
+export declare const IonToolbar: import("react").ForwardRefExoticComponent<JSX.IonToolbar & Omit<import("react").HTMLAttributes<HTMLIonToolbarElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLIonToolbarElement>>;

package/dist/types/components/react-component-lib/createComponent.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+export interface HTMLStencilElement extends HTMLElement {
+    componentOnReady(): Promise<this>;
+}
+interface StencilReactInternalProps<ElementType> extends React.HTMLAttributes<ElementType> {
+    forwardedRef: React.RefObject<ElementType>;
+    ref?: React.Ref<any>;
+}
+export declare const createReactComponent: <PropType, ElementType extends HTMLStencilElement, ContextStateType = {}, ExpandedPropsTypes = {}>(tagName: string, ReactComponentContext?: React.Context<ContextStateType> | undefined, manipulatePropsFunction?: ((originalProps: StencilReactInternalProps<ElementType>, propsToPass: any) => ExpandedPropsTypes) | undefined, defineCustomElement?: () => void) => React.ForwardRefExoticComponent<React.PropsWithoutRef<PropType & Omit<React.HTMLAttributes<ElementType>, "style"> & import("./interfaces").StyleReactProps> & React.RefAttributes<ElementType>>;
+export {};

package/dist/types/components/react-component-lib/createOverlayComponent.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+import { OverlayEventDetail } from './interfaces';
+import { StencilReactForwardedRef } from './utils';
+interface OverlayElement extends HTMLElement {
+    present: () => Promise<void>;
+    dismiss: (data?: any, role?: string | undefined) => Promise<boolean>;
+}
+export interface ReactOverlayProps {
+    children?: React.ReactNode;
+    isOpen: boolean;
+    onDidDismiss?: (event: CustomEvent<OverlayEventDetail>) => void;
+    onDidPresent?: (event: CustomEvent<OverlayEventDetail>) => void;
+    onWillDismiss?: (event: CustomEvent<OverlayEventDetail>) => void;
+    onWillPresent?: (event: CustomEvent<OverlayEventDetail>) => void;
+}
+export declare const createOverlayComponent: <OverlayComponent extends object, OverlayType extends OverlayElement>(tagName: string, controller: {
+    create: (options: any) => Promise<OverlayType>;
+}, customElement?: any) => React.ForwardRefExoticComponent<React.PropsWithoutRef<OverlayComponent & ReactOverlayProps & {
+    forwardedRef?: StencilReactForwardedRef<OverlayType> | undefined;
+}> & React.RefAttributes<OverlayType>>;
+export {};

package/dist/types/components/react-component-lib/index.d.ts

@@ -0,0 +1,2 @@
+export { createReactComponent } from './createComponent';
+export { createOverlayComponent } from './createOverlayComponent';

package/dist/types/components/react-component-lib/interfaces.d.ts

@@ -0,0 +1,29 @@
+export interface EventEmitter<T = any> {
+    emit: (data?: T) => CustomEvent<T>;
+}
+export interface StyleReactProps {
+    class?: string;
+    className?: string;
+    style?: {
+        [key: string]: any;
+    };
+}
+export interface OverlayEventDetail<T = any> {
+    data?: T;
+    role?: string;
+}
+export interface OverlayInterface {
+    el: HTMLElement;
+    animated: boolean;
+    keyboardClose: boolean;
+    overlayIndex: number;
+    presented: boolean;
+    enterAnimation?: any;
+    leaveAnimation?: any;
+    didPresent: EventEmitter<void>;
+    willPresent: EventEmitter<void>;
+    willDismiss: EventEmitter<OverlayEventDetail>;
+    didDismiss: EventEmitter<OverlayEventDetail>;
+    present(): Promise<void>;
+    dismiss(data?: any, role?: string): Promise<boolean>;
+}

package/dist/types/components/react-component-lib/utils/attachProps.d.ts

@@ -0,0 +1,16 @@
+export declare const attachProps: (node: HTMLElement, newProps: any, oldProps?: any) => void;
+export declare const getClassName: (classList: DOMTokenList, newProps: any, oldProps: any) => string;
+/**
+ * Transforms a React event name to a browser event name.
+ */
+export declare const transformReactEventName: (eventNameSuffix: string) => string;
+/**
+ * Checks if an event is supported in the current execution environment.
+ * @license Modernizr 3.0.0pre (Custom Build) | MIT
+ */
+export declare const isCoveredByReact: (eventNameSuffix: string) => boolean;
+export declare const syncEvent: (node: Element & {
+    __events?: {
+        [key: string]: ((e: Event) => any) | undefined;
+    } | undefined;
+}, eventName: string, newEventHandler?: ((e: Event) => any) | undefined) => void;

package/dist/types/components/react-component-lib/utils/case.d.ts

@@ -0,0 +1,2 @@
+export declare const dashToPascalCase: (str: string) => string;
+export declare const camelToDashCase: (str: string) => string;

package/dist/types/components/react-component-lib/utils/dev.d.ts

@@ -0,0 +1,2 @@
+export declare const isDevMode: () => boolean;
+export declare const deprecationWarning: (key: string, message: string) => void;

package/dist/types/components/react-component-lib/utils/index.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { StyleReactProps } from '../interfaces';
+export type StencilReactExternalProps<PropType, ElementType> = PropType & Omit<React.HTMLAttributes<ElementType>, 'style'> & StyleReactProps;
+export type StencilReactForwardedRef<T> = ((instance: T | null) => void) | React.MutableRefObject<T | null> | null;
+export declare const setRef: (ref: StencilReactForwardedRef<any> | React.Ref<any> | undefined, value: any) => void;
+export declare const mergeRefs: (...refs: (StencilReactForwardedRef<any> | React.Ref<any> | undefined)[]) => React.RefCallback<any>;
+export declare const createForwardRef: <PropType, ElementType>(ReactComponent: any, displayName: string) => React.ForwardRefExoticComponent<React.PropsWithoutRef<PropType & Omit<React.HTMLAttributes<ElementType>, "style"> & StyleReactProps> & React.RefAttributes<ElementType>>;
+export declare const defineCustomElement: (tagName: string, customElement: any) => void;
+export * from './attachProps';
+export * from './case';

package/dist/types/components/routing-proxies.d.ts

@@ -0,0 +1,44 @@
+/// <reference types="react" />
+import type { JSX } from '@ionic/core/components';
+export declare const IonRouterLink: import("react").ForwardRefExoticComponent<Omit<JSX.IonRouterLink, "routerDirection"> & {
+    routerLink?: string | undefined;
+    routerDirection?: import("..").RouterDirection | undefined;
+    routerOptions?: import("..").RouterOptions | undefined;
+    routerAnimation?: import("@ionic/core/components").AnimationBuilder | undefined;
+} & Omit<import("react").HTMLAttributes<HTMLIonRouterLinkElement>, "style"> & import("./IonicReactProps").IonicReactProps & import("react").RefAttributes<HTMLIonRouterLinkElement>>;
+export declare const IonButton: import("react").ForwardRefExoticComponent<Omit<JSX.IonButton, "routerDirection"> & {
+    routerLink?: string | undefined;
+    routerDirection?: import("..").RouterDirection | undefined;
+    routerOptions?: import("..").RouterOptions | undefined;
+    routerAnimation?: import("@ionic/core/components").AnimationBuilder | undefined;
+} & Omit<import("react").HTMLAttributes<HTMLIonButtonElement>, "style"> & import("./IonicReactProps").IonicReactProps & import("react").RefAttributes<HTMLIonButtonElement>>;
+export declare const IonCard: import("react").ForwardRefExoticComponent<Omit<JSX.IonCard, "routerDirection"> & {
+    routerLink?: string | undefined;
+    routerDirection?: import("..").RouterDirection | undefined;
+    routerOptions?: import("..").RouterOptions | undefined;
+    routerAnimation?: import("@ionic/core/components").AnimationBuilder | undefined;
+} & Omit<import("react").HTMLAttributes<HTMLIonCardElement>, "style"> & import("./IonicReactProps").IonicReactProps & import("react").RefAttributes<HTMLIonCardElement>>;
+export declare const IonFabButton: import("react").ForwardRefExoticComponent<Omit<JSX.IonFabButton, "routerDirection"> & {
+    routerLink?: string | undefined;
+    routerDirection?: import("..").RouterDirection | undefined;
+    routerOptions?: import("..").RouterOptions | undefined;
+    routerAnimation?: import("@ionic/core/components").AnimationBuilder | undefined;
+} & Omit<import("react").HTMLAttributes<HTMLIonFabButtonElement>, "style"> & import("./IonicReactProps").IonicReactProps & import("react").RefAttributes<HTMLIonFabButtonElement>>;
+export declare const IonItem: import("react").ForwardRefExoticComponent<Omit<JSX.IonItem, "routerDirection"> & {
+    routerLink?: string | undefined;
+    routerDirection?: import("..").RouterDirection | undefined;
+    routerOptions?: import("..").RouterOptions | undefined;
+    routerAnimation?: import("@ionic/core/components").AnimationBuilder | undefined;
+} & Omit<import("react").HTMLAttributes<HTMLIonItemElement>, "style"> & import("./IonicReactProps").IonicReactProps & import("react").RefAttributes<HTMLIonItemElement>>;
+export declare const IonItemOption: import("react").ForwardRefExoticComponent<Omit<JSX.IonItemOption, "routerDirection"> & {
+    routerLink?: string | undefined;
+    routerDirection?: import("..").RouterDirection | undefined;
+    routerOptions?: import("..").RouterOptions | undefined;
+    routerAnimation?: import("@ionic/core/components").AnimationBuilder | undefined;
+} & Omit<import("react").HTMLAttributes<HTMLIonItemOptionElement>, "style"> & import("./IonicReactProps").IonicReactProps & import("react").RefAttributes<HTMLIonItemOptionElement>>;
+export declare const IonBreadcrumb: import("react").ForwardRefExoticComponent<Omit<JSX.IonBreadcrumb, "routerDirection"> & {
+    routerLink?: string | undefined;
+    routerDirection?: import("..").RouterDirection | undefined;
+    routerOptions?: import("..").RouterOptions | undefined;
+    routerAnimation?: import("@ionic/core/components").AnimationBuilder | undefined;
+} & Omit<import("react").HTMLAttributes<HTMLIonBreadcrumbElement>, "style"> & import("./IonicReactProps").IonicReactProps & import("react").RefAttributes<HTMLIonBreadcrumbElement>>;

package/dist/types/components/utils/detachProps.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The @stencil/react-output-target will bind event listeners for any
+ * attached props that use the `on` prefix. This function will remove
+ * those event listeners when the component is unmounted.
+ *
+ * This prevents memory leaks and React state updates on unmounted components.
+ */
+export declare const detachProps: (node: HTMLElement, props: any) => void;

package/dist/types/components/utils/index.d.ts

@@ -0,0 +1,8 @@
+import type { Config as CoreConfig, Platforms } from '@ionic/core/components';
+import React from 'react';
+import type { IonicReactProps } from '../IonicReactProps';
+export type IonicReactExternalProps<PropType, ElementType> = PropType & Omit<React.HTMLAttributes<ElementType>, 'style'> & IonicReactProps;
+export declare const createForwardRef: <PropType, ElementType>(ReactComponent: any, displayName: string) => React.ForwardRefExoticComponent<React.PropsWithoutRef<PropType & Omit<React.HTMLAttributes<ElementType>, "style"> & IonicReactProps> & React.RefAttributes<ElementType>>;
+export declare const isPlatform: (platform: Platforms) => boolean;
+export declare const getPlatforms: () => ("hybrid" | "ios" | "ipad" | "iphone" | "android" | "phablet" | "tablet" | "cordova" | "capacitor" | "electron" | "pwa" | "mobile" | "mobileweb" | "desktop")[];
+export declare const getConfig: () => CoreConfig | null;

package/dist/types/components/utils/ionRenderToString.d.ts

@@ -0,0 +1,2 @@
+import type { SerializeDocumentOptions } from '@ionic/core/hydrate';
+export declare function ionRenderToString(html: string, userAgent: string, options?: SerializeDocumentOptions): Promise<string>;

package/dist/types/contexts/IonContext.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { ReactComponentOrElement } from '../models';
+export interface IonContextInterface {
+    addOverlay: (id: string, overlay: ReactComponentOrElement, containerElement: HTMLDivElement) => void;
+    removeOverlay: (id: string) => void;
+}
+export declare const IonContext: React.Context<IonContextInterface>;

package/dist/types/contexts/IonLifeCycleContext.d.ts

@@ -0,0 +1,72 @@
+import React from 'react';
+export interface IonLifeCycleContextInterface {
+    onIonViewWillEnter: (callback: () => void) => void;
+    ionViewWillEnter: () => void;
+    onIonViewDidEnter: (callback: () => void) => void;
+    ionViewDidEnter: () => void;
+    onIonViewWillLeave: (callback: () => void) => void;
+    ionViewWillLeave: () => void;
+    onIonViewDidLeave: (callback: () => void) => void;
+    ionViewDidLeave: () => void;
+    cleanupIonViewWillEnter: (callback: () => void) => void;
+    cleanupIonViewDidEnter: (callback: () => void) => void;
+    cleanupIonViewWillLeave: (callback: () => void) => void;
+    cleanupIonViewDidLeave: (callback: () => void) => void;
+}
+export declare const IonLifeCycleContext: React.Context<IonLifeCycleContextInterface>;
+export interface LifeCycleCallback {
+    (): void | (() => void | undefined);
+    id?: number;
+}
+export interface LifeCycleDestructor {
+    id: number;
+    destructor: ReturnType<LifeCycleCallback>;
+}
+export declare const DefaultIonLifeCycleContext: {
+    new (): {
+        ionViewWillEnterCallbacks: LifeCycleCallback[];
+        ionViewDidEnterCallbacks: LifeCycleCallback[];
+        ionViewWillLeaveCallbacks: LifeCycleCallback[];
+        ionViewDidLeaveCallbacks: LifeCycleCallback[];
+        componentCanBeDestroyedCallback?: (() => void) | undefined;
+        ionViewWillEnterDestructorCallbacks: LifeCycleDestructor[];
+        ionViewDidEnterDestructorCallbacks: LifeCycleDestructor[];
+        ionViewWillLeaveDestructorCallbacks: LifeCycleDestructor[];
+        ionViewDidLeaveDestructorCallbacks: LifeCycleDestructor[];
+        onIonViewWillEnter(callback: LifeCycleCallback): void;
+        teardownCallback(callback: LifeCycleCallback, callbacks: any[]): void;
+        /**
+         * Tears down the user-provided ionViewWillEnter lifecycle callback.
+         * This is the same behavior as React's useEffect hook. The callback
+         * is invoked when the component is unmounted.
+         */
+        cleanupIonViewWillEnter(callback: LifeCycleCallback): void;
+        /**
+         * Tears down the user-provided ionViewDidEnter lifecycle callback.
+         * This is the same behavior as React's useEffect hook. The callback
+         * is invoked when the component is unmounted.
+         */
+        cleanupIonViewDidEnter(callback: LifeCycleCallback): void;
+        /**
+         * Tears down the user-provided ionViewWillLeave lifecycle callback.
+         * This is the same behavior as React's useEffect hook. The callback
+         * is invoked when the component is unmounted.
+         */
+        cleanupIonViewWillLeave(callback: LifeCycleCallback): void;
+        /**
+         * Tears down the user-provided ionViewDidLeave lifecycle callback.
+         * This is the same behavior as React's useEffect hook. The callback
+         * is invoked when the component is unmounted.
+         */
+        cleanupIonViewDidLeave(callback: LifeCycleCallback): void;
+        ionViewWillEnter(): void;
+        onIonViewDidEnter(callback: LifeCycleCallback): void;
+        ionViewDidEnter(): void;
+        onIonViewWillLeave(callback: LifeCycleCallback): void;
+        ionViewWillLeave(): void;
+        onIonViewDidLeave(callback: LifeCycleCallback): void;
+        ionViewDidLeave(): void;
+        onComponentCanBeDestroyed(callback: () => void): void;
+        componentCanBeDestroyed(): void;
+    };
+};

package/dist/types/contexts/NavContext.d.ts

@@ -0,0 +1,17 @@
+import type { AnimationBuilder, RouterDirection } from '@ionic/core/components';
+import React from 'react';
+import type { RouteInfo } from '../models';
+export interface NavContextState {
+    getIonRoute: () => any;
+    getIonRedirect: () => any;
+    getPageManager: () => any;
+    getStackManager: () => any;
+    goBack: (route?: string | RouteInfo, animationBuilder?: AnimationBuilder) => void;
+    navigate: (path: string, direction?: RouterDirection | 'none', ionRouteAction?: 'push' | 'replace' | 'pop', animationBuilder?: AnimationBuilder, options?: any, tab?: string) => void;
+    hasIonicRouter: () => boolean;
+    routeInfo?: RouteInfo;
+    setCurrentTab: (tab: string, routeInfo: RouteInfo) => void;
+    changeTab: (tab: string, path: string, routeOptions?: any) => void;
+    resetTab: (tab: string, originalHref: string, originalRouteOptions?: any) => void;
+}
+export declare const NavContext: React.Context<NavContextState>;

package/dist/types/framework-delegate.d.ts

@@ -0,0 +1,2 @@
+import type { FrameworkDelegate } from '@ionic/core/components';
+export declare const ReactDelegate: (addView: (view: React.ReactElement) => void, removeView: (view: React.ReactElement) => void) => FrameworkDelegate;

package/dist/types/hooks/HookOverlayOptions.d.ts

@@ -0,0 +1,7 @@
+import type { OverlayEventDetail } from '@ionic/core/components';
+export interface HookOverlayOptions {
+    onDidDismiss?: (event: CustomEvent<OverlayEventDetail>) => void;
+    onDidPresent?: (event: CustomEvent<OverlayEventDetail>) => void;
+    onWillDismiss?: (event: CustomEvent<OverlayEventDetail>) => void;
+    onWillPresent?: (event: CustomEvent<OverlayEventDetail>) => void;
+}

package/dist/types/hooks/useController.d.ts

@@ -0,0 +1,12 @@
+import type { HookOverlayOptions } from './HookOverlayOptions';
+interface OverlayBase extends HTMLElement {
+    present: () => Promise<void>;
+    dismiss: (data?: any, role?: string | undefined) => Promise<boolean>;
+}
+export declare function useController<OptionsType, OverlayType extends OverlayBase>(displayName: string, controller: {
+    create: (options: OptionsType) => Promise<OverlayType>;
+}, defineCustomElement: () => void): {
+    present: (options: OptionsType & HookOverlayOptions) => Promise<void>;
+    dismiss: () => Promise<void>;
+};
+export {};

package/dist/types/hooks/useIonActionSheet.d.ts

@@ -0,0 +1,26 @@
+import type { ActionSheetButton, ActionSheetOptions } from '@ionic/core/components';
+import type { HookOverlayOptions } from './HookOverlayOptions';
+/**
+ * A hook for presenting/dismissing an IonActionSheet component
+ * @returns Returns the present and dismiss methods in an array
+ */
+export declare function useIonActionSheet(): UseIonActionSheetResult;
+export type UseIonActionSheetResult = [
+    {
+        /**
+         * Presents the action sheet
+         * @param buttons An array of buttons for the action sheet
+         * @param header Optional - Title for the action sheet
+         */
+        (buttons: ActionSheetButton[], header?: string | undefined): Promise<void>;
+        /**
+         * Presents the action sheet
+         * @param options The options to pass to the IonActionSheet
+         */
+        (options: ActionSheetOptions & HookOverlayOptions): Promise<void>;
+    },
+    /**
+     * Dismisses the action sheet
+     */
+    () => Promise<void>
+];

package/dist/types/hooks/useIonAlert.d.ts

@@ -0,0 +1,26 @@
+import type { AlertButton, AlertOptions } from '@ionic/core/components';
+import type { HookOverlayOptions } from './HookOverlayOptions';
+/**
+ * A hook for presenting/dismissing an IonAlert component
+ * @returns Returns the present and dismiss methods in an array
+ */
+export declare function useIonAlert(): UseIonAlertResult;
+export type UseIonAlertResult = [
+    {
+        /**
+         * Presents the alert
+         * @param message The main message to be displayed in the alert
+         * @param buttons Optional - Array of buttons to be added to the alert
+         */
+        (message: string, buttons?: AlertButton[]): Promise<void>;
+        /**
+         * Presents the alert
+         * @param options The options to pass to the IonAlert
+         */
+        (options: AlertOptions & HookOverlayOptions): Promise<void>;
+    },
+    /**
+     * Dismisses the alert
+     */
+    () => Promise<void>
+];

package/dist/types/hooks/useIonLoading.d.ts

@@ -0,0 +1,27 @@
+import type { LoadingOptions, SpinnerTypes } from '@ionic/core/components';
+import type { HookOverlayOptions } from './HookOverlayOptions';
+/**
+ * A hook for presenting/dismissing an IonLoading component
+ * @returns Returns the present and dismiss methods in an array
+ */
+export declare function useIonLoading(): UseIonLoadingResult;
+export type UseIonLoadingResult = [
+    {
+        /**
+         * Presents the loading indicator
+         * @param message Optional - Text content to display in the loading indicator, defaults to blank string
+         * @param duration Optional - Number of milliseconds to wait before dismissing the loading indicator
+         * @param spinner Optional - The name of the spinner to display, defaults to "lines"
+         */
+        (message?: string, duration?: number, spinner?: SpinnerTypes): Promise<void>;
+        /**
+         * Presents the loading indicator
+         * @param options The options to pass to the IonLoading
+         */
+        (options: LoadingOptions & HookOverlayOptions): Promise<void>;
+    },
+    /**
+     * Dismisses the loading indicator
+     */
+    () => Promise<void>
+];

package/dist/types/hooks/useIonModal.d.ts

@@ -0,0 +1,17 @@
+import type { ModalOptions } from '@ionic/core/components';
+import type { ReactComponentOrElement } from '../models/ReactComponentOrElement';
+import type { HookOverlayOptions } from './HookOverlayOptions';
+/**
+ * A hook for presenting/dismissing an IonModal component
+ * @param component The component that the modal will show. Can be a React Component, a functional component, or a JSX Element
+ * @param componentProps The props that will be passed to the component, if required
+ * @returns Returns the present and dismiss methods in an array
+ */
+export declare function useIonModal(component: ReactComponentOrElement, componentProps?: any): UseIonModalResult;
+export type UseIonModalResult = [
+    (options?: Omit<ModalOptions, 'component' | 'componentProps'> & HookOverlayOptions) => void,
+    /**
+     * Dismisses the modal
+     */
+    (data?: any, role?: string) => void
+];

package/dist/types/hooks/useIonPicker.d.ts

@@ -0,0 +1,26 @@
+import type { PickerButton, PickerColumn, PickerOptions } from '@ionic/core/components';
+import type { HookOverlayOptions } from './HookOverlayOptions';
+/**
+ * A hook for presenting/dismissing an IonPicker component
+ * @returns Returns the present and dismiss methods in an array
+ */
+export declare function useIonPicker(): UseIonPickerResult;
+export type UseIonPickerResult = [
+    {
+        /**
+         * Presents the picker
+         * @param columns Array of columns to be displayed in the picker.
+         * @param buttons Optional - Array of buttons to be displayed at the top of the picker.
+         */
+        (columns: PickerColumn[], buttons?: PickerButton[]): Promise<void>;
+        /**
+         * Presents the picker
+         * @param options The options to pass to the IonPicker
+         */
+        (options: PickerOptions & HookOverlayOptions): Promise<void>;
+    },
+    /**
+     * Dismisses the picker
+     */
+    () => Promise<void>
+];

package/dist/types/hooks/useIonPopover.d.ts

@@ -0,0 +1,17 @@
+import type { PopoverOptions } from '@ionic/core/components';
+import type { ReactComponentOrElement } from '../models/ReactComponentOrElement';
+import type { HookOverlayOptions } from './HookOverlayOptions';
+/**
+ * A hook for presenting/dismissing an IonPicker component
+ * @param component The component that the popover will show. Can be a React Component, a functional component, or a JSX Element
+ * @param componentProps The props that will be passed to the component, if required
+ * @returns Returns the present and dismiss methods in an array
+ */
+export declare function useIonPopover(component: ReactComponentOrElement, componentProps?: any): UseIonPopoverResult;
+export type UseIonPopoverResult = [
+    (options?: Omit<PopoverOptions, 'component' | 'componentProps'> & HookOverlayOptions) => void,
+    /**
+     * Dismisses the popover
+     */
+    (data?: any, role?: string) => void
+];

package/dist/types/hooks/useIonToast.d.ts

@@ -0,0 +1,26 @@
+import type { ToastOptions } from '@ionic/core/components';
+import type { HookOverlayOptions } from './HookOverlayOptions';
+/**
+ * A hook for presenting/dismissing an IonToast component
+ * @returns Returns the present and dismiss methods in an array
+ */
+export declare function useIonToast(): UseIonToastResult;
+export type UseIonToastResult = [
+    {
+        /**
+         * Presents the toast
+         * @param message Message to be shown in the toast.
+         * @param duration Optional - How many milliseconds to wait before hiding the toast. By default, it will show until dismissToast() is called.
+         */
+        (message: string, duration?: number): Promise<void>;
+        /**
+         * Presents the Toast
+         * @param options The options to pass to the IonToast.
+         */
+        (options: ToastOptions & HookOverlayOptions): Promise<void>;
+    },
+    /**
+     * Dismisses the toast
+     */
+    () => Promise<void>
+];

package/dist/types/hooks/useOverlay.d.ts

@@ -0,0 +1,13 @@
+import type { ReactComponentOrElement } from '../models/ReactComponentOrElement';
+import type { HookOverlayOptions } from './HookOverlayOptions';
+interface OverlayBase extends HTMLElement {
+    present: () => Promise<void>;
+    dismiss: (data?: any, role?: string | undefined) => Promise<boolean>;
+}
+export declare function useOverlay<OptionsType, OverlayType extends OverlayBase>(displayName: string, controller: {
+    create: (options: OptionsType) => Promise<OverlayType>;
+}, defineCustomElement: () => void, component: ReactComponentOrElement, componentProps?: any): {
+    present: (options: OptionsType & HookOverlayOptions) => Promise<void>;
+    dismiss: (data?: any, role?: string) => Promise<void>;
+};
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,7 @@
+export * from './lifecycle';
+export * from './contexts/NavContext';
+export * from './contexts/IonLifeCycleContext';
+export * from './components';
+export * from './routing';
+export * from './models';
+export * from './utils/generateId';