@siemens/ix 4.4.0 → 5.1.0

package/dist/types/components/time-picker/time-picker.d.ts

@@ -1,7 +1,19 @@
 import { EventEmitter } from '../../stencil-public-runtime';
-import type { TimePickerCorners } from './time-picker.types';
-type TimePickerDescriptorUnit = 'hour' | 'minute' | 'second' | 'millisecond';
-export declare class TimePicker {
+import type { TimePickerCorners, TimePickerDescriptorUnit } from './time-picker.types';
+declare const TimePicker_base: abstract new (...args: any[]) => {
+    componentDidLoad(): void;
+    disconnectedCallback(): void;
+    hostElement?: import("@stencil/core/internal").HTMLStencilElement;
+    connectedCallback?(): void;
+    componentWillRender?(): Promise<void> | void;
+    componentDidRender?(): void;
+    componentWillLoad?(): Promise<void> | void;
+    componentShouldUpdate?(newVal: any, oldVal: any, propName: string): boolean | void;
+    componentWillUpdate?(): Promise<void> | void;
+    componentDidUpdate?(): void;
+    render?(): any;
+} & import("../utils/internal/component").StencilLifecycle;
+export declare class TimePicker extends TimePicker_base {
     hostElement: HTMLIxTimePickerElement;
     /**
      * Format of time string.
@@ -57,12 +69,25 @@ export declare class TimePicker {
     millisecondInterval: number;
     watchMillisecondIntervalPropHandler(newValue: number): void;
     private printIntervalError;
+    private warnIfConstraintTimeInvalid;
+    private warnIfConstraintRangeInverted;
+    private warnConstraintTimesIfInvalid;
     /**
      * Selected time value.
      * Format has to match the `format` property.
      */
     time?: string;
-    watchTimePropHandler(newValue: string): void;
+    watchTimePropHandler(newValue: string | undefined): void;
+    /** Earliest selectable time (`format` tokens). Invalid non-empty values are ignored.
+     *
+     * @since 5.0.0 */
+    minTime?: string;
+    /** Latest selectable time (`format` tokens). Invalid non-empty values are ignored.
+     *
+     * @since 5.0.0 */
+    maxTime?: string;
+    watchMinTimePropHandler(): void;
+    watchMaxTimePropHandler(): void;
     /**
      * Get default time value
      * @returns DateTime.now() for empty state (no selection)
@@ -126,20 +151,38 @@ export declare class TimePicker {
     private getElementContainer;
     private isElementVisible;
     private scrollElementIntoView;
-    private updateFocusedValue;
     private setInitialFocusedValueAndUnit;
     private setupVisibilityObserver;
     private mutationObserverCallback;
     private areElementsRendered;
     private getFormattedTime;
-    private timeUpdate;
     private changeTimeReference;
-    private isFormat12Hour;
+    /** `_time` or “now” (constraints, AM/PM, confirm). */
+    private referenceOrNow;
     private setTimeRef;
-    private getInitialFocusedValueForUnit;
+    private getConstraintBounds;
+    /** Bounds and `selectionBase` from {@link referenceOrNow}. */
+    private getUnitSelectionContext;
+    private isWithinTimeConstraints;
+    private canSelectUnitValue;
+    private isSelectableForUnitWithinBounds;
+    /** Provisional `unit` for cross-column base: roving cell, earlier descriptors, else displayed digits. */
+    private getProvisionalRawValue;
+    /** Base time for `canSelect`/`select` on `targetUnit`: committed hour; mid-columns via {@link getProvisionalRawValue}. */
+    private buildCandidateBaseBeforeUnit;
+    private getConstrainedFocusedValueForUnitWithBase;
+    private getConstrainedFocusedValueForUnit;
+    private resolvePreservedFocusedValueOnColumnBlur;
+    private syncKeyboardFocusWithConstraints;
+    private findFirstSelectableInUnit;
+    private getColumnTabStopValue;
+    private stepFocusedValue;
+    private isConfirmDisabled;
     private setTimePickerDescriptors;
     private getNumberArrayForUnit;
     private isSelected;
+    /** Roving tabindex: one tab stop per column; active column only the focused cell has `tabindex=0`. */
+    private getUnitCellTabIndex;
     private select;
     private updateDescriptorFocusedValue;
     private elementListScrollToTop;
@@ -150,7 +193,6 @@ export declare class TimePicker {
     private updateScrollPositions;
     private formatUnitValue;
     private getColumnSeparator;
-    private getElementContainerTabIndex;
     render(): any;
 }
 export {};

package/dist/types/components/time-picker/time-picker.types.d.ts

@@ -1,2 +1,3 @@
 import type { DateTimeCardCorners } from '../date-time-card/date-time-card.types';
 export type TimePickerCorners = DateTimeCardCorners;
+export type TimePickerDescriptorUnit = 'hour' | 'minute' | 'second' | 'millisecond';

package/dist/types/components/toast/toast-container.d.ts

@@ -1,19 +1,11 @@
-import { ToastConfig } from './toast-utils';
 import type { ShowToastResult } from './toast-container.types';
+import { ToastConfig } from './toast-utils';
 export declare class ToastContainer {
+    hostElement: HTMLIxToastContainerElement;
     /**
-     */
-    containerId: string;
-    /**
-     */
-    containerClass: string;
-    /**
+     * Position of the toast container. Determines where the toasts will be displayed on the screen.
      */
     position: 'bottom-right' | 'top-right';
-    private readonly PREFIX_POSITION_CLASS;
-    get hostContainer(): Promise<HTMLElement>;
-    componentDidLoad(): void;
-    onPositionChange(newPosition: string, oldPosition: string): void;
     /**
      * Display a toast message
      * @param config

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

@@ -1,9 +1,38 @@
 import { EventEmitter } from '../../stencil-public-runtime';
+import { InheritAriaAttributesMixinContract } from '../utils/internal/mixins/accessibility/inherit-aria-attributes.mixin';
 import { IxFormComponent } from '../utils/input';
+declare const Toggle_base: abstract new (...args: any[]) => {
+    componentDidLoad(): void;
+    disconnectedCallback(): void;
+    hostElement?: import("@stencil/core/internal").HTMLStencilElement;
+    connectedCallback?(): void;
+    componentWillRender?(): Promise<void> | void;
+    componentDidRender?(): void;
+    componentWillLoad?(): Promise<void> | void;
+    componentShouldUpdate?(newVal: any, oldVal: any, propName: string): boolean | void;
+    componentWillUpdate?(): Promise<void> | void;
+    componentDidUpdate?(): void;
+    render?(): any;
+} & import("../utils/internal/component").StencilLifecycle & {
+    inheritAriaAttributes: import("../utils/a11y").A11yAttributes;
+    getIgnoredAriaAttributes(): import("../utils/a11y").A11yAttributeName[];
+    componentWillLoad(): Promise<void> | void;
+    ariaAttributeChanged(newValue: string | null, _: string | null, propName: string): void;
+    hostElement?: import("@stencil/core/internal").HTMLStencilElement;
+    connectedCallback?(): void;
+    disconnectedCallback?(): void;
+    componentWillRender?(): Promise<void> | void;
+    componentDidRender?(): void;
+    componentDidLoad?(): void;
+    componentShouldUpdate?(newVal: any, oldVal: any, propName: string): boolean | void;
+    componentWillUpdate?(): Promise<void> | void;
+    componentDidUpdate?(): void;
+    render?(): any;
+};
 /**
  * @form-ready
  */
-export declare class Toggle implements IxFormComponent<string> {
+export declare class Toggle extends Toggle_base implements IxFormComponent<string>, InheritAriaAttributesMixinContract {
     formInternals: ElementInternals;
     hostElement: HTMLIxToggleElement;
     /**
@@ -70,5 +99,7 @@ export declare class Toggle implements IxFormComponent<string> {
     /** @internal */
     isTouched(): Promise<boolean>;
     updateClassMappings(): void;
+    private resolveAriaLabel;
     render(): any;
 }
+export {};

package/dist/types/components/toggle-button/toggle-button.d.ts

@@ -1,8 +1,37 @@
 import { EventEmitter } from '../../stencil-public-runtime';
 import { BaseButtonVariant } from '../button/base-button.types';
 import { ButtonVariant } from '../button/button';
+import { InheritAriaAttributesMixinContract } from '../utils/internal/mixins/accessibility/inherit-aria-attributes.mixin';
 export type ToggleButtonVariant = Exclude<ButtonVariant, `danger-${BaseButtonVariant}`>;
-export declare class ToggleButton {
+declare const ToggleButton_base: abstract new (...args: any[]) => {
+    componentDidLoad(): void;
+    disconnectedCallback(): void;
+    hostElement?: import("@stencil/core/internal").HTMLStencilElement;
+    connectedCallback?(): void;
+    componentWillRender?(): Promise<void> | void;
+    componentDidRender?(): void;
+    componentWillLoad?(): Promise<void> | void;
+    componentShouldUpdate?(newVal: any, oldVal: any, propName: string): boolean | void;
+    componentWillUpdate?(): Promise<void> | void;
+    componentDidUpdate?(): void;
+    render?(): any;
+} & import("../utils/internal/component").StencilLifecycle & {
+    inheritAriaAttributes: import("../utils/a11y").A11yAttributes;
+    getIgnoredAriaAttributes(): import("../utils/a11y").A11yAttributeName[];
+    componentWillLoad(): Promise<void> | void;
+    ariaAttributeChanged(newValue: string | null, _: string | null, propName: string): void;
+    hostElement?: import("@stencil/core/internal").HTMLStencilElement;
+    connectedCallback?(): void;
+    disconnectedCallback?(): void;
+    componentWillRender?(): Promise<void> | void;
+    componentDidRender?(): void;
+    componentDidLoad?(): void;
+    componentShouldUpdate?(newVal: any, oldVal: any, propName: string): boolean | void;
+    componentWillUpdate?(): Promise<void> | void;
+    componentDidUpdate?(): void;
+    render?(): any;
+};
+export declare class ToggleButton extends ToggleButton_base implements InheritAriaAttributesMixinContract {
     hostElement: HTMLIxToggleButtonElement;
     /**
      * Button variant.
@@ -29,11 +58,6 @@ export declare class ToggleButton {
      * Show button as pressed
      */
     pressed: boolean;
-    /**
-     * ARIA label that will be set on the native HTML button element
-     * @since 3.2.0
-     */
-    ariaLabelButton?: string;
     /**
      * Pressed change event
      */
@@ -41,3 +65,4 @@ export declare class ToggleButton {
     private dispatchPressedChange;
     render(): any;
 }
+export {};

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

@@ -1,4 +1,4 @@
-import { ElementReference } from "../../components";
+import { ElementReference } from '../utils/element-reference';
 /**
  * @slot title-icon - Icon displayed next to the tooltip title. The icon will be displayed as 16x16px.
  * @slot title-content - Content of tooltip title
@@ -36,6 +36,7 @@ export declare class Tooltip {
     private disposeTriggerListener?;
     private disposeTooltipListener?;
     private disposeDomChangeListener?;
+    private hasDisconnected;
     private readonly instance;
     private readonly dialogRef;
     private get arrowElement();
@@ -58,6 +59,7 @@ export declare class Tooltip {
     private clearTimeouts;
     componentWillLoad(): void;
     componentDidLoad(): void;
+    connectedCallback(): void;
     disconnectedCallback(): void;
     private handleTitleIconSlotChange;
     render(): any;

package/dist/types/components/tree/tree-model.d.ts

@@ -7,11 +7,15 @@ export interface TreeItem<T> {
     data: T;
     hasChildren: boolean;
     children: TreeItemId[];
+    disabled?: boolean;
 }
 export interface TreeItemVisual<T> extends TreeItem<T> {
     level: number;
+    posinset?: number;
+    setsize?: number;
 }
 export interface TreeItemContext {
     isExpanded: boolean;
     isSelected: boolean;
+    isDisabled?: boolean;
 }

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

@@ -13,6 +13,12 @@ export declare class TreeItem {
      * Context
      */
     context?: TreeItemContext;
+    /**
+     * Disable tree item
+     *
+     * @since 5.0.0
+     */
+    disabled: boolean;
     /**
      * ARIA label for the chevron icon
      */

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

@@ -10,6 +10,12 @@ export declare class Upload {
      * If multiple is true the user can drop or select multiple files
      */
     multiple: boolean;
+    /**
+     * If directoryUpload is true the user can drop or select a folder containing one or more files
+     *
+     * @since 5.1.0
+     */
+    directoryUpload: boolean;
     /**
      * Whether the text should wrap to more than one line
      */
@@ -25,11 +31,11 @@ export declare class Upload {
     /**
      * Will be used by state = UploadFileState.SELECT_FILE
      */
-    selectFileText: string;
+    selectFileText?: string;
     /**
      * Will be used by state = UploadFileState.LOADING
      */
-    loadingText: string;
+    loadingText?: string;
     /**
      * Will be used by state = UploadFileState.UPLOAD_FAILED
      */
@@ -39,9 +45,9 @@ export declare class Upload {
      */
     uploadSuccessText: string;
     /**
-     * Label for upload file button
+     * Label for upload file or folder button
      */
-    i18nUploadFile: string;
+    i18nUploadFile?: string;
     /**
      * Text for disabled state
      */

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

@@ -6,4 +6,9 @@ type PartialRecord<K extends A11yAttributeName, T> = {
     [P in K]?: T;
 };
 export type A11yAttributes = PartialRecord<A11yAttributeName, string>;
+/**
+ * Usually called by ref={(ref) => forceTabIndex(ref, -1)} to workaround an issue
+ * where the tabIndex is not applied to the element after re-render.
+ */
+export declare const forceTabIndex: (element: HTMLElement | undefined, tabIndex: number) => void;
 export {};

package/dist/types/components/utils/dependency-function.d.ts

@@ -0,0 +1,16 @@
+export type CustomElementDependency<Tag extends string = string> = {
+    tag: Tag;
+    define: () => Promise<void> | void;
+};
+type CustomElementDependencies = readonly CustomElementDependency[];
+type DependencyDefinitions<TDependencies extends CustomElementDependencies> = {
+    readonly [Index in keyof TDependencies]: TDependencies[Index] extends CustomElementDependency<infer Tag> ? CustomElementDependency<Tag> : never;
+};
+type DependencyFunctionCallback = (...args: never[]) => Promise<unknown>;
+export type DependencyFunction<TCallback extends DependencyFunctionCallback, TDependencies extends CustomElementDependencies> = TCallback & {
+    readonly dependencies: DependencyDefinitions<TDependencies>;
+    ensureDependencies: () => Promise<void>;
+    withDependencies: (dependencies: DependencyDefinitions<TDependencies>) => DependencyFunction<TCallback, TDependencies>;
+};
+export declare function createDependencyFunction<TCallback extends DependencyFunctionCallback, const TDependencies extends CustomElementDependencies>(callback: TCallback, dependencies: TDependencies): DependencyFunction<TCallback, TDependencies>;
+export {};

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

@@ -0,0 +1,8 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+export declare function emitEvent<T>(action: () => {
+    new: T;
+    old: T;
+}, emitter: EventEmitter<T>, rollback: (oldValue: T) => void): {
+    new: T;
+    old: T;
+};

package/dist/types/components/utils/focus/detect-keyboard-mode.d.ts

@@ -0,0 +1,5 @@
+export type KeyboardModeDetector = {
+    destroy: () => void;
+    hasKeyboardMode: () => boolean;
+};
+export declare function detectKeyboardMode(element?: HTMLElement): KeyboardModeDetector;

package/dist/types/components/utils/focus/focus-proxy.d.ts

@@ -0,0 +1,14 @@
+type FocusProxyProps = {
+    hostId: string;
+    otherProps: Record<string, string | boolean | undefined>;
+};
+/**
+ * Add a focus proxy element to the DOM to allow for better keyboard navigation and accessibility.
+ *
+ * Important: Also import the focus proxy mixin in the host component's scss file to ensure the proxy is visually hidden but still accessible to screen readers and keyboard navigation.
+ */
+export declare const FocusProxy: (props: FocusProxyProps) => any;
+export declare const PROXY_LIST_ID_SUFFIX: "proxy-listbox";
+export declare const PROXY_LISTITEM_ID_SUFFIX: "proxy-listbox-item";
+export declare const updateFocusProxyList: <T extends HTMLElement>(proxyListElement: HTMLElement, items: T[], modifyProxyElement?: (item: T, proxyElement: HTMLLIElement) => void) => void;
+export {};

package/dist/types/components/utils/focus/focus-trap.d.ts

@@ -0,0 +1,27 @@
+import { MakeRef } from '../make-ref';
+import { IxFocusOptions } from './focus-utilities';
+export interface FocusTrapResult {
+    destroy: () => void;
+}
+export declare const TRAP_FOCUS_EXCLUDE_ATTRIBUTE = "data-ix-focus-trap-exclude";
+export declare const TRAP_FOCUS_INCLUDE_ATTRIBUTE = "data-ix-focus-trap-include";
+export type FocusTrapOptions = {
+    targetElement?: HTMLElement | MakeRef<any>;
+    trapFocusInShadowDom?: boolean | 'both';
+    excludeElements?: boolean;
+    /** Capture Tab on `document` (popover in ancestor shadow roots / top layer). */
+    listenOnDocument?: boolean;
+    /** Skip handling when another overlay owns focus (nested / sibling popover). */
+    shouldDeferTabTrap?: (trapHost: HTMLElement) => boolean;
+};
+export declare const getDeepActiveElement: () => Element | null;
+export declare function findActiveFocusableIndex(active: Element | null, focusableElements: HTMLElement[]): number;
+export declare function isFocusWithinTrapHost(element: Element, trapHost: HTMLElement): boolean;
+export declare function getPopoverHostForElement(element: Element): HTMLElement | undefined;
+export declare function isWithinInertSubtree(element: Element): boolean;
+/** Drops focusables inside closed or nested child popovers (not tabbable in the active layer). */
+export declare function filterFocusTrapFocusables(focusableElements: HTMLElement[], trapHost: HTMLElement): HTMLElement[];
+export declare function getFocusTrapFocusables(ref: HTMLElement, options?: FocusTrapOptions): HTMLElement[];
+/** Focus the first content control; falls back to the header close when content has none. */
+export declare function focusFirstFocusTrapElement(ref: HTMLElement, options?: FocusTrapOptions, focusOptions?: IxFocusOptions): void;
+export declare const addFocusTrap: (element: HTMLElement, options?: FocusTrapOptions) => Promise<FocusTrapResult>;

package/dist/types/components/utils/focus/focus-utilities.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Originally based on Ionic's focus-visible utility.
+ * Fork of https://github.com/ionic-team/ionic-framework/blob/c37e2a5d9e765cf48d768061c9d453a13b187e13/core/src/utils/focus-visible.ts
+ */
+export declare const IX_FOCUS_VISIBLE_ACTIVE = "ix-focused";
+export declare const IX_FOCUS_VISIBLE = "ix-focusable";
+export declare const FOCUS_KEYS: Set<string>;
+export declare function queryElements(dropdownElement: HTMLElement | ShadowRoot | null | undefined, query: string, includeShadowDom?: boolean): HTMLElement[];
+export type DomFocusOptions = Parameters<HTMLElement['focus']>[0];
+/** `focusVisible` is supported in Firefox 104+; omitted from some TypeScript DOM typings. */
+export type IxFocusOptions = DomFocusOptions & {
+    focusVisible?: boolean;
+};
+export declare function tryFocusElement(element: Element | HTMLElement, options?: IxFocusOptions): void;
+export type FocusVisibleConfig = {
+    trapFocus?: boolean;
+    trapFocusInShadowDom?: boolean;
+};
+export type FocusOptions = {
+    focusCheckedItem?: boolean;
+};
+export declare const focusFirstDescendant: <R extends HTMLElement, T extends HTMLElement>(ref: R, fallbackElement?: T, options?: FocusOptions) => void;
+export declare const focusLastDescendant: <R extends HTMLElement, T extends HTMLElement>(ref: R, fallbackElement?: T) => void;
+/**
+ * Checks if an element is part of a custom element's shadow root
+ * and returns the host element if it is, otherwise returns the element itself.
+ */
+export declare const getHostElement: (element: HTMLElement) => HTMLElement;
+export declare const focusElementInContext: <T extends HTMLElement>(hostToFocus: HTMLElement | null | undefined, fallbackElement: T, options?: IxFocusOptions) => void;
+export declare const focusElement: (element: HTMLElement | null | undefined, options?: DomFocusOptions) => void;
+export declare const focusableQueryString: string;
+export declare const buildFocusableQueryString: (additionalSelector?: string) => string;

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

@@ -1,5 +1,5 @@
 import { EventEmitter } from '../../../stencil-public-runtime';
-import { IxComponent } from '../internal';
+import { IxComponentInterface } from '../internal';
 export * from './validation';
 export interface FieldWrapperInterface {
     /**
@@ -39,7 +39,7 @@ export interface IxFormValidationState {
     isInfo: boolean;
     isWarning: boolean;
 }
-export interface IxFormComponent<T = string> extends IxComponent {
+export interface IxFormComponent<T = string> extends IxComponentInterface {
     formInternals: ElementInternals;
     required?: boolean;
     name?: string;
@@ -60,3 +60,7 @@ export interface IxInputFieldComponent<T = string> extends IxFormComponent<T>, I
     focusInput(): Promise<void>;
 }
 export declare function isIxInputFieldComponent<T>(obj: HTMLElement | IxFormComponent<T>): obj is HTMLIxInputFieldComponentElement<T>;
+export interface IxInputFieldWithPickerComponent<T> extends IxInputFieldComponent<T> {
+    openPicker(): Promise<void>;
+}
+export declare function isIxInputFieldWithPickerComponent<T>(obj: HTMLElement | IxFormComponent<T>): obj is IxInputFieldWithPickerComponent<T>;

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

@@ -1,5 +1,5 @@
 import { HTMLIxFormComponentElement, IxFormComponent } from '.';
-import { IxComponent } from '../internal';
+import { IxComponentInterface } from '../internal';
 export type ClassMutationObserver = {
     destroy: () => void;
 };
@@ -13,5 +13,5 @@ export type ValidationResults = Record<ValidationResultProperty, boolean>;
 export declare function checkFieldClasses(hostElement: HTMLIxFormComponentElement<unknown>, includeChildren?: boolean): ValidationResults;
 export declare function HookValidationLifecycle(options?: {
     includeChildren?: boolean;
-}): (proto: IxComponent, methodName: string) => void;
+}): (proto: IxComponentInterface, methodName: string) => void;
 export declare function getValidationText(isInputInvalid: boolean, customInvalidText: string | undefined, i18nFallbackText: string): string | undefined;

package/dist/types/components/utils/internal/component.d.ts

@@ -1,4 +1,109 @@
-import { HTMLStencilElement, ComponentInterface } from '../../../stencil-public-runtime';
-export interface IxComponent extends ComponentInterface {
+import type { ComponentInterface } from '../../../stencil-public-runtime';
+import { HTMLStencilElement } from '../../../stencil-public-runtime';
+export interface StencilLifecycle {
+    hostElement?: HTMLStencilElement;
+    connectedCallback?(): void;
+    disconnectedCallback?(): void;
+    componentWillRender?(): Promise<void> | void;
+    componentDidRender?(): void;
+    /**
+     * The component is about to load and it has not
+     * rendered yet.
+     *
+     * This is the best place to make any data updates
+     * before the first render.
+     *
+     * componentWillLoad will only be called once.
+     */
+    componentWillLoad?(): Promise<void> | void;
+    /**
+     * The component has loaded and has already rendered.
+     *
+     * Updating data in this method will cause the
+     * component to re-render.
+     *
+     * componentDidLoad will only be called once.
+     */
+    componentDidLoad?(): void;
+    /**
+     * A `@Prop` or `@State` property changed and a rerender is about to be requested.
+     *
+     * Called multiple times throughout the life of
+     * the component as its properties change.
+     *
+     * componentShouldUpdate is not called on the first render.
+     */
+    componentShouldUpdate?(newVal: any, oldVal: any, propName: string): boolean | void;
+    /**
+     * The component is about to update and re-render.
+     *
+     * Called multiple times throughout the life of
+     * the component as it updates.
+     *
+     * componentWillUpdate is not called on the first render.
+     */
+    componentWillUpdate?(): Promise<void> | void;
+    /**
+     * The component has just re-rendered.
+     *
+     * Called multiple times throughout the life of
+     * the component as it updates.
+     *
+     * componentWillUpdate is not called on the
+     * first render.
+     */
+    componentDidUpdate?(): void;
+    render?(): any;
+}
+export interface IxComponentInterface extends ComponentInterface {
     hostElement: HTMLStencilElement;
 }
+export declare const DefaultMixins: readonly [<B extends import("@stencil/core").MixedInCtor<StencilLifecycle>>(Base: B) => {
+    new (...args: any[]): {
+        componentDidLoad(): void;
+        disconnectedCallback(): void;
+        hostElement?: HTMLStencilElement;
+        connectedCallback?(): void;
+        componentWillRender?(): Promise<void> | void;
+        componentDidRender?(): void;
+        /**
+         * The component is about to load and it has not
+         * rendered yet.
+         *
+         * This is the best place to make any data updates
+         * before the first render.
+         *
+         * componentWillLoad will only be called once.
+         */
+        componentWillLoad?(): Promise<void> | void;
+        /**
+         * A `@Prop` or `@State` property changed and a rerender is about to be requested.
+         *
+         * Called multiple times throughout the life of
+         * the component as its properties change.
+         *
+         * componentShouldUpdate is not called on the first render.
+         */
+        componentShouldUpdate?(newVal: any, oldVal: any, propName: string): boolean | void;
+        /**
+         * The component is about to update and re-render.
+         *
+         * Called multiple times throughout the life of
+         * the component as it updates.
+         *
+         * componentWillUpdate is not called on the first render.
+         */
+        componentWillUpdate?(): Promise<void> | void;
+        /**
+         * The component has just re-rendered.
+         *
+         * Called multiple times throughout the life of
+         * the component as it updates.
+         *
+         * componentWillUpdate is not called on the
+         * first render.
+         */
+        componentDidUpdate?(): void;
+        render?(): any;
+    };
+} & B];

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

@@ -1 +1,2 @@
-export { IxComponent } from './component';
+export { IxComponentInterface } from './component';
+export { SetupMixin } from './mixins/setup.mixin';

package/dist/types/components/utils/internal/mixins/accessibility/aria-activedescendant.mixin.d.ts

@@ -0,0 +1,30 @@
+import { MixedInCtor } from '../../../../../stencil-public-runtime';
+import { StencilLifecycle } from '../../component';
+import { IxFocusVisibleChangeEvent } from '../setup.mixin';
+export interface AriaActiveDescendantMixinContract {
+    isAriaActiveDescendantActive(): boolean;
+    getControllingAriaElement(): Promise<HTMLElement> | HTMLElement | null;
+    getAriaActiveDescendantProxyItemId?(): string | boolean;
+    suppressAriaActiveDescendant?: boolean;
+}
+export declare const AriaActiveDescendantMixin: <B extends MixedInCtor<StencilLifecycle>>(Base: B) => {
+    new (...args: any[]): {
+        suppressAriaActiveDescendant: boolean;
+        isAriaActiveDescendantActive(): boolean;
+        getControllingAriaElement(): Promise<HTMLElement> | HTMLElement | null;
+        getAriaActiveDescendantProxyItemId(): string | boolean;
+        clearActiveDescendant(): Promise<void>;
+        $internal_onActiveDescendantChange(event: IxFocusVisibleChangeEvent): Promise<void>;
+        hostElement?: import("@stencil/core/internal").HTMLStencilElement;
+        connectedCallback?(): void;
+        disconnectedCallback?(): void;
+        componentWillRender?(): Promise<void> | void;
+        componentDidRender?(): void;
+        componentWillLoad?(): Promise<void> | void;
+        componentDidLoad?(): void;
+        componentShouldUpdate?(newVal: any, oldVal: any, propName: string): boolean | void;
+        componentWillUpdate?(): Promise<void> | void;
+        componentDidUpdate?(): void;
+        render?(): any;
+    };
+} & B;

package/dist/types/components/utils/internal/mixins/accessibility/inherit-aria-attributes.mixin.d.ts

@@ -0,0 +1,25 @@
+import { MixedInCtor } from '../../../../../stencil-public-runtime';
+import { StencilLifecycle } from '../../component';
+import { A11yAttributeName, A11yAttributes } from './../../../a11y';
+export interface InheritAriaAttributesMixinContract {
+    inheritAriaAttributes: A11yAttributes;
+    getIgnoredAriaAttributes?(): A11yAttributeName[];
+}
+export declare const InheritAriaAttributesMixin: <B extends MixedInCtor<StencilLifecycle>>(Base: B) => {
+    new (...args: any[]): {
+        inheritAriaAttributes: A11yAttributes;
+        getIgnoredAriaAttributes(): A11yAttributeName[];
+        componentWillLoad(): Promise<void> | void;
+        ariaAttributeChanged(newValue: string | null, _: string | null, propName: string): void;
+        hostElement?: import("@stencil/core/internal").HTMLStencilElement;
+        connectedCallback?(): void;
+        disconnectedCallback?(): void;
+        componentWillRender?(): Promise<void> | void;
+        componentDidRender?(): void;
+        componentDidLoad?(): void;
+        componentShouldUpdate?(newVal: any, oldVal: any, propName: string): boolean | void;
+        componentWillUpdate?(): Promise<void> | void;
+        componentDidUpdate?(): void;
+        render?(): any;
+    };
+} & B;