@siemens/ix 3.0.0-alpha.0 → 3.0.0-alpha.1

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

@@ -0,0 +1,32 @@
+export type TypographyVariants = 'x-small' | 'small' | 'caption' | 'caption-single' | 'default' | 'default-single' | 'default-title' | 'default-title-single' | 'large' | 'large-single' | 'large-title' | 'large-title-single' | 'h2' | 'display-large';
+export type TypographyColors = 'contrast' | 'std' | 'soft' | 'weak' | 'inv-contrast' | 'inv-std' | 'inv-soft' | 'inv-weak' | 'alarm';
+type TypographyFormatLabel = 'label' | 'label-xs' | 'label-sm' | 'label-lg';
+type TypographyFormatBody = 'body' | 'body-xs' | 'body-sm' | 'body-lg';
+type TypographyFormatDisplay = 'display' | 'display-xs' | 'display-sm' | 'display-lg' | 'display-xl' | 'display-xxl';
+type TypographyFormatHeading = 'h6' | 'h5' | 'h4' | 'h3' | 'h2' | 'h1';
+type TypographyFormatCode = 'code' | 'code-sm' | 'code-lg';
+export type TypographyFormat = TypographyFormatLabel | TypographyFormatBody | TypographyFormatDisplay | TypographyFormatHeading | TypographyFormatCode;
+export type TextDecoration = 'none' | 'underline' | 'line-through';
+/**
+ * @since 2.0.0
+ */
+export declare class IxTypography {
+    /**
+     * Text format
+     */
+    format?: TypographyFormat;
+    /**
+     * Text color based on theme variables
+     */
+    textColor?: TypographyColors;
+    /**
+     * Display text bold
+     */
+    bold: boolean;
+    /**
+     * Text decoration
+     */
+    textDecoration: TextDecoration;
+    render(): any;
+}
+export {};

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

@@ -0,0 +1 @@
+export {};

package/dist/types/components/upload/upload-file-state.d.ts

@@ -0,0 +1,6 @@
+export declare enum UploadFileState {
+    SELECT_FILE = "SELECT_FILE",
+    LOADING = "LOADING",
+    UPLOAD_FAILED = "UPLOAD_FAILED",
+    UPLOAD_SUCCESSED = "UPLOAD_SUCCESSED"
+}

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

@@ -0,0 +1,72 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import { UploadFileState } from './upload-file-state';
+export declare class Upload {
+    /**
+     * The accept attribute specifies the types of files that the server accepts (that can be submitted through a file upload).
+     * [accept]{@link "https://www.w3schools.com/tags/att_input_accept.asp"}
+     */
+    accept?: string;
+    /**
+     * If multiple is true the user can drop or select multiple files
+     */
+    multiple: boolean;
+    /**
+     * Whether the text should wrap to more than one line
+     */
+    multiline: boolean;
+    /**
+     * Disable all input events
+     */
+    disabled: boolean;
+    /**
+     * After a file is uploaded you can set the upload component to a defined state
+     */
+    state: UploadFileState;
+    /**
+     * Will be used by state = UploadFileState.SELECT_FILE
+     */
+    selectFileText: string;
+    /**
+     * Will be used by state = UploadFileState.LOADING
+     */
+    loadingText: string;
+    /**
+     * Will be used by state = UploadFileState.UPLOAD_FAILED
+     */
+    uploadFailedText: string;
+    /**
+     * Will be used by state = UploadFileState.UPLOAD_SUCCESSED
+     */
+    uploadSuccessText: string;
+    /**
+     * Label for upload file button
+     */
+    i18nUploadFile: string;
+    /**
+     * Text for disabled state
+     */
+    i18nUploadDisabled: string;
+    /**
+     * You get an array of Files after drop-action or browse action is finished
+     */
+    filesChanged: EventEmitter<Array<File>>;
+    hostElement: HTMLIxUploadElement;
+    get inputElement(): HTMLInputElement;
+    isFileOver: boolean;
+    private filesToUpload?;
+    private a11y;
+    constructor();
+    componentWillLoad(): void;
+    private fileDropped;
+    private fileOver;
+    private fileLeave;
+    private fileChangeEvent;
+    private convertToFileArray;
+    private renderUploadState;
+    /**
+     * Set files
+     * @param obj
+     */
+    setFilesToUpload(obj: any): Promise<void>;
+    render(): any;
+}

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

