@ionic/core 8.8.20-dev.11787158518.168a2fea → 8.8.20-dev.11789504012.1a675914

package/dist/types/components/gallery/gallery-interface.d.ts

@@ -0,0 +1,10 @@
+export interface GalleryBreakpoints<T = string | number> {
+    xs?: T;
+    sm?: T;
+    md?: T;
+    lg?: T;
+    xl?: T;
+    xxl?: T;
+}
+export type GalleryColumns = GalleryBreakpoints | string | number;
+export type GalleryGap = GalleryBreakpoints | string | number;

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

@@ -0,0 +1,218 @@
+import type { ComponentInterface } from '../../stencil-public-runtime';
+import type { GalleryColumns, GalleryGap } from './gallery-interface';
+/**
+ * @virtualProp {"ios" | "md"} mode - The mode determines the platform behaviors of the component.
+ * @virtualProp {"ios" | "md" | "ionic"} theme - The theme determines the visual appearance of the component.
+ *
+ * @slot - One or more `ion-gallery-item` components, placed in a responsive
+ * gallery layout.
+ */
+export declare class Gallery implements ComponentInterface {
+    el: HTMLIonGalleryElement;
+    private masonryRaf?;
+    private resizeObserver?;
+    private lastWidth?;
+    private hasWarnedInvalidColumns;
+    private hasWarnedInvalidGap;
+    private hasWarnedUnusedOrder;
+    private hasWarnedInvalidItems;
+    /**
+     * The visual layout of the gallery. When `uniform`, rows take up the height
+     * of the tallest item and are spaced evenly across the gallery. Additionally,
+     * items will have an aspect ratio of 1/1, forcing them to be square unless a
+     * height is explicitly set. When `masonry`, items will be positioned under each
+     * other with only the specified gap between them.
+     */
+    layout: 'uniform' | 'masonry';
+    /**
+     * The order in which items are positioned. Only applies when layout is
+     * `masonry`. When `sequential`, items are positioned in the order they are
+     * placed in the DOM. When `best-fit`, items are positioned under the column
+     * with the most available space. Defaults to `sequential` when layout is
+     * `masonry` and `order` is not explicitly set.
+     */
+    order?: 'sequential' | 'best-fit';
+    /**
+     * The number of columns to display. Can be set as a number or an object of
+     * breakpoint values (e.g. `{ xs: 2, sm: 3, md: 4 }`).
+     */
+    columns: GalleryColumns;
+    /**
+     * The space between gallery items. Accepts valid CSS [length-percentage](https://developer.mozilla.org/en-US/docs/Web/CSS/Reference/Values/length-percentage)
+     * values like `16px`, `1rem`, `20%`, math functions like `calc(10px + 20%)`,
+     * CSS variables like `var(--app-gallery-gap)`, or numbers (treated as pixel
+     * values). Can also be set as a breakpoint map
+     * (e.g. `{ xs: '8px', sm: '1rem', md: '24px' }`). Does not accept
+     * space-separated values or CSS keyword values like `inherit`, `auto`, etc.
+     */
+    gap: GalleryGap;
+    protected onColumnsOrGapChanged(): void;
+    protected onLayoutOrOrderChanged(): void;
+    /**
+     * Sync the current layout with each item when the gallery's `layout`
+     * changes.
+     */
+    private syncItemLayout;
+    componentDidLoad(): void;
+    disconnectedCallback(): void;
+    /**
+     * Observe the host and each item for size changes. Items are observed in
+     * addition to the host so masonry placement is recomputed when an item's
+     * rendered height changes — most importantly when a dynamically added
+     * `ion-gallery-item` finishes hydrating, which (unlike an `<img>`) emits no
+     * `load` event and does not change the host's measured size while collapsed.
+     */
+    private observeResizes;
+    /**
+     * Listen for the load event on child elements.
+     * When the layout is `masonry`, this listener is used to schedule a resize
+     * of the masonry grid when the child elements load. This is useful for when
+     * images take time to load.
+     */
+    protected onChildLoad(ev: Event): void;
+    /**
+     * Listen for the slotchange event on the slot. When the gallery's items are
+     * added or removed, re-collapse wrappers, re-observe items for size changes,
+     * and recompute the masonry grid.
+     */
+    private onSlotChange;
+    /**
+     * Recompute the gallery column and gap variables and masonry placement when
+     * columns, gap, layout, or order change.
+     */
+    private syncResponsiveLayout;
+    /**
+     * Batch masonry measurements to a single animation frame.
+     * This avoids repeated sync layouts during rapid resize/load/slot changes.
+     */
+    private scheduleMasonryResize;
+    /**
+     * Normalize a single column value (`columns` as a number, string, or one entry from
+     * a `columns` breakpoint map) to a positive integer. Returns `undefined` when
+     * the input cannot be interpreted as a finite number.
+     */
+    private sanitizeColumns;
+    /**
+     * Normalize a single gap value (`gap` as a number, a string such as a CSS
+     * length-percentage or `var()` reference, or one entry from a `gap`
+     * breakpoint map) to a CSS length string. Returns `undefined` when the
+     * input cannot be interpreted as a valid CSS length or `var()` reference.
+     */
+    private sanitizeGap;
+    /**
+     * Check if the value is a breakpoint map object.
+     */
+    private isBreakpointMap;
+    /**
+     * Check if the breakpoint map has any invalid values for the provided
+     * sanitizer. A breakpoint map is invalid when there are no valid breakpoint
+     * keys set (e.g. `{}` or `{ colums: 3 }`), or when a value under a
+     * breakpoint key fails the sanitizer (e.g. `{ xs: -3 }`, `{ sm: 'foo' }`).
+     */
+    private hasInvalidBreakpointMap;
+    /**
+     * Resolve a responsive value from a breakpoint map.
+     * Uses a breakpoint-specific default when custom values are missing/invalid.
+     */
+    private resolveFromBreakpoints;
+    /**
+     * Get the columns from a responsive breakpoint map.
+     * Returns the columns for the last matching breakpoint.
+     */
+    private getColumnsFromBreakpointMap;
+    /**
+     * Get the gap from a responsive breakpoint map.
+     * Returns the gap for the last matching breakpoint.
+     */
+    private getGapFromBreakpointMap;
+    /**
+     * Warn about an invalid columns value when it is set to a negative number,
+     * an empty breakpoint map, a map with no supported breakpoint keys,
+     * or a map with invalid breakpoint values.
+     */
+    private warnInvalidColumns;
+    /**
+     * Warn about an invalid gap value when it is set to a negative number,
+     * an empty breakpoint map, a map with no supported breakpoint keys,
+     * or a map with invalid breakpoint values.
+     */
+    private warnInvalidGap;
+    /**
+     * Warn when `order` is explicitly set while layout is `uniform`.
+     */
+    private warnUnusedOrder;
+    /**
+     * Resolve the active columns value for the current width. Falls back to
+     * the default responsive columns when the provided prop is invalid.
+     */
+    private getColumnsForWidth;
+    /**
+     * Resolve the active gap value for the current width.
+     */
+    private getGapForWidth;
+    /**
+     * Update the responsive styles for the gallery. This is used to update
+     * the columns and gap when the component width changes.
+     */
+    private updateResponsiveStyles;
+    /**
+     * Return the `ion-gallery-item` elements to place in the grid. Each item is a
+     * direct grid cell, whether a direct child or nested inside a pass-through
+     * wrapper (e.g. a layout `<div>`). Items belonging to a nested `ion-gallery`
+     * are excluded.
+     */
+    private getItems;
+    /**
+     * Collapse each pass-through wrapper's box with `display: contents` so its
+     * items participate in the gallery grid. Restore the box of a wrapper that
+     * no longer contains items, and warn about children that contain none.
+     */
+    private collapseWrappers;
+    /**
+     * Warn when the gallery has content that is not wrapped in an
+     * `ion-gallery-item` component. Items belonging to a nested
+     * gallery are considered invalid content for the parent gallery.
+     */
+    private warnInvalidItems;
+    /**
+     * Clear the item styles for the given item element.
+     * This is used to switch between uniform and masonry layouts.
+     */
+    private clearItemStyles;
+    /**
+     * Clear placement styles for all items when leaving masonry mode.
+     */
+    private clearMasonryStyles;
+    /**
+     * Whether the item contains any images that have not finished loading.
+     * Used to defer masonry placement until the rendered height is final.
+     */
+    private hasUnloadedImages;
+    /**
+     * Convert a rendered item height to the number of grid rows it should span.
+     * Returns undefined when the item has images that are not fully loaded yet.
+     */
+    private calculateRowSpan;
+    /**
+     * Get the index of the column to position the item in.
+     * When the order is `best-fit`, the column with the shortest height is
+     * returned. Otherwise, items are placed in the column that matches their
+     * natural DOM order.
+     */
+    private getColumnIndex;
+    /**
+     * Apply masonry placement by assigning each item a column and row span.
+     */
+    private layoutMasonry;
+    /**
+     * Measure the host and children, then compute masonry placement.
+     */
+    private resizeMasonryGrid;
+    /**
+     * Resolved order for layout and CSS. Order should be `undefined` for
+     * the uniform layout. When order is not set, it should be `"sequential"`
+     * for the masonry layout.
+     */
+    private getOrder;
+    render(): any;
+}

