@siemens/ix 4.4.0 → 5.1.0

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

@@ -3,7 +3,20 @@ import { DateTime } from 'luxon';
 import type { DateTimeCardCorners } from '../date-time-card/date-time-card.types';
 import { IxDatePickerComponent } from './date-picker-component';
 import type { DateChangeEvent } from './date-picker.events';
-export declare class DatePicker implements IxDatePickerComponent {
+declare const DatePicker_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 DatePicker extends DatePicker_base implements IxDatePickerComponent {
     hostElement: HTMLIxDatePickerElement;
     /**
      * Date format string.
@@ -54,6 +67,20 @@ export declare class DatePicker implements IxDatePickerComponent {
      * Will be set as aria-label on the nested HTML button element.
      */
     ariaLabelNextMonthButton?: string;
+    /**
+     * ARIA label for the next month icon button
+     * Will be set as aria-label on the nested HTML button element
+     *
+     * @since 5.0.0
+     */
+    ariaLabelMonthSelection?: string;
+    /**
+     * ARIA label for the next month icon button
+     * Will be set as aria-label on the nested HTML button element
+     *
+     * @since 5.0.0
+     */
+    ariaLabelYearSelection?: string;
     /**
      * The index of which day to start the week on, based on the Locale#weekdays array.
      * E.g. if the locale is en-us, weekStartIndex = 1 results in starting the week on Monday.
@@ -118,9 +145,8 @@ export declare class DatePicker implements IxDatePickerComponent {
     endYear: number;
     selectedMonth: number;
     tempMonth: number;
-    private readonly dropdownButtonRef;
-    private readonly yearContainerRef;
-    private readonly firstMonthRef;
+    private readonly yearDropdownButtonRef;
+    private readonly yearMonthSelectionDropdownRef;
     dayNames: string[];
     monthNames: string[];
     focusedDay: number;
@@ -128,16 +154,36 @@ export declare class DatePicker implements IxDatePickerComponent {
     private monthChangedFromFocus;
     private readonly DAYS_IN_WEEK;
     private calendar;
-    handleKeyUp(event: KeyboardEvent): void;
+    onKeyDown(event: KeyboardEvent): void;
+    private setFocusedDay;
     private getDaysInCurrentMonth;
+    private getFirstDayOfWeek;
+    private getLastDayOfWeek;
     private getDateTimeNow;
     private parseDateString;
-    private updateSelectedYearMonth;
+    /**
+     * @internal
+     */
+    updateSelectedYearMonth(date: DateTime): Promise<void>;
     onDayBlur(): void;
     onDayFocus(): void;
     componentWillLoad(): void;
+    private keyboardNavigationYearSelection?;
+    private keyboardNavigationMonthSelection?;
+    disconnectedCallback(): void;
+    componentDidLoad(): void;
     componentWillRender(): void;
     componentDidRender(): void;
+    /** @internal */
+    navigateCalendar(direction: -1 | 1, byYear: boolean): Promise<void>;
+    /** @internal */
+    focusFirstDayOfCurrentWeek(): Promise<void>;
+    /** @internal */
+    focusLastDayOfCurrentWeek(): Promise<void>;
+    /** @internal */
+    isCalendarDayFocused(): Promise<boolean>;
+    /** @internal */
+    focusActiveDay(): Promise<void>;
     private setTranslations;
     /**
      * Rotate the WeekdayNames array.
@@ -146,17 +192,23 @@ export declare class DatePicker implements IxDatePickerComponent {
     private rotateWeekDayNames;
     private onDone;
     private calculateCalendar;
-    private selectTempYear;
-    private focusMonth;
-    private infiniteScrollYears;
     private selectMonth;
-    private changeToAdjacentMonth;
+    private changeCalendarView;
+    private navigateByMonthOrYear;
     private selectDay;
     private onDateChange;
+    private getUtilitiesBasedOnDay;
     private getDayClasses;
     private isWithinMinMaxYear;
     private isWithinMinMaxMonth;
     private isWithinMinMaxDate;
+    private renderMonths;
     private renderYears;
+    changeFocusedDay(): void;
+    private intersect;
+    private skipFirstScrollOffset;
+    private intersectStart;
+    private intersectEnd;
     render(): any;
 }
+export {};

package/dist/types/components/date-time-card/date-time-card.d.ts

@@ -19,6 +19,10 @@ export declare class DateTimeCard {
      * Set corners style
      */
     corners: DateTimeCardCorners;
+    /**
+     * Remove content padding
+     */
+    noPadding: boolean;
     private cardClasses;
     render(): any;
 }

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

@@ -0,0 +1,210 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import { PickerValidityStateTracker } from '../input/input.util';
+import { IxInputFieldComponent, ValidationResults } from '../utils/input';
+import { MakeRef } from '../utils/make-ref';
+import { DateTimeInputValidityState } from './datetime-input.types';
+import { InputPickerMixinContract } from '../utils/internal/mixins/input/input-picker.mixin';
+declare const DatetimeInput_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;
+/**
+ * @since 5.0.0
+ * @form-ready
+ *
+ * @slot start - Element will be displayed at the start of the input
+ * @slot end - Element will be displayed at the end of the input
+ */
+export declare class DatetimeInput extends DatetimeInput_base implements IxInputFieldComponent<string | undefined>, InputPickerMixinContract {
+    hostElement: HTMLIxDatetimeInputElement;
+    formInternals: ElementInternals;
+    /** Name of the form control for form submission */
+    name?: string;
+    /** Placeholder text when input is empty */
+    placeholder?: string;
+    /** Value in display format (e.g., "2026/01/21 13:07:04" for default format) */
+    value?: string;
+    /**
+     * Luxon date and time format for display (e.g., 'yyyy/LL/dd HH:mm:ss' → "2026/01/20 13:07:04").
+     *
+     * See {@link https://moment.github.io/luxon/#/formatting?id=table-of-tokens} for all available tokens.
+     */
+    format: string;
+    /** Locale for date/time formatting (e.g., 'en-US', 'de-DE') */
+    locale?: string;
+    /** Whether the field is required */
+    required: boolean;
+    /** Whether the input is disabled */
+    disabled: boolean;
+    /** Whether the input is read-only (calendar icon hidden) */
+    readonly: boolean;
+    /** Minimum allowed date (matching format or date-only, e.g., "2026/01/20") */
+    minDate?: string;
+    /** Maximum allowed date (matching format or date-only, e.g., "2026/12/31") */
+    maxDate?: string;
+    /**
+     * Earliest selectable time (tokens matching the time portion of `format`). Invalid non-empty values are ignored.
+     *
+     * @since 5.0.0
+     */
+    minTime?: string;
+    /**
+     * Latest selectable time (tokens matching the time portion of `format`). Invalid non-empty values are ignored.
+     *
+     * @since 5.0.0
+     */
+    maxTime?: string;
+    /** Label text displayed above the input */
+    label?: string;
+    /** Helper text displayed below the input */
+    helperText?: string;
+    /** Validation message for invalid state */
+    invalidText?: string;
+    /** Informational message */
+    infoText?: string;
+    /** Warning message */
+    warningText?: string;
+    /** Success/valid message */
+    validText?: string;
+    /** Show helper text as tooltip instead of below input */
+    showTextAsTooltip: boolean;
+    /** Error message when datetime cannot be parsed */
+    i18nErrorDateTimeUnparsable: string;
+    /** Text for confirm button in picker (prop name matches datetime-picker) */
+    i18nDone: string;
+    /** Header text for time picker section */
+    i18nTime: string;
+    /** ARIA label for previous month navigation button */
+    ariaLabelPreviousMonthButton?: string;
+    /** ARIA label for next month navigation button */
+    ariaLabelNextMonthButton?: string;
+    /**
+     * ARIA label for the calendar icon button
+     * Will be set as aria-label on the nested HTML button element
+     */
+    ariaLabelCalendarButton?: string;
+    /** Show week numbers in date picker */
+    showWeekNumbers: boolean;
+    /** First day of week (0=Sunday, 1=Monday, etc.) */
+    weekStartIndex: number;
+    /** Prevent form submission when Enter is pressed */
+    suppressSubmitOnEnter: boolean;
+    /** Text alignment within the input field */
+    textAlignment: 'start' | 'end';
+    /**
+     * Enable Popover API rendering for dropdown.
+     */
+    enableTopLayer: boolean;
+    /** Emitted when the datetime value changes. Payload is display format or undefined */
+    valueChange: EventEmitter<string | undefined>;
+    /** Emitted when validation state changes */
+    validityStateChange: EventEmitter<DateTimeInputValidityState>;
+    /** Emitted when the input receives focus */
+    ixFocus: EventEmitter<void>;
+    /** Emitted when the input loses focus */
+    ixBlur: EventEmitter<void>;
+    /**
+     * Emitted when the date/time value changes via user interaction.
+     *
+     * Fires in two scenarios:
+     * - When the input loses focus (blur) and the value has changed
+     * - When a new date/time is selected in the picker and confirmed
+     *
+     * Does NOT fire when:
+     * - The picker is opened/closed without confirming a change
+     * - The input is blurred without modifying the value
+     * - The value is changed programmatically via the value property
+     */
+    ixChange: EventEmitter<string | undefined>;
+    isInputInvalid: boolean;
+    isInvalid: boolean;
+    isValid: boolean;
+    isInfo: boolean;
+    isWarning: boolean;
+    private readonly slotStartRef;
+    private readonly slotEndRef;
+    private readonly inputElementRef;
+    private readonly dropdownElementRef;
+    private readonly datetimePickerRef;
+    show: boolean;
+    from?: string | null;
+    time?: string | null;
+    private classObserver?;
+    initialValue?: string;
+    invalidReason?: string;
+    touched: boolean;
+    validityTracker: PickerValidityStateTracker;
+    private disposableChangesAndVisibilityObservers?;
+    watchValuePropHandler(newValue: string): void;
+    watchMinTimePropHandler(): void;
+    watchMaxTimePropHandler(): void;
+    private get combinedFormat();
+    private get dateOnlyFormat();
+    private get timeOnlyFormat();
+    private syncPickerState;
+    onInput(value: string | undefined): Promise<void>;
+    private parseConstraintDate;
+    private validateConstraints;
+    private getTimeConstraintBoundsForDate;
+    private computeConstraintValidation;
+    private revalidateCurrentValue;
+    private handleInputKeyDown;
+    private initPickerValues;
+    onCalendarClick(event: Event): void;
+    private openDropdown;
+    private closeDropdown;
+    updateFormInternalValue(value: string | undefined): void;
+    /**
+     * Returns whether the input has a value.
+     * @internal
+     */
+    hasValidValue(): Promise<boolean>;
+    /**
+     * Returns the associated HTML form element.
+     * @internal
+     */
+    getAssociatedFormElement(): Promise<HTMLFormElement | null>;
+    /**
+     * Get the native input element
+     * @internal
+     */
+    getNativeInputElement(): Promise<HTMLInputElement>;
+    /**
+     * Focus the native input element
+     * @internal
+     */
+    focusInput(): Promise<void>;
+    /**
+     * Returns whether the input field has been touched.
+     * @internal
+     */
+    isTouched(): Promise<boolean>;
+    /**
+     * Returns the validity state of the input.
+     * @internal
+     */
+    getValidityState(): Promise<ValidityState>;
+    onInputValidationChange(): Promise<void>;
+    hookValidationLifecycle({ isInfo, isInvalid, isInvalidByRequired, isValid, isWarning, }: ValidationResults): void;
+    private emitValidityStateChangeIfChanged;
+    private emitChange;
+    connectedCallback(): void;
+    componentWillLoad(): void;
+    private updatePaddings;
+    disconnectedCallback(): void;
+    private checkClassList;
+    private readonly handleDateSelect;
+    getPickerElement(): MakeRef<HTMLIxDropdownElement> | null;
+    private renderInput;
+    render(): any;
+}
+export {};

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

@@ -0,0 +1,3 @@
+export interface DateTimeInputValidityState extends ValidityState {
+    invalidReason?: string;
+}

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

@@ -2,6 +2,7 @@ import { EventEmitter } from '../../stencil-public-runtime';
 import { IxDatePickerComponent } from '../date-picker/date-picker-component';
 import type { DateTimeDateChangeEvent, DateTimeSelectEvent } from './datetime-picker.types';
 export declare class DatetimePicker implements Omit<IxDatePickerComponent, 'corners' | 'format'> {
+    hostElement: HTMLIxDatetimePickerElement;
     /**
      * If true, disables date range selection (from/to).
      */
@@ -26,6 +27,18 @@ export declare class DatetimePicker implements Omit<IxDatePickerComponent, 'corn
      * See {@link https://moment.github.io/luxon/#/formatting?id=table-of-tokens} for all available tokens.
      */
     timeFormat: string;
+    /**
+     * Earliest selectable time (`timeFormat` tokens). Invalid non-empty values are ignored.
+     *
+     * @since 5.0.0
+     */
+    minTime?: string;
+    /**
+     * Latest selectable time (`timeFormat` tokens). Invalid non-empty values are ignored.
+     *
+     * @since 5.0.0
+     */
+    maxTime?: string;
     /**
      * The selected starting date. If the picker is not in range mode, this is the selected date.
      * Format has to match the `dateFormat` property.
@@ -85,6 +98,8 @@ export declare class DatetimePicker implements Omit<IxDatePickerComponent, 'corn
      * @since 3.0.0
      */
     showWeekNumbers: boolean;
+    /** @internal */
+    embedded: boolean;
     /**
      * Time change event. Emitted when the time changes in the embedded time picker.
      */
@@ -99,8 +114,25 @@ export declare class DatetimePicker implements Omit<IxDatePickerComponent, 'corn
     dateSelect: EventEmitter<DateTimeSelectEvent>;
     private datePickerElement?;
     private timePickerElement?;
+    private selectedFromDate?;
+    private hasTimeConstraintsConfigured;
+    private warnIfRangeModeIgnoresTimeConstraints;
+    watchFromPropHandler(value: string | undefined): void;
+    watchSingleSelectionPropHandler(): void;
+    watchMinTimePropHandler(): void;
+    watchMaxTimePropHandler(): void;
+    componentWillLoad(): void;
+    private get dateOnlyFormat();
+    private parseDateValue;
+    private parseDateConstraint;
+    private getSelectedFromDateTime;
+    private getEffectiveTimeConstraints;
     private onDone;
     private onDateChange;
     private onTimeChange;
+    /** @internal */
+    getDatepickerElement(): Promise<HTMLIxDatePickerElement | undefined>;
+    /** @internal */
+    getTimepickerElement(): Promise<HTMLIxTimePickerElement | undefined>;
     render(): any;
 }

package/dist/types/components/dropdown/dropdown-controller.d.ts

@@ -1,6 +1,6 @@
-import { IxComponent } from '../utils/internal';
+import { IxComponentInterface } from '../utils/internal';
 export type CloseBehavior = 'inside' | 'outside' | 'both' | boolean;
-export interface DropdownInterface extends IxComponent {
+export interface DropdownInterface extends IxComponentInterface {
     closeBehavior: CloseBehavior;
     discoverAllSubmenus: boolean;
     getAssignedSubmenuIds(): string[];
@@ -17,8 +17,7 @@ export interface DropdownItemWrapper {
     getDropdownItemElement(): Promise<HTMLIxDropdownItemElement>;
 }
 declare class DropdownController {
-    private readonly dropdowns;
-    private submenuIds;
+    private readonly stack;
     private isWindowListenerActive;
     connected(dropdown: DropdownInterface): void;
     disconnected(dropdown: DropdownInterface): void;
@@ -31,8 +30,8 @@ declare class DropdownController {
     dismissAll(ignoreBehaviorForIds?: string[], ignoreRelatedDropdowns?: boolean): void;
     dismissOthers(uid: string): void;
     pathIncludesTrigger(eventTargets: EventTarget[]): HTMLElement | undefined;
+    getParentDropdownId(dropdownId: string): string | undefined;
     private pathIncludesDropdown;
-    private buildComposedPath;
     private addOverlayListeners;
 }
 export declare const dropdownController: DropdownController;

package/dist/types/components/dropdown/dropdown-focus.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Originally based on Ionic's focus-visible utility.
+ * Fork of https://github.com/ionic-team/ionic-framework/blob/c37e2a5d9e765cf48d768061c9d453a13b187e13/core/src/utils/focus-trap.ts
+ */
+export declare const QUERY_ARROW_ELEMENTS: string;
+export declare const QUERY_CURRENT_VISIBLE_FOCUS: string;
+export declare const getIndexOfDropdownItem: (items: HTMLElement[], item: HTMLElement | null, selector?: string) => number;
+export declare const getNextFocusableDropdownItem: (items: HTMLElement[], currentItem: HTMLElement | null, selector?: string) => HTMLElement;
+export declare const getPreviousFocusableItem: (items: HTMLElement[], currentItem: HTMLElement | null, selector?: string) => HTMLElement;
+export declare const isTriggerElement: (element: HTMLElement) => boolean;
+export declare const configureKeyboardInteraction: (getItemsHost: () => HTMLElement, options?: {
+    getActiveElement?: () => HTMLElement | null;
+    setItemActive?: (item: HTMLElement) => void;
+    getEventListenerTarget?: () => HTMLElement;
+    querySelector?: string;
+    activeQuerySelector?: string;
+    itemTriggerKeys?: string[];
+    beforeKeydown?: (ev: KeyboardEvent) => void;
+    onItemActivation?: (event: KeyboardEvent, activeElement: HTMLElement) => void;
+}) => () => void;

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

@@ -1,9 +1,22 @@
 import { EventEmitter } from '../../stencil-public-runtime';
-import { ComponentInterface } from '../../stencil-public-runtime';
 import { ElementReference } from '../utils/element-reference';
+import { FocusTrapOptions } from '../utils/focus/focus-trap';
 import { CloseBehavior, DropdownInterface } from './dropdown-controller';
 import { AlignedPlacement } from './placement';
-export declare class Dropdown implements ComponentInterface, DropdownInterface {
+declare const Dropdown_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 Dropdown extends Dropdown_base implements DropdownInterface {
     hostElement: HTMLIxDropdownElement;
     /**
      * Suppress the automatic placement of the dropdown.
@@ -39,6 +52,49 @@ export declare class Dropdown implements ComponentInterface, DropdownInterface {
      * An optional header shown at the top of the dropdown
      */
     header?: string;
+    /**
+     * By default the dropdown gets closed if the trigger is not visible anymore (e.g. due to scrolling). Setting this property prevents that behavior.
+     *
+     * @since 5.0.0
+     */
+    suppressTriggerVisibilityCheck: boolean;
+    /**
+     * Suppress automatic focus when the dropdown is shown
+     *
+     * @since 4.3.0
+     */
+    disableFocusHandling: boolean;
+    /**
+     * Close dropdown when tabbing away, and do not trap focus inside dropdown
+     *
+     * @since 4.3.0
+     */
+    disableFocusTrap: boolean;
+    /**
+     * Enable Popover API rendering for top-layer positioning.
+     *
+     * @default false in v5.x, will default to true in v6.0.0
+     * @since 4.3.0
+     */
+    enableTopLayer: boolean;
+    /**
+     * If true, the dropdown will try to focus checked items first when opened via keyboard, otherwise it will always focus the first focusable item.
+     *
+     * @since 5.0.0
+     */
+    focusCheckedItem: boolean;
+    /**
+     * Keys that will open the dropdown when the trigger is focused
+     *
+     * @internal
+     */
+    keyboardActivationKeys: string[];
+    /**
+     * Keys that will open the dropdown when the trigger is focused
+     *
+     * @internal
+     */
+    keyboardItemTriggerKeys: string[];
     /**
      * Move dropdown along main axis of alignment
      *
@@ -66,24 +122,49 @@ export declare class Dropdown implements ComponentInterface, DropdownInterface {
     ignoreRelatedSubmenu: boolean;
     /** @internal */
     suppressOverflowBehavior: boolean;
+    /** @internal */
+    focusHost?: HTMLElement;
+    /** @internal */
+    focusTrapOptions?: FocusTrapOptions;
+    /** @internal */
+    hostRole?: string;
     /**
-     * Enable Popover API rendering for top-layer positioning.
-     *
-     * @default false in v4.x, will default to true in v5.0.0
+     * @internal
+     * Called instead of the default focus-on-open logic when the dropdown is
+     * opened via keyboard. When not set, default behavior is used.
      */
-    enableTopLayer: boolean;
+    callbackFocusElement?: (event: KeyboardEvent) => Promise<boolean | undefined>;
+    /**
+     * Fire event before visibility of dropdown has changed, preventing event will cancel showing dropdown
+     */
+    showChange: EventEmitter<boolean>;
     /**
      * Fire event after visibility of dropdown has changed
      */
     showChanged: EventEmitter<boolean>;
+    fallbackPlacement?: AlignedPlacement;
+    /**
+     * Will be fired only after dropdown changed visibility to "true"
+     *
+     * @internal
+     */
+    experimentalRequestFocus: EventEmitter<{
+        keyEvent: KeyboardEvent;
+    }>;
+    /**
+     * @internal
+     */
+    experimentalFocusNextElement: EventEmitter<void>;
     private autoUpdateCleanup?;
     private readonly dialogRef;
+    private intersectObserverTrigger?;
     private triggerElement?;
     private anchorElement?;
-    private arrowFocusController?;
-    private localUId;
+    private forwardQueryElement;
+    private dropdownElementId;
     private assignedSubmenu;
-    private itemObserver?;
+    private keyboardNavigationCleanup?;
+    private focusUtilities?;
     connectedCallback(): void;
     cacheSubmenuId(event: CustomEvent<string>): void;
     disconnectedCallback(): void;
@@ -98,23 +179,30 @@ export declare class Dropdown implements ComponentInterface, DropdownInterface {
     get slotElement(): HTMLSlotElement | null;
     private disposeClickListener?;
     private disposeKeyListener?;
+    private toggleController;
+    private readonly onTriggerClick;
+    private handleTriggerClick;
+    private readonly onTriggerKeydown;
+    private handleTriggerKeydown;
     private addEventListenersFor;
     /** @internal */
     discoverSubmenu(): Promise<void>;
     private registerKeyListener;
     private registerListener;
+    private addObserverForTriggerVisibility;
+    private createFallbackPlacement;
     private resolveElement;
     private checkForSubmenuAnchor;
     private resolveAnchorElement;
     changedShow(newShow: boolean): Promise<void>;
-    changedTrigger(newTriggerValue: ElementReference): void;
+    emitShowChanged(newShow: boolean): Promise<void>;
+    changedTrigger(newTriggerValue: ElementReference, oldTriggerValue: ElementReference | undefined): void;
+    private applyFallbackPosition;
+    private hideDialog;
+    private cleanupOnHide;
     private destroyAutoUpdate;
     private isAnchorSubmenu;
-    private showDropdownAsync;
-    private hideDropdownAsync;
-    private cleanupOnHide;
     private applyDropdownPosition;
-    private focusDropdownItem;
     componentDidLoad(): Promise<void>;
     componentDidRender(): Promise<void>;
     private isTriggerElement;
@@ -123,5 +211,12 @@ export declare class Dropdown implements ComponentInterface, DropdownInterface {
      * Update position of dropdown
      */
     updatePosition(): Promise<void>;
+    openSubmenu(event: CustomEvent<{
+        activeElement: HTMLElement;
+    }>): void;
+    closeSubmenu(): void;
+    /**@internal */
+    resetForwardQueryElement(): Promise<void>;
     render(): any;
 }
+export {};