@@ -0,0 +1,9 @@
+export declare const a11yBoolean: (value: boolean | undefined) => "true" | "false";
+export declare const getFallbackLabelFromIconName: (iconName?: string) => string;
+export declare const a11yHostAttributes: (hostElement: HTMLElement, ignoreAttributes?: A11yAttributeName[]) => Record<A11yAttributeName, string>;
+export type A11yAttributeName = 'role' | 'aria-activedescendant' | 'aria-atomic' | 'aria-autocomplete' | 'aria-braillelabel' | 'aria-brailleroledescription' | 'aria-busy' | 'aria-checked' | 'aria-colcount' | 'aria-colindex' | 'aria-colindextext' | 'aria-colspan' | 'aria-controls' | 'aria-current' | 'aria-describedby' | 'aria-description' | 'aria-details' | 'aria-disabled' | 'aria-errormessage' | 'aria-expanded' | 'aria-flowto' | 'aria-haspopup' | 'aria-hidden' | 'aria-invalid' | 'aria-keyshortcuts' | 'aria-label' | 'aria-labelledby' | 'aria-level' | 'aria-live' | 'aria-multiline' | 'aria-multiselectable' | 'aria-orientation' | 'aria-owns' | 'aria-placeholder' | 'aria-posinset' | 'aria-pressed' | 'aria-readonly' | 'aria-relevant' | 'aria-required' | 'aria-roledescription' | 'aria-rowcount' | 'aria-rowindex' | 'aria-rowindextext' | 'aria-rowspan' | 'aria-selected' | 'aria-setsize' | 'aria-sort' | 'aria-valuemax' | 'aria-valuemin' | 'aria-valuenow' | 'aria-valuetext';
+type PartialRecord<K extends A11yAttributeName, T> = {
+    [P in K]?: T;
+};
+export type A11yAttributes = PartialRecord<A11yAttributeName, string>;
+export {};

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

@@ -0,0 +1,7 @@
+export default abstract class Animation {
+    static readonly shortTime = 0;
+    static readonly defaultTime = 150;
+    static readonly mediumTime = 300;
+    static readonly slowTime = 500;
+    static readonly xSlowTime = 1000;
+}

package/dist/types/components/utils/app-switch/index.d.ts

@@ -0,0 +1,2 @@
+import { AppSwitchConfiguration } from '../application-layout/context';
+export declare function showAppSwitch(config: AppSwitchConfiguration): Promise<(updateAppSwitchConfig: AppSwitchConfiguration) => void>;

package/dist/types/components/utils/application-layout/context.d.ts

@@ -0,0 +1,22 @@
+import { type LiteralStringUnion } from '../type-helper';
+export declare const closestIxMenu: (element: Element) => HTMLIxMenuElement;
+export type AppSwitchConfigurationTarget = LiteralStringUnion<'_self' | '_blank' | '_parent' | '_top'>;
+export type AppSwitchConfiguration = {
+    currentAppId: string;
+    apps: {
+        id: string;
+        name: string;
+        description: string;
+        url: string;
+        target: AppSwitchConfigurationTarget;
+        iconSrc: string;
+    }[];
+    i18nAppSwitch?: string;
+    i18nLoadingApps?: string;
+};
+export declare const ApplicationLayoutContext: Readonly<import("../context").Context<{
+    hideHeader: boolean;
+    host: "basic-navigation" | "map-navigation" | null;
+    appSwitchConfig?: AppSwitchConfiguration;
+    sidebar?: boolean;
+}>>;

package/dist/types/components/utils/application-layout/index.d.ts

@@ -0,0 +1 @@
+export { applicationLayoutService } from './service';