package/dist/types/components/gallery/test/utils.d.ts

@@ -0,0 +1,3 @@
+export declare const sharedGalleryStyles = "\n  ion-gallery {\n    width: 343px;\n  }\n";
+export declare const sharedGalleryItemStyles = "\n  ion-gallery-item {\n    color: #fff;\n  }\n\n  ion-gallery-item:nth-child(1) {\n    background: #ff6b6b;\n  }\n\n  ion-gallery-item:nth-child(2) {\n    background: #4ecdc4;\n  }\n\n  ion-gallery-item:nth-child(3) {\n    background: #ffe66d;\n    color: #333;\n  }\n\n  ion-gallery-item:nth-child(4) {\n    background: #5f27cd;\n  }\n\n  ion-gallery-item:nth-child(5) {\n    background: #7f8c8d;\n  }\n\n  ion-gallery-item:nth-child(6) {\n    background: #ff9f43;\n  }\n\n  ion-gallery-item:nth-child(7) {\n    background: #ff3f34;\n  }\n\n  ion-gallery-item:nth-child(8) {\n    background: #2ecc71;\n  }\n\n  ion-gallery-item:nth-child(9) {\n    background: #34495e;\n  }\n\n  ion-gallery-item:nth-child(10) {\n    background: #1abc9c;\n  }\n\n  ion-gallery-item:nth-child(11) {\n    background: #e67e22;\n  }\n\n  ion-gallery-item:nth-child(12) {\n    background: #9b59b6;\n  }\n";
+export declare const numberToWords: (value: number) => string;

