@siemens/ix 0.0.0-20240419081748

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

@@ -0,0 +1,70 @@
+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;
+    constructor();
+    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) => "true" | "false";
+export declare const getFallbackLabelFromIconName: (iconName: string) => string;
+export declare const a11yHostAttributes: (hostElement: HTMLElement, ignoreAttributes?: A11yAttributeName[]) => Record<A11yAttributeName, any>;
+type PartialRecord<K extends keyof any, T> = {
+    [P in K]?: T;
+};
+export type A11yAttributes = PartialRecord<A11yAttributeName, any>;
+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';
+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,21 @@
+export declare const closestIxMenu: (element: Element) => HTMLIxMenuElement;
+export type AppSwitchConfigurationTarget = '_self' | '_blank' | '_parent' | '_top' | (string & {});
+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/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/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/listener.d.ts

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

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

@@ -0,0 +1,6 @@
+export type MakeRef<T> = {
+    (ref: T): void;
+    current: T;
+    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 { 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,41 @@
+import { TypedEvent } from '../typed-event';
+export type MessageContent = {
+    icon: string;
+    iconColor?: string;
+    messageTitle: string;
+    message: string;
+    actions: {
+        id: string;
+        type: 'button-primary' | 'button-secondary' | 'okay' | 'cancel';
+        text: string;
+        payload?: any;
+    }[];
+    ariaLabelledby?: string;
+    ariaDescribedby?: string;
+};
+export declare function showMessage<T>(config: MessageContent): 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-warning' | 'color-success' | 'color-alarm';

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

@@ -0,0 +1,16 @@
+import { IxComponent } from '../utils/internal';
+export interface IxOverlayComponent extends IxComponent {
+    isPresent(): boolean;
+    willPresent?(): boolean;
+    willDismiss?(): boolean;
+    present(): void;
+    dismiss(): void;
+}
+export declare class OverlayController {
+    overlays: Set<IxOverlayComponent>;
+    connected(instance: IxOverlayComponent): void;
+    disconnected(instance: IxOverlayComponent): void;
+    present(instance: IxOverlayComponent): void;
+    dismiss(instance: IxOverlayComponent): void;
+    private dismissOthers;
+}

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

@@ -0,0 +1,7 @@
+/**
+ * Prevents angular from change detection when requesting an animation frame
+ *
+ * Credits goes to:
+ * https://github.com/ionic-team/ionic-framework/blob/main/core/src/utils/helpers.ts
+ */
+export declare const requestAnimationFrameNoNgZone: (callback: (...args: any[]) => void) => any;

package/dist/types/components/utils/rwd.util.d.ts

@@ -0,0 +1,2 @@
+export declare const convertToRemString: (value: number) => string;
+export declare const convertToAbbreviationString: (num: number) => string;

package/dist/types/components/utils/shadow-dom.d.ts

@@ -0,0 +1,5 @@
+export declare function closestElement(selector: string, el: any): any;
+export declare function getSlottedElements<R = any>(slot: any): R[];
+export declare function hasSlottedElements(slot: any): boolean;
+export declare function containsElement(target: Element, element: Element): boolean;
+export declare function closestPassShadow(node: Node, selector: string): HTMLElement;

package/dist/types/components/utils/theme-switcher.d.ts

@@ -0,0 +1,26 @@
+import { TypedEvent } from './typed-event';
+export type ThemeVariant = 'light' | 'dark';
+declare class ThemeSwitcher {
+    readonly prefixTheme = "theme-";
+    readonly suffixLight = "-light";
+    readonly suffixDark = "-dark";
+    readonly defaultTheme = "theme-classic-dark";
+    mutationObserver: MutationObserver;
+    _themeChanged: TypedEvent<string>;
+    get themeChanged(): TypedEvent<string>;
+    hasVariantSuffix(className: string): boolean;
+    private isThemeClass;
+    setTheme(themeName: string, systemAppearance?: boolean): void;
+    private replaceBodyThemeClass;
+    toggleMode(): void;
+    getCurrentTheme(): string;
+    setVariant(variant?: ThemeVariant): void;
+    private getOppositeMode;
+    private handleMutations;
+    private registerMutationObserver;
+    constructor();
+}
+export type IxTheme = 'classic' | 'classic-dark' | 'classic-light' | (string & {});
+export declare const getCurrentSystemAppearance: () => ThemeVariant;
+export declare const themeSwitcher: ThemeSwitcher;
+export {};

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

@@ -0,0 +1,15 @@
+export interface Listener<T> {
+    (event: T): any;
+}
+export interface Disposable {
+    dispose(): void;
+}
+export declare class TypedEvent<T> {
+    readonly listeners: Listener<T>[];
+    listenersOncer: Listener<T>[];
+    on: (listener: Listener<T>) => Disposable;
+    once: (listener: Listener<T>) => void;
+    off: (listener: Listener<T>) => void;
+    emit: (event: T) => void;
+    pipe: (te: TypedEvent<T>) => Disposable;
+}

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

@@ -0,0 +1 @@
+export declare function waitForElement<R extends HTMLElement>(selector: string, doc: any, timeout?: number): Promise<R>;

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

@@ -0,0 +1,45 @@
+import { Side } from '../dropdown/placement';
+type Position = {
+    x: number;
+    y: number;
+};
+/**
+ * @slot tooltip-message - Custom tooltip message with html support
+ */
+export declare class ValidationTooltip {
+    hostElement: HTMLIxValidationTooltipElement;
+    /**
+     * Message of the tooltip
+     */
+    message: string;
+    /**
+     * Placement of the tooltip
+     */
+    placement: Side;
+    /**
+     * Suppress the automatic placement of the dropdown.
+     *
+     * @since 2.0.0
+     */
+    suppressAutomaticPlacement: boolean;
+    isInputValid: boolean;
+    tooltipPosition: Position;
+    arrowPosition: Position;
+    private onSubmitBind;
+    private onInputFocusBind;
+    private autoUpdateCleanup;
+    private observer;
+    get arrow(): HTMLElement;
+    get inputElement(): HTMLInputElement;
+    get formElement(): HTMLFormElement;
+    get tooltipElement(): HTMLElement;
+    private destroyAutoUpdate;
+    private applyTooltipPosition;
+    componentDidLoad(): void;
+    private onInputFocus;
+    private onSubmit;
+    disconnectedCallback(): void;
+    validationChanged(): void;
+    render(): any;
+}
+export {};

package/dist/types/components/workflow-step/workflow-step.d.ts

@@ -0,0 +1,42 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+export declare class WorkflowStep {
+    hostElement: HTMLIxWorkflowStepElement;
+    /**
+     * Select orientation
+     */
+    vertical: boolean;
+    /**
+     * Set disabled
+     */
+    disabled: boolean;
+    /**
+     * Set status
+     */
+    status: 'open' | 'success' | 'done' | 'warning' | 'error';
+    /**
+     * Activate navigation click
+     */
+    clickable: boolean;
+    /**
+     * Set selected
+     */
+    selected: boolean;
+    /**
+     * Activate navigation click
+     *
+     * @internal
+     */
+    position: 'first' | 'last' | 'single' | 'undefined';
+    iconName: 'circle' | 'circle-dot' | 'success' | 'warning' | 'error';
+    iconColor: string;
+    /**
+     * @internal
+     */
+    selectedChanged: EventEmitter<HTMLIxWorkflowStepElement>;
+    private customIconSlot;
+    selectedHandler(): void;
+    watchPropHandler(): void;
+    componentDidLoad(): void;
+    onStepClick(): void;
+    render(): any;
+}

package/dist/types/components/workflow-steps/test/workflow-steps.ct.d.ts

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

package/dist/types/components/workflow-steps/workflow-steps.d.ts

@@ -0,0 +1,29 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+export declare class WorkflowSteps {
+    hostElement: HTMLIxWorkflowStepsElement;
+    /**
+     * Select orientation
+     */
+    vertical: boolean;
+    /**
+     * Activate navigation click
+     */
+    clickable: boolean;
+    /**
+     * Activate navigation click
+     */
+    selectedIndex: number;
+    /**
+     * On step selected event
+     */
+    stepSelected: EventEmitter<number>;
+    private getSteps;
+    updateSteps(): void;
+    private observer;
+    onStepSelectionChanged(event: CustomEvent<HTMLIxWorkflowStepElement>): void;
+    componentWillLoad(): void;
+    componentDidLoad(): void;
+    disconnectedCallback(): void;
+    componentDidRender(): void;
+    render(): any;
+}