package/dist/types/components/utils/application-layout/service.d.ts

@@ -0,0 +1,17 @@
+import { Breakpoint } from '../breakpoints';
+import { TypedEvent } from '../typed-event';
+declare class ApplicationLayoutService {
+    #private;
+    debouncedOnResize: (...args: unknown[]) => void;
+    constructor();
+    get breakpoint(): "sm" | "md" | "lg";
+    get onChange(): TypedEvent<"sm" | "md" | "lg">;
+    get isDetectionEnabled(): boolean;
+    private onResize;
+    disableBreakpointDetection(): void;
+    enableBreakpointDetection(): void;
+    setBreakpoint(breakpoint: Breakpoint): void;
+    setBreakpoints(breakpoints: Breakpoint[]): void;
+}
+export declare const applicationLayoutService: ApplicationLayoutService;
+export {};

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

@@ -0,0 +1,2 @@
+export type Attributes = Record<string, string>;
+export declare const inheritAttributes: (element: HTMLElement, attributes?: string[]) => Attributes;

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

@@ -0,0 +1,8 @@
+declare const mediaQueries: {
+    readonly sm: "(max-width: 48em)";
+    readonly md: "(min-width: 48.0625em) and (max-width: 80em)";
+    readonly lg: "(min-width: 80.0625em)";
+};
+export type Breakpoint = keyof typeof mediaQueries;
+export declare const matchBreakpoint: (breakpoint: Breakpoint) => boolean;
+export {};

package/dist/types/components/utils/condition-checks.d.ts

@@ -0,0 +1,2 @@
+export declare const isHttpUrl: (link: string) => boolean;
+export declare const isSvgDataUrl: (url: string) => boolean;

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

@@ -0,0 +1,57 @@
+/**
+ * A Context object defines an optional initial value for a Context, as well as a name identifier for debugging purposes.
+ */
+export type Context<T> = {
+    name: string;
+    initialValue?: T;
+};
+/**
+ * An unknown context type
+ */
+export type UnknownContext = Context<unknown>;
+/**
+ * A helper type which can extract a Context value type from a Context type
+ */
+export type ContextType<T extends UnknownContext> = T extends Context<infer Y> ? Y : never;
+/**
+ * A function which creates a Context value object
+ */
+export declare function createContext<T>(name: string, initialValue?: T): Readonly<Context<T>>;
+/**
+ * A callback which is provided by a context requester and is called with the value satisfying the request.
+ * This callback can be called multiple times by context providers as the requested value is changed.
+ */
+export type ContextCallback<ValueType> = (value: ValueType, unsubscribe?: () => void) => void;
+/**
+ * An event fired by a context requester to signal it desires a named context.
+ *
+ * A provider should inspect the `context` property of the event to determine if it has a value that can
+ * satisfy the request, calling the `callback` with the requested value if so.
+ *
+ * If the requested context event contains a truthy `subscribe` value, then a provider can call the callback
+ * multiple times if the value is changed, if this is the case the provider should pass an `unsubscribe`
+ * function to the callback which requesters can invoke to indicate they no longer wish to receive these updates.
+ */
+export declare class ContextEvent<T extends UnknownContext> extends Event {
+    readonly context: T;
+    readonly callback: ContextCallback<ContextType<T>>;
+    readonly subscribe?: boolean;
+    constructor(context: T, callback: ContextCallback<ContextType<T>>, subscribe?: boolean);
+}
+declare global {
+    interface HTMLElementEventMap {
+        /**
+         * A 'context-request' event can be emitted by any element which desires
+         * a context value to be injected by an external provider.
+         */
+        'context-request': ContextEvent<UnknownContext>;
+    }
+}
+export type ContextConsumerSubscription = {
+    unsubscribe: () => void;
+};
+export declare function useContextConsumer<T extends HTMLElement, C extends UnknownContext>(hostElement: T, context: C, onContextReceived: (context: ContextType<C>, unsubscribe?: () => void) => void, subscribe?: boolean): ContextConsumerSubscription;
+export type ContextProvider<C extends Context<{}> = Context<any>> = {
+    emit: (context: ContextType<C>) => void;
+};
+export declare function useContextProvider<X extends {}, C extends Context<X>, T extends HTMLElement = HTMLElement>(hostElement: T, context: C, contextPayload?: ContextType<C>): ContextProvider<C>;

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