package/dist/types/components/gallery-item/gallery-item.d.ts

@@ -0,0 +1,33 @@
+import type { ComponentInterface } from '../../stencil-public-runtime';
+/**
+ * @virtualProp {"ios" | "md"} mode - The mode determines the platform behaviors of the component.
+ * @virtualProp {"ios" | "md" | "ionic"} theme - The theme determines the visual appearance of the component.
+ *
+ * @slot - The content placed inside of the gallery item. This is typically an
+ * `img`, but can be any element (e.g. a `figure` wrapping an image and caption).
+ */
+export declare class GalleryItem implements ComponentInterface {
+    private hasWarnedInvalidParent;
+    el: HTMLIonGalleryItemElement;
+    /**
+     * The layout of the parent `ion-gallery`, mirrored as a class so the item
+     * can apply layout-specific styles (e.g. a square aspect ratio in the
+     * `uniform` layout, a bottom margin in the `masonry` layout).
+     */
+    galleryLayout?: 'uniform' | 'masonry';
+    componentWillLoad(): void;
+    componentDidLoad(): void;
+    connectedCallback(): void;
+    /**
+     * Resolve the layout from the parent `ion-gallery`. Called internally on
+     * load and connect, and by the gallery when its layout changes.
+     * @internal
+     */
+    syncGalleryLayout(): Promise<void>;
+    private onSlotChange;
+    /**
+     * Warn when the item is not a descendant of an `ion-gallery`.
+     */
+    private warnInvalidParent;
+    render(): any;
+}

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