@@ -0,0 +1,3 @@
+type AnyFunction = (...args: any[]) => any;
+export declare function debounce<T extends AnyFunction>(func: T, delay: number): (...args: Parameters<T>) => void;
+export {};

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

@@ -0,0 +1,15 @@
+export type DelegateConfig = {
+    parentElement?: Element;
+};
+export interface FrameworkDelegate {
+    attachView<R = HTMLElement>(view: any, config?: DelegateConfig): Promise<R>;
+    removeView(view: any): Promise<void>;
+}
+declare class DefaultFrameworkDelegate implements FrameworkDelegate {
+    attachView<R = HTMLElement>(view: any, config?: DelegateConfig): Promise<R>;
+    removeView(view: any): Promise<void>;
+}
+export declare function registerFrameworkDelegate(delegate: FrameworkDelegate): void;
+export declare const resolveDelegate: () => FrameworkDelegate;
+export declare const getCoreDelegate: () => DefaultFrameworkDelegate;
+export {};

package/dist/types/components/utils/disposable-event-listener.d.ts

@@ -0,0 +1,7 @@
+export type DisposableEventListener = () => void;
+export declare const addDisposableEventListener: (element: Element | Window | Document, eventType: string, callback: EventListenerOrEventListenerObject) => DisposableEventListener;
+export declare const addDisposableEventListenerAsArray: (listener: {
+    element: Element | Window | Document;
+    eventType: string;
+    callback: EventListenerOrEventListenerObject;
+}[]) => DisposableEventListener;

package/dist/types/components/utils/element-reference.d.ts

@@ -0,0 +1 @@
+export type ElementReference = string | HTMLElement | Promise<HTMLElement>;

package/dist/types/components/utils/find-element.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Will try to resolve the selector in the light dom, shadow dom or slot
+ * @param selector The selector to resolve
+ * @param hostElement The element to start the search from
+ * @returns Promise with the resolved elements or undefined if not found
+ */
+export declare function resolveSelector(selector: string, hostElement?: HTMLElement): Promise<HTMLElement[] | undefined>;
+/**
+ * Walk up the DOM to find the nearest shadow root
+ * @param element The element to get the root for
+ * @param parent This will determine how far up the DOM to travel to find the root
+ * @returns The root element
+ */
+export declare function getRootFor(element: HTMLElement, parent?: HTMLElement): HTMLElement | ShadowRoot;
+export declare function waitForSelector(selector: string, node?: Document, hostElement?: HTMLElement): Promise<Element>;
+/**
+ * Find an element by ID or reference
+ * @param element The element to find
+ * @param hostElement The element to start the search from
+ * @returns A promise that will resolve to the element
+ */
+export declare function findElement(element: string | HTMLElement | Promise<HTMLElement>, hostElement?: HTMLElement): Promise<Element>;

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

@@ -0,0 +1,11 @@
+export declare class ArrowFocusController {
+    items: Element[];
+    container?: HTMLElement;
+    wrap: boolean;
+    callback: any;
+    private readonly keyListener;
+    constructor(items: any[], container: HTMLElement, callback?: (index: number) => void);
+    private getActiveIndex;
+    private onKeyDown;
+    disconnect(): void;
+}

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

@@ -0,0 +1,62 @@
+import { EventEmitter } from '../../../stencil-public-runtime';
+import { IxComponent } from '../internal';
+export * from './validation';
+export interface FieldWrapperInterface {
+    /**
+     * Label for the field component
+     */
+    label?: string;
+    /**
+     * Show text below the field component which show additional information
+     */
+    helperText?: string;
+    /**
+     * Info text for the field component
+     */
+    infoText?: string;
+    /**
+     * Warning text for the field component
+     */
+    warningText?: string;
+    /**
+     * Error text for the field component
+     */
+    invalidText?: string;
+    /**
+     * Valid text for the field component
+     */
+    validText?: string;
+    /**
+     * Show helper, info, warning, error and valid text as tooltip
+     */
+    showTextAsTooltip?: boolean;
+}
+export type HTMLIxFormComponentElement<T> = HTMLElement & IxFormComponent<T>;
+export type HTMLIxInputFieldComponentElement<T> = HTMLIxFormComponentElement<T> & IxInputFieldComponent<T>;
+export interface IxFormValidationState {
+    isInvalid: boolean;
+    isValid: boolean;
+    isInfo: boolean;
+    isWarning: boolean;
+}
+export interface IxFormComponent<T = string> extends IxComponent {
+    formInternals: ElementInternals;
+    required?: boolean;
+    name?: string;
+    value?: T;
+    disabled: boolean;
+    valueChange: EventEmitter<T>;
+    updateFormInternalValue(value: T): void;
+    hasValidValue(): Promise<boolean>;
+    getValidityState?(): Promise<ValidityState>;
+    getAssociatedFormElement(): Promise<HTMLFormElement | null>;
+    isTouched?(): Promise<boolean>;
+}
+export interface IxInputFieldComponent<T = string> extends IxFormComponent<T>, IxFormValidationState, FieldWrapperInterface {
+    placeholder?: string;
+    readonly: boolean;
+    ixBlur: EventEmitter<void>;
+    getNativeInputElement(): Promise<HTMLInputElement | HTMLTextAreaElement>;
+    focusInput(): Promise<void>;
+}
+export declare function isIxInputFieldComponent<T>(obj: HTMLElement | IxFormComponent<T>): obj is HTMLIxInputFieldComponentElement<T>;

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

@@ -0,0 +1,16 @@
+import { HTMLIxFormComponentElement, IxFormComponent } from '.';
+import { IxComponent } from '../internal';
+export type ClassMutationObserver = {
+    destroy: () => void;
+};
+export declare function isTouched<T>(host: IxFormComponent<T>): Promise<boolean>;
+export declare function shouldSuppressInternalValidation<T>(host: IxFormComponent<T>): Promise<boolean>;
+export declare function createClassMutationObserver(element: HTMLElement, callback: () => void, options?: {
+    includeChildren?: boolean;
+}): ClassMutationObserver;
+export type ValidationResultProperty = 'isInvalid' | 'isInvalidByRequired' | 'isValid' | 'isInfo' | 'isWarning';
+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;

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

@@ -0,0 +1,4 @@
+import { HTMLStencilElement, ComponentInterface } from '../../../stencil-public-runtime';
+export interface IxComponent extends ComponentInterface {
+    hostElement: HTMLStencilElement;
+}

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

@@ -0,0 +1 @@
+export { IxComponent } from './component';

package/dist/types/components/utils/lazy-list/index.d.ts

@@ -0,0 +1,2 @@
+export type { VirtualListConfig } from './lazy';
+export { VirtualList } from './lazy';

package/dist/types/components/utils/lazy-list/lazy.d.ts