@@ -1,4 +1,8 @@
 import type { ComponentInterface } from '../../stencil-public-runtime';
+/**
+ * @virtualProp {"ios" | "md"} mode - The mode determines the platform behaviors of the component.
+ * @virtualProp {"ios" | "md" | "ionic"} theme - The theme determines the visual appearance of the component.
+ */
 export declare class Grid implements ComponentInterface {
     /**
      * If `true`, the grid will have a fixed width based on the screen size.

package/dist/types/components/header/header-interface.d.ts

@@ -0,0 +1 @@
+export type HeaderScrollEffect = 'hide' | 'condense' | 'fade';

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

@@ -1,6 +1,8 @@
 import type { ComponentInterface } from '../../stencil-public-runtime';
+import type { HeaderScrollEffect } from './header-interface';
 /**
- * @virtualProp {"ios" | "md"} mode - The mode determines which platform styles to use.
+ * @virtualProp {"ios" | "md"} mode - The mode determines the platform behaviors of the component.
+ * @virtualProp {"ios" | "md" | "ionic"} theme - The theme determines the visual appearance of the component.
  */
 export declare class Header implements ComponentInterface {
     private scrollEl?;
@@ -8,17 +10,37 @@ export declare class Header implements ComponentInterface {
     private intersectionObserver?;
     private collapsibleMainHeader?;
     private inheritedAttributes;
+    private scrollHideCtrl?;
+    private scrollHideCtrlPromise;
+    private hasWarnedCollapse;
+    private activeEffect?;
+    private fadeCondenseSetupId;
     el: HTMLElement;
     /**
      * Describes the scroll effect that will be applied to the header.
-     * Only applies in iOS mode.
+     * `"hide"` slides the header out of view when scrolling down and back in
+     * when scrolling up.
+     * `"condense"` collapses the large title into the main toolbar on scroll.
+     * `"fade"` fades the toolbar background on scroll.
+     */
+    scrollEffect?: HeaderScrollEffect;
+    /**
+     * Describes the scroll effect that will be applied to the header.
+     * Only applies when the theme is `"ios"`.
      *
      * Typically used for [Collapsible Large Titles](https://ionicframework.com/docs/api/title#collapsible-large-titles)
+     *
+     * @deprecated Use `scrollEffect` instead.
      */
     collapse?: 'condense' | 'fade';
+    /**
+     * If `true`, the header will have a line at the bottom.
+     * TODO(ROU-10855): add support for this prop on ios/md themes
+     */
+    divider: boolean;
     /**
      * If `true`, the header will be translucent.
-     * Only applies when the mode is `"ios"` and the device supports
+     * Only applies when the theme is `"ios"` or `"ionic"` and the device supports
      * [`backdrop-filter`](https://developer.mozilla.org/en-US/docs/Web/CSS/backdrop-filter#Browser_compatibility).
      *
      * Note: In order to scroll content behind the header, the `fullscreen`
@@ -30,6 +52,7 @@ export declare class Header implements ComponentInterface {
     componentDidUpdate(): void;
     disconnectedCallback(): void;
     private checkCollapsibleHeader;
+    private setupScrollEffectHide;
     private setupFadeHeader;
     private destroyCollapsibleHeader;
     private setupCondenseHeader;

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

@@ -27,10 +27,9 @@ export declare const handleHeaderFade: (scrollEl: HTMLElement, baseEl: HTMLEleme
  * Get the role type for the ion-header.
  *
  * @param isInsideMenu If ion-header is inside ion-menu.
- * @param isCondensed If ion-header has collapse="condense".
- * @param mode The current mode.
- * @returns 'none' if inside ion-menu or if condensed in md
- * mode, otherwise 'banner'.
+ * @returns 'none' if inside ion-menu, otherwise 'banner'.
+ * Condensed headers start as 'banner' and have their role
+ * toggled dynamically by setHeaderActive() on scroll.
  */
-export declare const getRoleType: (isInsideMenu: boolean, isCondensed: boolean, mode: "ios" | "md") => "none" | "banner";
+export declare const getRoleType: (isInsideMenu: boolean) => "none" | "banner";
 export {};

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

@@ -1,6 +1,7 @@
 import type { ComponentInterface, EventEmitter } from '../../stencil-public-runtime';
 /**
- * @deprecated
+ * @virtualProp {"ios" | "md"} mode - The mode determines the platform behaviors of the component.
+ * @virtualProp {"ios" | "md" | "ionic"} theme - The theme determines the visual appearance of the component.
  *
  * @part image - The inner `img` element.
  */

package/dist/types/components/infinite-scroll/infinite-scroll.d.ts

@@ -1,8 +1,13 @@
 import type { ComponentInterface, EventEmitter } from '../../stencil-public-runtime';
+/**
+ * @virtualProp {"ios" | "md"} mode - The mode determines the platform behaviors of the component.
+ * @virtualProp {"ios" | "md" | "ionic"} theme - The theme determines the visual appearance of the component.
+ */
 export declare class InfiniteScroll implements ComponentInterface {
     private thrPx;
     private thrPc;
     private scrollEl?;
+    private minHeightLocked;
     /**
      * didFire exists so that ionInfinite
      * does not fire multiple times if
@@ -41,6 +46,12 @@ export declare class InfiniteScroll implements ComponentInterface {
      * The value can be either `top` or `bottom`.
      */
     position: 'top' | 'bottom';
+    /**
+     * If `true`, the infinite scroll will preserve the scroll position
+     * when the content is re-rendered. This is useful when the content is
+     * re-rendered with new keys, and the scroll position should be preserved.
+     */
+    preserveRerenderScrollPosition: boolean;
     /**
      * Emitted when the scroll reaches
      * the threshold distance. From within your infinite handler,
@@ -51,6 +62,16 @@ export declare class InfiniteScroll implements ComponentInterface {
     connectedCallback(): Promise<void>;
     disconnectedCallback(): void;
     private onScroll;
+    /**
+     * Loop through our sibling elements and lock or unlock their min height.
+     * This keeps our siblings, for example `ion-list`, the same height as their
+     * content currently is, so when it loads new data and the DOM removes the old
+     * data, the height of the container doesn't change and we don't lose our scroll position.
+     *
+     * We preserve existing min-height values, if they're set, so we don't erase what
+     * has been previously set by the user when we restore after complete is called.
+     */
+    private lockSiblingMinHeight;
     /**
      * Call `complete()` within the `ionInfinite` output event handler when
      * your async operation has completed. For example, the `loading`

package/dist/types/components/infinite-scroll-content/infinite-scroll-content.d.ts

@@ -1,6 +1,10 @@
 import type { ComponentInterface } from '../../stencil-public-runtime';
 import type { IonicSafeString } from '../../utils/sanitization';
 import type { SpinnerTypes } from '../spinner/spinner-configs';
+/**
+ * @virtualProp {"ios" | "md"} mode - The mode determines the platform behaviors of the component.
+ * @virtualProp {"ios" | "md" | "ionic"} theme - The theme determines the visual appearance of the component.
+ */
 export declare class InfiniteScrollContent implements ComponentInterface {
     private customHTMLEnabled;
     /**

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

@@ -2,7 +2,8 @@ import type { ComponentInterface, EventEmitter } from '../../stencil-public-runt
 import type { AutocompleteTypes, Color, TextFieldTypes } from '../../interface';
 import type { InputChangeEventDetail, InputInputEventDetail } from './input-interface';
 /**
- * @virtualProp {"ios" | "md"} mode - The mode determines which platform styles to use.
+ * @virtualProp {"ios" | "md"} mode - The mode determines the platform behaviors of the component.
+ * @virtualProp {"ios" | "md" | "ionic"} theme - The theme determines the visual appearance of the component.
  *
  * @slot label - The label text to associate with the input. Use the `labelPlacement` property to control where the label is placed relative to the input. Use this if you need to render a label with custom HTML. (EXPERIMENTAL)
  * @slot start - Content to display at the leading edge of the input. (EXPERIMENTAL)
@@ -19,8 +20,6 @@ export declare class Input implements ComponentInterface {
     private slotMutationController?;
     private notchController?;
     private notchSpacerEl;
-    private startContainerController?;
-    private startContainerEl;
     private originalIonInput?;
     /**
      * `true` if the input was cleared as a result of the user typing
@@ -46,6 +45,9 @@ export declare class Input implements ComponentInterface {
      * Track validation state for proper aria-live announcements
      */
     isInvalid: boolean;
+    /** Keeps the clear button visible for the duration of a press. */
+    isClearButtonPressed: boolean;
+    private readonly clearButtonPressController;
     el: HTMLIonInputElement;
     private validationObserver?;
     /**
@@ -66,7 +68,7 @@ export declare class Input implements ComponentInterface {
     /**
      * Whether auto correction should be enabled when the user is entering/editing the text value.
      */
-    autocorrect: boolean;
+    autocorrect: 'on' | 'off';
     /**
      * Sets the [`autofocus` attribute](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/autofocus) on the native input element.
      *
@@ -118,7 +120,7 @@ export declare class Input implements ComponentInterface {
     errorText?: string;
     /**
      * The fill for the item. If `"solid"` the item will have a background. If
-     * `"outline"` the item will be transparent with a border. Only available in `md` mode.
+     * `"outline"` the item will be transparent with a border. Only available when the theme is `"md"`.
      */
     fill?: 'outline' | 'solid';
     /**
@@ -146,8 +148,12 @@ export declare class Input implements ComponentInterface {
      * `"floating"`: The label will appear smaller and above the input when the input is focused or it has a value. Otherwise it will appear on top of the input.
      * `"stacked"`: The label will appear smaller and above the input regardless even when the input is blurred or has no value.
      * `"fixed"`: The label has the same behavior as `"start"` except it also has a fixed width. Long text will be truncated with ellipses ("...").
+     *
+     * Defaults to "stacked" for the ionic theme, or "start" for all other themes.
+     *
+     * In the ionic theme, only the values "stacked" and "floating" are supported.
      */
-    labelPlacement: 'start' | 'end' | 'floating' | 'stacked' | 'fixed';
+    labelPlacement?: 'start' | 'end' | 'floating' | 'stacked' | 'fixed';
     /**
      * The maximum value, which must not be less than its minimum (min attribute) value.
      */
@@ -191,9 +197,12 @@ export declare class Input implements ComponentInterface {
      */
     required: boolean;
     /**
-     * The shape of the input. If "round" it will have an increased border radius.
+     * Set to `"soft"` for an input with slightly rounded corners, `"round"` for an input with fully
+     * rounded corners, or `"rectangular"` for an input without rounded corners.
+     * Defaults to `"round"` for the ionic theme, and `undefined` for all other themes.
+     * Only applies when the fill is set to `"solid"` or `"outline"`.
      */
-    shape?: 'round';
+    shape?: 'soft' | 'round' | 'rectangular';
     /**
      * If `true`, the element will have its spelling and grammar checked.
      */
@@ -203,6 +212,11 @@ export declare class Input implements ComponentInterface {
      * Possible values are: `"any"` or a positive floating point number.
      */
     step?: string;
+    /**
+     * The size of the input. If "large", it will have an increased height. By default the
+     * size is medium. This property only applies to the `"ionic"` theme.
+     */
+    size?: 'medium' | 'large' | 'xlarge';
     /**
      * The type of control to display. The default type is text.
      */
@@ -303,6 +317,10 @@ export declare class Input implements ComponentInterface {
     private emitInputChange;
     private shouldClearOnEdit;
     private getValue;
+    private getFill;
+    private getLabelPlacement;
+    private getSize;
+    private getShape;
     private onInput;
     private onChange;
     private onBlur;
@@ -349,18 +367,23 @@ export declare class Input implements ComponentInterface {
      */
     private get hasLabel();
     /**
-     * Stops propagation for clicks on the input's own content (label text,
-     * input field) to prevent double-click events. Allows clicks on slotted
-     * content to propagate so event delegation works for parent handlers.
-     *
-     * Only slots belonging directly to this input should be considered.
-     * The input itself may have a slot attribute when placed in an item
-     * or toolbar, which does not make its content slotted content.
+     * Stops propagation when the label is clicked,
+     * otherwise, two clicks will be triggered.
      */
     private onLabelClick;
     /**
-     * Renders the outline border with a notch for the label.
+     * Renders the border container
+     * when fill="outline".
+     */
+    private renderLabelContainer;
+    /**
+     * Get the icon to use for the clear icon.
+     * If an icon is set on the component, use that.
+     * Otherwise, use the icon set in the config.
+     * If no icon is set in the config, use the default icon.
+     *
+     * @internal
      */
-    private renderOutlineContainer;
+    get inputClearIcon(): string;
     render(): any;
 }

package/dist/types/components/input-otp/input-otp.d.ts

@@ -1,6 +1,16 @@
 import type { ComponentInterface, EventEmitter } from '../../stencil-public-runtime';
 import type { Color } from '../../interface';
 import type { InputOtpChangeEventDetail, InputOtpCompleteEventDetail, InputOtpInputEventDetail } from './input-otp-interface';
+/**
+ * @virtualProp {"ios" | "md"} mode - The mode determines the platform behaviors of the component.
+ * @virtualProp {"ios" | "md" | "ionic"} theme - The theme determines the visual appearance of the component.
+ *
+ * @part group - The container element that wraps all input boxes.
+ * @part container - The wrapper element for each individual input box.
+ * @part native - The native input element.
+ * @part separator - The separator element displayed between input boxes.
+ * @part description - The container element for the description text.
+ */
 export declare class InputOTP implements ComponentInterface {
     private inheritedAttributes;
     private inputRefs;
@@ -19,6 +29,7 @@ export declare class InputOTP implements ComponentInterface {
      */
     private isKeyboardNavigation;
     el: HTMLIonInputOtpElement;
+    internals: ElementInternals;
     private inputValues;
     hasFocus: boolean;
     private previousInputValues;
@@ -37,6 +48,10 @@ export declare class InputOTP implements ComponentInterface {
      * If `true`, the user cannot interact with the input.
      */
     disabled: boolean;
+    /**
+     * Update element internals when disabled prop changes
+     */
+    protected disabledChanged(): void;
     /**
      * The fill for the input boxes. If `"solid"` the input boxes will have a background. If
      * `"outline"` the input boxes will be transparent with a border.
@@ -180,6 +195,28 @@ export declare class InputOTP implements ComponentInterface {
      * If all of the input boxes are filled, it emits an `ionComplete` event.
      */
     private updateValue;
+    /**
+     * Gets the value of the input group as a string for form submission.
+     * Returns an empty string if the value is null or undefined.
+     */
+    private getValue;
+    /**
+     * Called when the form state is restored.
+     * Restores the component's value.
+     */
+    formStateRestoreCallback(value: string): void;
+    /**
+     * Called when the form is reset.
+     * Resets the component's value.
+     */
+    formResetCallback(): void;
+    /**
+     * Updates the form value and reports validity state to the browser via
+     * ElementInternals. This should be called when the component loads, when
+     * the disabled prop changes, and when the value changes to ensure the form
+     * value stays in sync and validation state is updated.
+     */
+    private updateElementInternals;
     /**
      * Emits an `ionChange` event.
      * This API should be called for user committed changes.

package/dist/types/components/input-password-toggle/input-password-toggle.d.ts

@@ -33,5 +33,19 @@ export declare class InputPasswordToggle implements ComponentInterface {
     connectedCallback(): void;
     disconnectedCallback(): void;
     private togglePasswordVisibility;
+    /**
+     * Get the icon to use for the hide icon.
+     * If an icon is set on the component, use that.
+     * Otherwise, use the icon set in the config.
+     * If no icon is set in the config, use the default icon.
+     */
+    get inputPasswordHideIcon(): any;
+    /**
+     * Get the icon to use for the show icon.
+     * If an icon is set on the component, use that.
+     * Otherwise, use the icon set in the config.
+     * If no icon is set in the config, use the default icon.
+     */
+    get inputPasswordShowIcon(): any;
     render(): any;
 }