@@ -0,0 +1,51 @@
+export type VirtualListConfig = {
+    applyPatch?: (element: HTMLElement, fragment: DocumentFragment | DocumentFragment[]) => void;
+    overrideScrollPosition?: () => void;
+    rowClassName?: string;
+    scrollContainer?: HTMLElement;
+    width: string;
+    height: string;
+    afterRender?: () => void;
+    scrollerTagName?: string;
+    scroller?: HTMLElement;
+    useFragment?: boolean;
+    generate?: (index: number) => HTMLElement;
+    total?: number;
+    itemHeight?: number;
+    horizontal?: boolean;
+};
+export declare class VirtualList {
+    _config: VirtualListConfig;
+    _lastRepaint: null;
+    _maxElementHeight: number;
+    _renderAnimationFrame: number;
+    _averageHeight: number;
+    static readonly defaultConfig: VirtualListConfig;
+    _element: any;
+    _scroller: any;
+    _itemHeights: number[];
+    _containerSize: number | string;
+    _scrollPaddingBottom: number;
+    _scrollPaddingTop: number;
+    _scrollHeight: any;
+    _itemPositions: any;
+    _screenItemsLen: number;
+    _lastFrom: number;
+    _cachedItemsLen: any;
+    static create(element: HTMLElement, userProvidedConfig?: VirtualListConfig): VirtualList;
+    static mergeStyle(element: HTMLElement, style: any): void;
+    static getMaxBrowserHeight(): number;
+    constructor(element: HTMLElement, userProvidedConfig: VirtualListConfig);
+    destroy(): void;
+    refresh(element: HTMLElement, userProvidedConfig?: VirtualListConfig): void;
+    _getRow(i: number): any;
+    _getScrollPosition(): any;
+    _renderChunk(force?: boolean): false | void;
+    _computePositions(from?: number): void;
+    _computeScrollHeight(): number;
+    _computeScrollPadding(): {
+        bottom: number;
+        top: number;
+    };
+    _getFrom(scrollTop: number): number;
+}

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

@@ -0,0 +1,13 @@
+export type ListenerOptions = {
+    target?: 'window';
+    defaultEnabled?: boolean;
+};
+type HostListener = {
+    on: (onEventCallback: any) => void;
+    isEnabled: boolean | undefined;
+    enable: (state: boolean) => void;
+    destroy: () => void;
+};
+export declare function createListener(event: string, options?: ListenerOptions): HostListener;
+export declare function OnListener<T>(event: string, fnExp?: (self: T) => boolean): (proto: any, methodName: string) => void;
+export {};

package/dist/types/components/utils/make-ref.d.ts

@@ -0,0 +1,6 @@
+export type MakeRef<T> = {
+    (ref: T | undefined | null): void;
+    current: T | null;
+    waitForCurrent(): Promise<T>;
+};
+export declare function makeRef<T>(currentChangedCallback?: (element: T) => void): MakeRef<T>;

package/dist/types/components/utils/menu-service/menu-service.d.ts

@@ -0,0 +1,14 @@
+import { TypedEvent } from '../typed-event';
+declare class MenuService {
+    #private;
+    register(menuElement: HTMLIxMenuElement): void;
+    setIsPinned(pinned: boolean): void;
+    open(): Promise<boolean>;
+    close(): Promise<boolean>;
+    toggle(): Promise<boolean>;
+    get nativeElement(): HTMLIxMenuElement;
+    get expandChange(): TypedEvent<boolean>;
+    get isPinned(): boolean;
+}
+export declare const menuController: MenuService;
+export {};

package/dist/types/components/utils/menu-tabs/menu-tabs-fc.d.ts

@@ -0,0 +1,8 @@
+import { FunctionalComponent } from '../../../stencil-public-runtime';
+import { MenuAbout } from '../../menu-about/menu-about';
+import { MenuSettings } from '../../menu-settings/menu-settings';
+interface MenuTabsProps {
+    context: MenuSettings | MenuAbout;
+}
+export declare const MenuTabs: FunctionalComponent<MenuTabsProps>;
+export {};

package/dist/types/components/utils/menu-tabs/menu-tabs-utils.d.ts

@@ -0,0 +1,13 @@
+import { MenuAbout } from '../../menu-about/menu-about';
+import { MenuSettings } from '../../menu-settings/menu-settings';
+export declare function setTab(context: MenuSettings | MenuAbout, label: string): void;
+export declare function initialize(context: MenuSettings | MenuAbout): void;
+export interface CustomLabelChangeEvent {
+    name: string;
+    oldLabel: string;
+    newLabel: string;
+}
+export interface CustomCloseEvent {
+    nativeEvent: MouseEvent;
+    name: string;
+}

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

@@ -0,0 +1,3 @@
+export { showModalLoading } from './loading';
+export { MessageConfig, showMessage } from './message';
+export { closeModal, dismissModal, ModalConfig, ModalInstance, showModal, } from './modal';

package/dist/types/components/utils/modal/loading.d.ts

@@ -0,0 +1,4 @@
+export declare function showModalLoading(message: string): {
+    update: (text: string) => string;
+    finish: (text?: string, timeout?: number) => void;
+};

package/dist/types/components/utils/modal/message.d.ts

@@ -0,0 +1,44 @@
+import { TypedEvent } from '../typed-event';
+import { ModalConfig } from './modal';
+export type MessageConfig<T> = Omit<ModalConfig<T, unknown>, 'content' | 'title'> & MessageContent;
+export type MessageAction = {
+    id: string;
+    type: 'button-primary' | 'button-secondary' | 'okay' | 'cancel';
+    text: string;
+    payload?: any;
+};
+export type MessageContent = {
+    icon: string;
+    iconColor?: string;
+    messageTitle: string;
+    message: string;
+    actions: MessageAction[];
+    ariaLabelledby?: string;
+    ariaDescribedby?: string;
+};
+export declare function showMessage<T>(config: MessageConfig<T>): Promise<TypedEvent<{
+    actionId: string;
+    payload: T;
+}>>;
+export declare namespace showMessage {
+    var info: (title: string, message: string, textOkay: string, textCancel?: string, payloadOkay?: any, payloadCancel?: any) => Promise<TypedEvent<{
+        actionId: string;
+        payload: unknown;
+    }>>;
+    var warning: (title: string, message: string, textOkay: string, textCancel?: string, payloadOkay?: any, payloadCancel?: any) => Promise<TypedEvent<{
+        actionId: string;
+        payload: unknown;
+    }>>;
+    var error: (title: string, message: string, textOkay: string, textCancel?: string, payloadOkay?: any, payloadCancel?: any) => Promise<TypedEvent<{
+        actionId: string;
+        payload: unknown;
+    }>>;
+    var success: (title: string, message: string, textOkay: string, textCancel?: string, payloadOkay?: any, payloadCancel?: any) => Promise<TypedEvent<{
+        actionId: string;
+        payload: unknown;
+    }>>;
+    var question: (title: string, message: string, textOkay: string, textCancel?: string, payloadOkay?: any, payloadCancel?: any) => Promise<TypedEvent<{
+        actionId: string;
+        payload: unknown;
+    }>>;
+}

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

@@ -0,0 +1,25 @@
+import { IxModalSize } from '../../modal/modal';
+import { TypedEvent } from '../typed-event';
+export declare function setA11yAttributes(element: HTMLElement, config: ModalConfig): void;
+export interface ModalConfig<TReason = any, CONTENT = any> {
+    animation?: boolean;
+    ariaDescribedby?: string;
+    ariaLabelledby?: string;
+    backdrop?: boolean;
+    closeOnBackdropClick?: boolean;
+    beforeDismiss?: (reason?: TReason) => boolean | Promise<boolean>;
+    centered?: boolean;
+    container?: string | HTMLElement;
+    content: CONTENT | string;
+    keyboard?: boolean;
+    size?: IxModalSize;
+    title?: string;
+}
+export interface ModalInstance<TReason = any> {
+    htmlElement: HTMLIxModalElement;
+    onClose: TypedEvent<TReason>;
+    onDismiss: TypedEvent<TReason>;
+}
+export declare function closeModal<TClose = any>(element: Element, closeResult: TClose): void;
+export declare function dismissModal(element: Element, dismissResult?: any): void;
+export declare function showModal<T>(config: ModalConfig<T>): Promise<ModalInstance<T>>;

package/dist/types/components/utils/mutation-observer.d.ts

@@ -0,0 +1 @@
+export declare const createMutationObserver: (callback: MutationCallback) => MutationObserver;

package/dist/types/components/utils/notification-color.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Icon colors representing common notification states (e.g. alarm, info).
+ */
+export type NotificationColor = 'color-std-text' | 'color-info' | 'color-critical' | 'color-warning' | 'color-success' | 'color-alarm' | 'color-neutral' | 'color-primary';