@deepkit/desktop-ui/dist/index.d.ts

Library for desktop UI widgets in Angular 10+

import * as _angular_core from '@angular/core';
import { ChangeDetectorRef, Type, OnDestroy, Injector, EventEmitter, ApplicationRef, Renderer2, RendererFactory2, TemplateRef, ViewContainerRef, EmbeddedViewRef, Signal, ElementRef, OnInit, OnChanges, WritableSignal, OutputEmitterRef, AfterViewInit, SimpleChanges, OutputRefSubscription, PendingTasks, PipeTransform, ComponentRef, ComponentFactoryResolver, QueryList } from '@angular/core';
import { FormGroup, NgControl, ControlValueAccessor } from '@angular/forms';
import { Subscription, Observable } from 'rxjs';
import { TemplatePortal } from '@angular/cdk/portal';
import { ConnectedPosition, Overlay, OverlayRef, PositionStrategy } from '@angular/cdk/overlay';
import * as i1 from '@angular/router';
import { Router, RouterLinkActive, RouterLink } from '@angular/router';
import { DomSanitizer, SafeUrl } from '@angular/platform-browser';
import { Excluded, Type as Type$1 } from '@deepkit/type';
import { TypeAnnotation, ClassType } from '@deepkit/core';
import { Progress } from '@deepkit/rpc';
import { ProgressTracker } from '@deepkit/core-rxjs';
import { CdkVirtualScrollViewport } from '@angular/cdk/scrolling';

declare class BrowserText {
    fontSize: number;
    fontFamily: string;
    protected canvas: HTMLCanvasElement;
    protected context: CanvasRenderingContext2D;
    constructor(fontSize?: number, fontFamily?: string);
    destroy(): void;
    getDimensions(text: string): {
        width: number;
        height: number;
    };
}

declare class FormRowComponent {
    label: _angular_core.InputSignal<string>;
    description: _angular_core.InputSignal<string>;
    labelWidth: _angular_core.InputSignal<number | undefined>;
    left: _angular_core.InputSignalWithTransform<boolean, unknown>;
    ngControl?: NgControl;
    isString(v: any): v is string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormRowComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormRowComponent, "dui-form-row", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "labelWidth": { "alias": "labelWidth"; "required": false; "isSignal": true; }; "left": { "alias": "left"; "required": false; "isSignal": true; }; }, {}, ["ngControl"], ["*"], true, never>;
}
declare class FormComponent {
    protected cd: ChangeDetectorRef;
    protected cdParent: ChangeDetectorRef;
    formGroup: _angular_core.InputSignal<FormGroup<any>>;
    disabled: _angular_core.InputSignal<boolean>;
    submit: _angular_core.InputSignal<(() => Promise<any> | any) | undefined>;
    success: _angular_core.OutputEmitterRef<void>;
    error: _angular_core.OutputEmitterRef<void>;
    errorText: _angular_core.WritableSignal<string>;
    submitting: _angular_core.WritableSignal<boolean>;
    constructor(cd: ChangeDetectorRef, cdParent: ChangeDetectorRef);
    onEnter(event: KeyboardEvent): void;
    get invalid(): boolean;
    submitForm(): Promise<void>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormComponent, [null, { skipSelf: true; }]>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormComponent, "dui-form", never, { "formGroup": { "alias": "formGroup"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "submit": { "alias": "submit"; "required": false; "isSignal": true; }; }, { "success": "success"; "error": "error"; }, never, ["*"], true, never>;
}

declare function ngValueAccessor<T>(clazz: Type<T>): {
    provide: _angular_core.InjectionToken<readonly ControlValueAccessor[]>;
    useExisting: Type<any>;
    multi: boolean;
};
declare class ValueAccessorBase<T> implements ControlValueAccessor, OnDestroy {
    private _ngControl?;
    private _ngControlFetched;
    value: _angular_core.ModelSignal<T | undefined>;
    disabled: _angular_core.ModelSignal<boolean>;
    valid?: boolean;
    error?: boolean;
    protected formComponent?: FormComponent;
    protected _changedCallback: ((value: T | undefined) => void)[];
    protected _touchedCallback: (() => void)[];
    get isDisabled(): boolean;
    get isValid(): boolean;
    get isError(): boolean | null | undefined;
    required: _angular_core.InputSignal<boolean>;
    protected injector: Injector;
    get ngControl(): NgControl | undefined;
    setDisabledState(isDisabled: boolean): void;
    ngOnDestroy(): void;
    /**
     * This is called whenever value() needs to update. Either through Angular forms or through setValue().
     * Do not call this method in UI code, use setValue() instead so that angular forms informed about the change.
     *
     * This is a good place to normalize values whenever they change. (like clamping a number to a range)
     */
    writeValue(value?: T): void;
    /**
     * Set the value from UI code.
     */
    setValue(value: T | undefined): void;
    /**
     * Call this method to signal Angular's form or other users that this widget has been touched.
     */
    touch(): void;
    registerOnChange(fn: (value: T | undefined) => void): void;
    registerOnTouched(fn: () => void): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ValueAccessorBase<any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ValueAccessorBase<any>, never, never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "valid": { "alias": "valid"; "required": false; }; "error": { "alias": "error"; "required": false; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "disabled": "disabledChange"; }, never, never, true, never>;
}

/**
 * @reflection never
 */

type ElectronOrBrowserWindow = Window & {
    setVibrancy?: (vibrancy: string) => void;
    addListener?: (event: string, listener: (...args: any[]) => void) => void;
    removeListener?: (event: string, listener: (...args: any[]) => void) => void;
};
declare class BrowserWindow {
    private window?;
    constructor(window?: ElectronOrBrowserWindow | undefined);
    isElectron(): boolean;
    getWindow(): ElectronOrBrowserWindow | undefined;
    setVibrancy(vibrancy: string): void;
    addListener(event: string, listener: (...args: any[]) => void): void;
    removeListener(event: string, listener: (...args: any[]) => void): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BrowserWindow, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<BrowserWindow>;
}
declare class Electron {
    static getRemote(): any;
    static getIpc(): any;
    static isAvailable(): any;
    static getRemoteOrUndefined(): any;
    static getProcess(): any;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Electron, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<Electron>;
}
declare class AsyncEventEmitter<T> extends EventEmitter<T> {
    emit(value?: T): void;
    subscribe(generatorOrNext?: any, error?: any, complete?: any): Subscription;
}
declare class ExecutionState {
    protected readonly cd: ChangeDetectorRef;
    protected readonly func: (...args: any[]) => Promise<any> | any;
    running: boolean;
    error: string;
    constructor(cd: ChangeDetectorRef, func: (...args: any[]) => Promise<any> | any);
    execute(...args: any[]): Promise<any>;
}
/**
 * Checks if `target` is children of `parent` or if `target` is `parent`.
 */
declare function isTargetChildOf(target: HTMLElement | EventTarget | null, parent: HTMLElement): boolean;
declare function isMacOs(): boolean;
declare function isWindows(): boolean;
/**
 * Checks if `target` is children of `parent` or if `target` is `parent`.
 */
declare function findParentWithClass(start: HTMLElement, className: string): HTMLElement | undefined;
declare function triggerResize(): void;
type FocusWatcherUnsubscribe = () => void;
/**
 * Observes focus changes on target elements and emits when focus is lost.
 *
 * This is used to track multi-element focus changes, such as when a user clicks from a dropdown toggle into the dropdown menu.
 */
declare function focusWatcher(target: Element, allowedFocuses: Element[] | undefined, onBlur: (event: FocusEvent) => void, customChecker?: (currentlyFocused: Element | null) => boolean): FocusWatcherUnsubscribe;
declare function redirectScrollableParentsToWindowResize(node: Element, passive?: boolean): () => void;
declare function getScrollableParents(node: Element): Element[];
declare function trackByIndex(index: number): number;
declare type __ΩElectronOrBrowserWindow = any[];
declare type __ΩFocusWatcherUnsubscribe = any[];

declare class DuiDocument implements OnDestroy {
    document: Document | null;
    activeElement: _angular_core.WritableSignal<Element | undefined>;
    onFocus: () => void;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DuiDocument, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DuiDocument>;
}

declare class BaseComponent {
    disabled: _angular_core.InputSignal<boolean | undefined>;
    get isDisabled(): boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseComponent, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BaseComponent, never, never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
declare class UiComponentComponent extends BaseComponent {
    name: _angular_core.InputSignal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UiComponentComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UiComponentComponent, "ui-component", never, { "name": { "alias": "name"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
declare class OverlayStackItem {
    level: number;
    host: HTMLElement;
    component: any;
    close: () => void;
    protected stack: OverlayStackItem[];
    release: () => void;
    constructor(level: number, host: HTMLElement, component: any, close: () => void, stack: OverlayStackItem[], release: () => void);
    getAllAfter(): OverlayStackItem[];
    getPrevious(): OverlayStackItem | undefined;
    isLast(): boolean;
    getAllBefore(): OverlayStackItem[];
}
declare class OverlayStack {
    stack: OverlayStackItem[];
    register(host: HTMLElement, component: any, onClose: () => void): OverlayStackItem;
    forEach(callback: (item: OverlayStackItem) => void): void;
    getCurrentLevel(): number;
    getLevel(item: OverlayStackItem): number;
    getForComponent(component: any): OverlayStackItem | undefined;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayStack, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<OverlayStack>;
}
declare class Storage {
    getItem(key: string): any;
    setItem(key: string, value: any): void;
    removeItem(key: string): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Storage, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<Storage>;
}
declare class DuiApp {
    protected app: ApplicationRef;
    protected document: Document;
    protected storage: Storage;
    protected windowRegistry?: WindowRegistry | undefined;
    protected router?: Router | undefined;
    darkMode: _angular_core.WritableSignal<boolean | undefined>;
    platform: _angular_core.WritableSignal<"web" | "darwin" | "linux" | "win32">;
    themeDetection: boolean;
    protected render: Renderer2;
    constructor(app: ApplicationRef, document: Document, rendererFactory: RendererFactory2, storage: Storage, windowRegistry?: WindowRegistry | undefined, router?: Router | undefined);
    start(): void;
    setPlatform(platform: 'web' | 'darwin' | 'linux' | 'win32'): void;
    getPlatform(): string;
    isDarkMode(): boolean;
    setAutoDarkMode(): void;
    get theme(): 'auto' | 'light' | 'dark';
    set theme(theme: 'auto' | 'light' | 'dark');
    isDarkModeOverwritten(): boolean;
    setGlobalDarkMode(darkMode: boolean): void;
    getVibrancy(): 'ultra-dark' | 'light';
    disableThemeDetection(): void;
    setDarkMode(darkMode?: boolean): void;
    protected isPreferDarkColorSchema(): boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DuiApp, [null, null, null, null, { optional: true; }, { optional: true; }]>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DuiApp>;
}

type BuiltTemplateItem = {
    [name: string]: any;
};

declare abstract class MenuBase implements ActiveComponent, OnDestroy {
    destroy: _angular_core.OutputEmitterRef<void>;
    label: _angular_core.InputSignal<string | undefined>;
    sublabel: _angular_core.InputSignal<string | undefined>;
    icon: _angular_core.InputSignal<string | undefined>;
    disabled: _angular_core.InputSignal<boolean>;
    accelerator: _angular_core.InputSignal<string | undefined>;
    role: _angular_core.InputSignal<string | undefined>;
    hotkey: _angular_core.InputSignal<string>;
    visible: _angular_core.InputSignal<boolean>;
    onlyMacOs: _angular_core.InputSignalWithTransform<boolean, unknown>;
    noMacOs: _angular_core.InputSignalWithTransform<boolean, unknown>;
    id: _angular_core.InputSignal<string | undefined>;
    before: _angular_core.InputSignal<string | undefined>;
    after: _angular_core.InputSignal<string | undefined>;
    beforeGroupContaining: _angular_core.InputSignal<string | undefined>;
    afterGroupContaining: _angular_core.InputSignal<string | undefined>;
    template: _angular_core.Signal<TemplateRef<any> | undefined>;
    registeredHotkey: _angular_core.WritableSignal<string>;
    click: _angular_core.OutputEmitterRef<void>;
    checkboxStyle: boolean;
    type: string;
    level: _angular_core.WritableSignal<number>;
    children: _angular_core.Signal<readonly MenuBase[]>;
    active: _angular_core.WritableSignal<boolean>;
    ngOnDestroy(): void;
    buildTemplate(item: BuiltTemplateItem): void;
    activate(): void;
    constructor();
    validOs(): boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuBase, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MenuBase, never, never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "sublabel": { "alias": "sublabel"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "accelerator": { "alias": "accelerator"; "required": false; "isSignal": true; }; "role": { "alias": "role"; "required": false; "isSignal": true; }; "hotkey": { "alias": "hotkey"; "required": false; "isSignal": true; }; "visible": { "alias": "visible"; "required": false; "isSignal": true; }; "onlyMacOs": { "alias": "onlyMacOs"; "required": false; "isSignal": true; }; "noMacOs": { "alias": "noMacOs"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "before": { "alias": "before"; "required": false; "isSignal": true; }; "after": { "alias": "after"; "required": false; "isSignal": true; }; "beforeGroupContaining": { "alias": "beforeGroupContaining"; "required": false; "isSignal": true; }; "afterGroupContaining": { "alias": "afterGroupContaining"; "required": false; "isSignal": true; }; }, { "destroy": "destroy"; "click": "click"; }, ["children"], never, true, never>;
}
declare class MenuItemComponent extends MenuBase {
    type: string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuItemComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuItemComponent, "dui-menu-item", never, {}, {}, never, ["*"], true, never>;
}
declare class MenuDivComponent extends MenuBase {
    type: string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuDivComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuDivComponent, "dui-menu-div", never, {}, {}, never, ["*"], true, never>;
}
declare class MenuCheckboxDirective extends MenuBase {
    checked: _angular_core.InputSignal<boolean>;
    type: string;
    buildTemplate(item: BuiltTemplateItem): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuCheckboxDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MenuCheckboxDirective, "dui-menu-checkbox", never, { "checked": { "alias": "checked"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
declare class MenuRadioComponent extends MenuBase {
    checked: _angular_core.InputSignal<boolean>;
    type: string;
    buildTemplate(item: BuiltTemplateItem): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuRadioComponent, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MenuRadioComponent, "dui-menu-radio", never, { "checked": { "alias": "checked"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
declare class MenuSeparatorComponent extends MenuBase {
    type: string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuSeparatorComponent, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MenuSeparatorComponent, "dui-menu-separator", never, {}, {}, never, never, true, never>;
}
declare class MenuRenderDirective implements OnDestroy {
    duiMenuRender: _angular_core.InputSignal<readonly MenuBase[]>;
    template: _angular_core.InputSignal<TemplateRef<{
        $implicit: MenuBase;
    }>>;
    rootAsButton: _angular_core.InputSignalWithTransform<boolean, unknown>;
    protected elementRef: _angular_core.ElementRef<HTMLElement>;
    protected viewContainerRef: ViewContainerRef;
    protected createdViews: EmbeddedViewRef<any>[];
    protected renderer: Renderer2;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuRenderDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MenuRenderDirective, "[duiMenuRender]", never, { "duiMenuRender": { "alias": "duiMenuRender"; "required": true; "isSignal": true; }; "template": { "alias": "template"; "required": true; "isSignal": true; }; "rootAsButton": { "alias": "rootAsButton"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
interface TemplateContext {
    $implicit: MenuBase;
}
declare class MenuItemTemplate {
    static ngTemplateContextGuard(directive: unknown, context: unknown): context is TemplateContext;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuItemTemplate, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MenuItemTemplate, "[menuItemTemplate]", never, {}, {}, never, never, true, never>;
}
declare class MenuComponent implements OnDestroy {
    /**
     * If true, this menu is used for the application menu bar (only works in Electron).
     */
    forApp: _angular_core.InputSignalWithTransform<boolean, unknown>;
    moreLabel: _angular_core.InputSignal<string>;
    children: _angular_core.Signal<readonly MenuBase[]>;
    adaptiveContainer: _angular_core.Signal<AdaptiveContainerComponent>;
    dropdownPositionsRoot: ConnectedPosition[];
    dropdownPositions: ConnectedPosition[];
    protected overlayStack: OverlayStack;
    protected windowMenuState: WindowMenuState | null;
    protected dropdowns: Map<number, DropdownComponent>;
    protected hotkeyRegistry: HotkeyRegistry;
    protected active: _angular_core.WritableSignal<boolean>;
    protected dropdownItemsMap: WeakMap<Element, MenuBase>;
    registerDropdownItem(item: Element, menu: MenuBase): void;
    selected(item: MenuBase): boolean;
    constructor();
    activate(item: MenuBase): void;
    close(): void;
    lostFocus(event: FocusEvent): void;
    protected hideSiblingsAndAbove(item: MenuBase): void;
    dropdownHidden(dropdown: DropdownComponent, level: number): void;
    dropdownShown(dropdown: DropdownComponent, level: number): void;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuComponent, "dui-menu", never, { "forApp": { "alias": "forApp"; "required": false; "isSignal": true; }; "moreLabel": { "alias": "moreLabel"; "required": false; "isSignal": true; }; }, {}, ["children"], never, true, never>;
}
declare type __ΩTemplateContext = any[];

declare class WindowMenuState {
    menus: MenuComponent[];
    addMenu(menu: MenuComponent): void;
    removeMenu(menu: MenuComponent): void;
    build(): void;
    protected _build(): void;
    focus(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WindowMenuState, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<WindowMenuState>;
}

interface WinHeader {
    getBottomPosition(): number;
}
interface Win {
    id: number;
    browserWindow: BrowserWindow;
    getClosestNonDialogWindow(): Win | undefined;
    header: Signal<WinHeader | undefined>;
    viewContainerRef: ViewContainerRef;
}
declare class WindowRegistry {
    id: number;
    registry: Map<Win, {
        state: WindowState;
        menu: WindowMenuState;
        viewContainerRef: ViewContainerRef;
    }>;
    windowHistory: Win[];
    activeWindow?: Win;
    getAllElectronWindows(): BrowserWindow[];
    register(win: Win, state: WindowState, menu: WindowMenuState, viewContainerRef: ViewContainerRef): void;
    /**
     * Finds the activeWindow and returns its most outer parent.
     */
    getOuterActiveWindow(): Win | undefined;
    getCurrentViewContainerRef(): ViewContainerRef;
    focus(win: Win): void;
    blur(win: Win): void;
    unregister(win: Win): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WindowRegistry, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<WindowRegistry>;
}
interface AlignedButtonGroup {
    activateOneTimeAnimation: () => void;
}
declare class WindowState {
    buttonGroupAlignedToSidebar: _angular_core.WritableSignal<AlignedButtonGroup | undefined>;
    focus: _angular_core.WritableSignal<boolean>;
    disableInputs: _angular_core.WritableSignal<boolean>;
    toolbars: _angular_core.WritableSignal<{
        [name: string]: TemplateRef<any>[];
    }>;
    addToolbarContainer(forName: string, template: TemplateRef<any>): void;
    removeToolbarContainer(forName: string, template: TemplateRef<any>): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WindowState, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<WindowState>;
}
declare type __ΩWinHeader = any[];
declare type __ΩWin = any[];
declare type __ΩAlignedButtonGroup = any[];

interface WinSidebar {
    template: TemplateRef<any>;
}
declare class WindowContentComponent {
    private windowState;
    transparent: _angular_core.InputSignalWithTransform<boolean, unknown>;
    sidebarVisible: _angular_core.InputSignal<boolean>;
    class: _angular_core.InputSignal<string>;
    sidebarWidth: _angular_core.ModelSignal<number>;
    sidebarMaxWidth: _angular_core.InputSignal<number>;
    sidebarMinWidth: _angular_core.InputSignal<number>;
    toolbar: _angular_core.WritableSignal<WinSidebar | undefined>;
    sidebar: _angular_core.Signal<ElementRef<any> | undefined>;
    sidebarContainer: _angular_core.Signal<ElementRef<any> | undefined>;
    content: _angular_core.Signal<ElementRef<any> | undefined>;
    withAnimation: _angular_core.WritableSignal<boolean>;
    constructor(windowState: WindowState);
    protected transitionEnded(): void;
    unregisterSidebar(sidebar: WinSidebar): void;
    registerSidebar(sidebar: WinSidebar): void;
    protected handleSidebarVisibility(withAnimation?: boolean): void;
    isSidebarVisible(): boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WindowContentComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WindowContentComponent, "dui-window-content", never, { "transparent": { "alias": "transparent"; "required": false; "isSignal": true; }; "sidebarVisible": { "alias": "sidebarVisible"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; "sidebarWidth": { "alias": "sidebarWidth"; "required": false; "isSignal": true; }; "sidebarMaxWidth": { "alias": "sidebarMaxWidth"; "required": false; "isSignal": true; }; "sidebarMinWidth": { "alias": "sidebarMinWidth"; "required": false; "isSignal": true; }; }, { "sidebarWidth": "sidebarWidthChange"; }, never, ["*"], true, never>;
}
declare type __ΩWinSidebar = any[];

declare class WindowHeaderComponent implements WinHeader {
    windowState: WindowState;
    protected element: ElementRef;
    size: _angular_core.InputSignal<"small" | "default">;
    protected get withToolbar(): number;
    constructor(windowState: WindowState, element: ElementRef);
    getBottomPosition(): number;
    maximize(): void;
    minimize(): void;
    close(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WindowHeaderComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WindowHeaderComponent, "dui-window-header", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}
declare class WindowToolbarComponent implements OnDestroy, OnInit {
    protected windowState: WindowState;
    for: _angular_core.InputSignal<string>;
    template?: TemplateRef<any>;
    constructor(windowState: WindowState);
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WindowToolbarComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WindowToolbarComponent, "dui-window-toolbar", never, { "for": { "alias": "for"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}
declare class WindowToolbarContainerComponent {
    name: _angular_core.InputSignal<string>;
    windowState: WindowState;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WindowToolbarContainerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WindowToolbarContainerComponent, "dui-window-toolbar-container", never, { "name": { "alias": "name"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * This is only for documentation purposes.
 */
declare class WindowFrameComponent {
    height: _angular_core.InputSignal<number>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WindowFrameComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WindowFrameComponent, "dui-window-frame", never, { "height": { "alias": "height"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}
declare class WindowComponent implements OnInit, OnDestroy, Win {
    id: number;
    content: _angular_core.Signal<WindowContentComponent | undefined>;
    header: _angular_core.Signal<WindowHeaderComponent | undefined>;
    closable: _angular_core.InputSignal<boolean>;
    maximizable: _angular_core.InputSignal<boolean>;
    minimizable: _angular_core.InputSignal<boolean>;
    dialog: _angular_core.InputSignal<boolean>;
    normalizeStyle: _angular_core.InputSignalWithTransform<boolean, unknown>;
    protected onBlur: () => void;
    protected onFocus: () => void;
    protected registry: WindowRegistry;
    protected app: DuiApp;
    protected parentWindow: WindowComponent | null;
    protected windowMenuState: WindowMenuState;
    windowState: WindowState;
    viewContainerRef: ViewContainerRef;
    browserWindow: BrowserWindow;
    constructor();
    ngOnInit(): void;
    ngOnDestroy(): void;
    getClosestNonDialogWindow(): WindowComponent | undefined;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WindowComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WindowComponent, "dui-window", never, { "closable": { "alias": "closable"; "required": false; "isSignal": true; }; "maximizable": { "alias": "maximizable"; "required": false; "isSignal": true; }; "minimizable": { "alias": "minimizable"; "required": false; "isSignal": true; }; "dialog": { "alias": "dialog"; "required": false; "isSignal": true; }; "normalizeStyle": { "alias": "normalize-style"; "required": false; "isSignal": true; }; }, {}, ["content", "header"], ["*"], true, never>;
}

declare function injectDocument(): Document | undefined;
declare function injectElementRef(): ElementRef<HTMLElement>;
declare function clamp(value: number, min: number, max: number): number;
declare class OpenExternalDirective implements OnChanges {
    private element;
    openExternal: _angular_core.InputSignal<string>;
    href: _angular_core.InputSignal<string>;
    constructor(element: ElementRef);
    ngOnChanges(): void;
    getLink(): string;
    onClick(event: Event): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OpenExternalDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OpenExternalDirective, "[openExternal], a[href]", never, { "openExternal": { "alias": "openExternal"; "required": false; "isSignal": true; }; "href": { "alias": "href"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
declare function scheduleWindowResizeEvent(): void;
declare class TemplateContextTypeDirective<T> {
    protected templateType: T;
    static ngTemplateContextGuard<T>(dir: TemplateContextTypeDirective<T>, ctx: unknown): ctx is T;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TemplateContextTypeDirective<any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TemplateContextTypeDirective<any>, "ng-template[templateType]", never, { "templateType": { "alias": "templateType"; "required": false; }; }, {}, never, never, true, never>;
}
declare class OnDomCreationDirective implements OnInit, OnDestroy {
    onDomCreation: _angular_core.OutputEmitterRef<Element>;
    onDomCreationDestroy: _angular_core.OutputEmitterRef<Element>;
    private element;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OnDomCreationDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OnDomCreationDirective, "[onDomCreation]", never, {}, { "onDomCreation": "onDomCreation"; "onDomCreationDestroy": "onDomCreationDestroy"; }, never, never, true, never>;
}
type RegisterEventListenerRemove = () => void;
declare function registerEventListener<T extends Element | Document | Window, K extends keyof KeyMap, KeyMap extends GlobalEventHandlersEventMap = T extends Document ? DocumentEventMap : T extends Window ? WindowEventMap : HTMLElementEventMap>(element: T, type: K, listener: (ev: KeyMap[K]) => any, options?: AddEventListenerOptions): RegisterEventListenerRemove;
declare type __ΩRegisterEventListenerRemove = any[];

declare abstract class ActiveComponent {
    abstract active: WritableSignal<boolean>;
    abstract registeredHotkey?: WritableSignal<string>;
    abstract showHotkey?: WritableSignal<boolean>;
    abstract destroy: OutputEmitterRef<void>;
    abstract activate(): void;
}
/**
 * hotkey has format of "ctrl+shift+alt+key", e.g "ctrl+s" or "shift+o"
 * and supports more than one, e.g. "ctrl+s,ctrl+o"
 */
type HotKey = string;
declare function hotKeySize(hotkey: HotKey): number;
declare class ButtonHotkeyComponent implements OnChanges, OnInit {
    hotkey: _angular_core.InputSignal<string>;
    protected isMac: boolean;
    protected metaKey: boolean;
    protected ctrlKey: boolean;
    protected shiftKey: boolean;
    protected altKey: boolean;
    protected key: string;
    ngOnInit(): void;
    ngOnChanges(): void;
    protected parse(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ButtonHotkeyComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ButtonHotkeyComponent, "dui-button-hotkey", never, { "hotkey": { "alias": "hotkey"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
declare class ButtonComponent implements OnInit, ActiveComponent, OnDestroy {
    hotKeySize: typeof hotKeySize;
    destroy: OutputEmitterRef<void>;
    /**
     * The icon for this button. Either a icon name same as for dui-icon, or an image path.
     */
    icon: _angular_core.InputSignal<string | undefined>;
    /**
     * Change in the icon size. Should not be necessary usually.
     */
    iconSize: _angular_core.InputSignal<number | undefined>;
    iconRight: _angular_core.InputSignalWithTransform<boolean, unknown>;
    iconColor: _angular_core.InputSignal<string | undefined>;
    showHotkey: _angular_core.ModelSignal<boolean>;
    registeredHotkey: WritableSignal<string>;
    /**
     * Whether the button is active (pressed)
     */
    active: _angular_core.ModelSignal<boolean>;
    /**
     * Whether the button has no padding and smaller font size
     */
    small: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * Whether the button has smaller padding. Better for button with icons.
     */
    tight: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * Whether the button is highlighted.
     */
    highlighted: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * Whether the button is primary.
     */
    primary: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * Whether the button is focused on initial loading.
     */
    autoFocus: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * The form to submit when this button is clicked.
     */
    submitForm: _angular_core.InputSignal<FormComponent | undefined>;
    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
    square: _angular_core.InputSignalWithTransform<boolean, unknown>;
    textured: _angular_core.InputSignalWithTransform<boolean, unknown>;
    iconOnly: _angular_core.Signal<boolean>;
    protected element: ElementRef<HTMLElement>;
    protected formComponent: FormComponent | null;
    protected routerLinkActive: RouterLinkActive;
    isDisabled: _angular_core.Signal<boolean>;
    constructor();
    ngOnDestroy(): void;
    protected isActive(): boolean;
    activate(): void;
    ngOnInit(): void;
    protected onClick(): Promise<void>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ButtonComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ButtonComponent, "dui-button", never, { "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconSize": { "alias": "iconSize"; "required": false; "isSignal": true; }; "iconRight": { "alias": "icon-right"; "required": false; "isSignal": true; }; "iconColor": { "alias": "iconColor"; "required": false; "isSignal": true; }; "showHotkey": { "alias": "showHotkey"; "required": false; "isSignal": true; }; "active": { "alias": "active"; "required": false; "isSignal": true; }; "small": { "alias": "small"; "required": false; "isSignal": true; }; "tight": { "alias": "tight"; "required": false; "isSignal": true; }; "highlighted": { "alias": "highlighted"; "required": false; "isSignal": true; }; "primary": { "alias": "primary"; "required": false; "isSignal": true; }; "autoFocus": { "alias": "auto-focus"; "required": false; "isSignal": true; }; "submitForm": { "alias": "submitForm"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "square": { "alias": "square"; "required": false; "isSignal": true; }; "textured": { "alias": "textured"; "required": false; "isSignal": true; }; }, { "destroy": "destroy"; "showHotkey": "showHotkeyChange"; "active": "activeChange"; }, never, ["*"], true, [{ directive: typeof i1.RouterLinkActive; inputs: { "routerLinkActiveOptions": "routerLinkActiveOptions"; }; outputs: {}; }]>;
}
declare class HotkeyRegistry implements OnDestroy {
    active: {
        key: HotKey;
        component: ActiveComponent;
    }[];
    protected document: Document;
    protected removeKeyDown?: RegisterEventListenerRemove;
    protected removeKeyUp?: RegisterEventListenerRemove;
    protected knownComponents: Set<ActiveComponent>;
    showHotKeyOn: string;
    constructor();
    activate(component: ActiveComponent): void;
    ngOnDestroy(): void;
    unregister(component: ActiveComponent): void;
    register(key: HotKey, component: ActiveComponent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HotkeyRegistry, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<HotkeyRegistry>;
}
/**
 * Adds a hotkey to a button.
 *
 * ```html
 * <dui-button hotkey="escape">Cancel</dui-button>
 * <dui-button hotkey="cmd+s">Save</dui-button>
 * ```
 */
declare class HotkeyDirective implements OnDestroy {
    hotkey: _angular_core.InputSignal<string>;
    protected oldButtonActive?: boolean;
    protected hotkeyRegistry: HotkeyRegistry;
    protected activeComponent: ActiveComponent | null;
    protected element: ElementRef<HTMLElement>;
    registeredHotkey: WritableSignal<string>;
    active: WritableSignal<boolean>;
    destroy: OutputEmitterRef<void>;
    ngOnDestroy(): void;
    constructor();
    activate(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HotkeyDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HotkeyDirective, "[hotkey]", never, { "hotkey": { "alias": "hotkey"; "required": true; "isSignal": true; }; }, { "destroy": "destroy"; }, never, never, true, never>;
}
/**
 * Used to group buttons together.
 */
declare class ButtonGroupComponent implements AfterViewInit, OnDestroy, AlignedButtonGroup {
    private element;
    protected cd: ChangeDetectorRef;
    private windowState?;
    private windowComponent?;
    /**
     * How the button should behave.
     * `sidebar` means it aligns with the sidebar. Is the sidebar open, this button-group has a left margin.
     * Is it closed, the margin is gone.
     */
    float: _angular_core.InputSignal<"static" | "right" | "sidebar" | "float">;
    /**
     * If set to none, buttons inside this group will be tightly packed together without any padding.
     */
    padding: _angular_core.InputSignal<"none" | "normal">;
    get isPaddingNone(): boolean;
    constructor(element: ElementRef<HTMLElement>, cd: ChangeDetectorRef, windowState?: WindowState | undefined, windowComponent?: WindowComponent | undefined);
    /**
     * @hidden
     */
    activateOneTimeAnimation(): void;
    ngOnDestroy(): void;
    protected transitionEnded(): void;
    ngAfterViewInit(): void;
    protected updatePaddingLeft(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ButtonGroupComponent, [null, { skipSelf: true; }, { optional: true; }, { optional: true; }]>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ButtonGroupComponent, "dui-button-group", never, { "float": { "alias": "float"; "required": false; "isSignal": true; }; "padding": { "alias": "padding"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}
declare class ButtonGroupsComponent {
    align: _angular_core.InputSignal<"center" | "left" | "right">;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ButtonGroupsComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ButtonGroupsComponent, "dui-button-groups", never, { "align": { "alias": "align"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}
/**
 * Directive to open the native file chooser dialog.
 * Can be used wth FormsModule (ngModel).
 *
 * ```html
 * <dui-button duiFileChooser duiFileChooserChange="open($event)">Open File</dui-button>
 * ```
 */
declare class FileChooserDirective extends ValueAccessorBase<File[]> implements OnDestroy, OnChanges {
    duiFileMultiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
    duiFileDirectory: _angular_core.InputSignalWithTransform<boolean, unknown>;
    duiFileChooserChange: OutputEmitterRef<File[]>;
    protected input: HTMLInputElement;
    constructor();
    ngOnDestroy(): void;
    ngOnChanges(): void;
    protected onClick(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FileChooserDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FileChooserDirective, "[duiFileChooser]", never, { "duiFileMultiple": { "alias": "duiFileMultiple"; "required": false; "isSignal": true; }; "duiFileDirectory": { "alias": "duiFileDirectory"; "required": false; "isSignal": true; }; }, { "duiFileChooserChange": "duiFileChooserChange"; }, never, never, true, never>;
}
interface FilePickerItem {
    data: Uint8Array;
    name: string;
    mimeType: string;
}
/**
 * Directive to open the native file picker dialog and return the selected files as Uint8Array.
 * Can be used wth FormsModule (ngModel).
 *
 * ```html
 * <dui-button duiFilePicker duiFilePickerChange="open($event)">Open File</dui-button>
 * ```
 */
declare class FilePickerDirective extends ValueAccessorBase<FilePickerItem[]> implements OnDestroy, AfterViewInit {
    duiFileMultiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
    duiFileAutoOpen: _angular_core.InputSignal<boolean>;
    duiFilePickerChange: OutputEmitterRef<FilePickerItem[]>;
    protected input: HTMLInputElement;
    constructor();
    ngOnDestroy(): void;
    ngAfterViewInit(): void;
    protected onClick(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FilePickerDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FilePickerDirective, "[duiFilePicker]", never, { "duiFileMultiple": { "alias": "duiFileMultiple"; "required": false; "isSignal": true; }; "duiFileAutoOpen": { "alias": "duiFileAutoOpen"; "required": false; "isSignal": true; }; }, { "duiFilePickerChange": "duiFilePickerChange"; }, never, never, true, never>;
}
/**
 * Directive to allow dropping files into an area.
 * Can be used wth FormsModule (ngModel).
 *
 * ```html
 * <div duiFileDrop (duiFileDropChange)="onFilesDropped($event)">
 *     Drop files here
 * </div>
 * ```
 */
declare class FileDropDirective extends ValueAccessorBase<FilePickerItem[]> implements OnDestroy {
    duiFileDropMultiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
    duiFileDropChange: OutputEmitterRef<FilePickerItem[]>;
    i: WritableSignal<number>;
    protected onDragEnter(ev: any): void;
    protected onDragOver(ev: any): void;
    protected onDragLeave(ev: any): void;
    protected onDrop(ev: any): Promise<void>;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FileDropDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FileDropDirective, "[duiFileDrop]", never, { "duiFileDropMultiple": { "alias": "duiFileDropMultiple"; "required": false; "isSignal": true; }; }, { "duiFileDropChange": "duiFileDropChange"; }, never, never, true, never>;
}

declare type __ΩHotKey = any[];
declare type __ΩFilePickerItem = any[];

type PositionObserverDisconnect = () => void;
declare function observePosition(element: Element, callback: (entry: DOMRectReadOnly) => void, debugPosition?: boolean): PositionObserverDisconnect;
declare class PositionChangeDirective implements OnInit, OnDestroy {
    duiPositionChange: _angular_core.OutputEmitterRef<any>;
    elementRef: _angular_core.ElementRef<HTMLElement>;
    observer: PositionObserverDisconnect;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PositionChangeDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PositionChangeDirective, "[duiPositionChange]", never, {}, { "duiPositionChange": "duiPositionChange"; }, never, never, true, never>;
}
declare type __ΩPositionObserverDisconnect = any[];

/**
 * A dropdown component that can be used to display a list of items or content in a popup.
 *
 * It can be opened and closed programmatically or via user interaction.
 *
 * By monitoring the focused elements, it is possible to add interactive elements inside the dropdown.
 */
declare class DropdownComponent implements OnChanges, OnDestroy, AfterViewInit {
    protected overlayService: Overlay;
    protected injector: Injector;
    protected overlayStack: OverlayStack;
    protected viewContainerRef: ViewContainerRef;
    isOpen: _angular_core.WritableSignal<boolean>;
    overlayRef?: OverlayRef;
    protected portalViewRef?: EmbeddedViewRef<any>;
    protected lastFocusWatcher?: ReturnType<typeof focusWatcher>;
    /**
     * If open() is called without a target, the host element is used as the target.
     * THe target elements is allowed to have focus without closing the dropdown.
     */
    host: _angular_core.InputSignal<Element | ElementRef<any> | undefined>;
    /**
     * Additional elements that are allowed to have focus without closing the dropdown.cdk-global-overlay-wrapper
     */
    allowedFocus: _angular_core.InputSignal<Element | ElementRef<any> | (Element | ElementRef<any>)[]>;
    normalizeStyle: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * Keeps the dropdown open when it should be closed, ideal for debugging purposes.
     */
    keepOpen: _angular_core.InputSignal<boolean | undefined>;
    height: _angular_core.InputSignal<string | number | undefined>;
    width: _angular_core.InputSignal<string | number | undefined>;
    minWidth: _angular_core.InputSignal<string | number | undefined>;
    minHeight: _angular_core.InputSignal<string | number | undefined>;
    maxWidth: _angular_core.InputSignal<string | number | undefined>;
    maxHeight: _angular_core.InputSignal<string | number | undefined>;
    /**
     * Whether the dropdown should allow scrollbars.
     */
    scrollbars: _angular_core.InputSignal<boolean>;
    /**
     * Whether the dropdown aligns to the horizontal center.
     */
    center: _angular_core.InputSignal<boolean>;
    dropdownClass: _angular_core.InputSignal<string>;
    /**
     * Whether is styled as overlay
     */
    overlay: _angular_core.InputSignalWithTransform<boolean, unknown>;
    hasBackdrop: _angular_core.InputSignalWithTransform<boolean, unknown>;
    show: _angular_core.InputSignal<boolean | undefined>;
    /**
     * Additional positions to connect the dropdown to the target element.
     */
    connectedPositions: _angular_core.InputSignal<ConnectedPosition[]>;
    /**
     * Triggered when the dropdown is opened or closed.
     */
    showChange: _angular_core.OutputEmitterRef<boolean>;
    /**
     * Triggered when the dropdown is opened.
     */
    shown: _angular_core.OutputEmitterRef<void>;
    /**
     * Triggered when the dropdown is closed.
     */
    hidden: _angular_core.OutputEmitterRef<void>;
    /**
     * Triggered when the dropdown loses focus and is about to close.
     */
    lostFocus: _angular_core.OutputEmitterRef<FocusEvent>;
    dropdownTemplate?: TemplateRef<any>;
    protected dropdown?: ElementRef<HTMLElement>;
    protected container: _angular_core.WritableSignal<TemplateRef<any> | undefined>;
    protected positionObserver?: PositionObserverDisconnect;
    protected relativeToInitiator?: HTMLElement;
    protected lastOverlayStackItem?: OverlayStackItem;
    protected positionStrategy?: PositionStrategy;
    protected templatePortal?: TemplatePortal;
    protected openForElement?: Element;
    protected windowComponent: WindowComponent | null;
    constructor(overlayService: Overlay, injector: Injector, overlayStack: OverlayStack, viewContainerRef: ViewContainerRef);
    ngOnChanges(changes: SimpleChanges): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    protected key(event: KeyboardEvent): void;
    /**
     * Toggles the dropdown open or closed.
     */
    toggle(target?: Element | ElementRef | MouseEvent | EventTarget | 'center' | null): boolean;
    /**
     * Sets the container template for the dropdown.
     */
    setContainer(container: TemplateRef<any> | undefined): void;
    /**
     * Opens the dropdown at the given target element or mouse position.
     */
    open(target?: Element | ElementRef | MouseEvent | EventTarget | 'center' | null, initiator?: HTMLElement | ElementRef | {
        x: number;
        y: number;
        width: number;
        height: number;
    }): void;
    protected watchOpen(overlayRef: OverlayRef, target: Element | ElementRef | MouseEvent | EventTarget | 'center' | null): void;
    protected createPositionStrategy(target: Element | ElementRef | MouseEvent | EventTarget | 'center' | null): PositionStrategy;
    setInitiator(initiator?: HTMLElement | ElementRef | {
        x: number;
        y: number;
        width: number;
        height: number;
    }): void;
    protected getInitiatorRelativeRect(): {
        x: number;
        y: number;
        width: number;
        height: number;
    };
    /**
     * Focuses the dropdown element.
     */
    focus(): void;
    /**
     * Closes the dropdown if it is open.
     */
    close(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DropdownComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DropdownComponent, "dui-dropdown", never, { "host": { "alias": "host"; "required": false; "isSignal": true; }; "allowedFocus": { "alias": "allowedFocus"; "required": false; "isSignal": true; }; "normalizeStyle": { "alias": "normalize-style"; "required": false; "isSignal": true; }; "keepOpen": { "alias": "keepOpen"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "minWidth": { "alias": "minWidth"; "required": false; "isSignal": true; }; "minHeight": { "alias": "minHeight"; "required": false; "isSignal": true; }; "maxWidth": { "alias": "maxWidth"; "required": false; "isSignal": true; }; "maxHeight": { "alias": "maxHeight"; "required": false; "isSignal": true; }; "scrollbars": { "alias": "scrollbars"; "required": false; "isSignal": true; }; "center": { "alias": "center"; "required": false; "isSignal": true; }; "dropdownClass": { "alias": "dropdownClass"; "required": false; "isSignal": true; }; "overlay": { "alias": "overlay"; "required": false; "isSignal": true; }; "hasBackdrop": { "alias": "hasBackdrop"; "required": false; "isSignal": true; }; "show": { "alias": "show"; "required": false; "isSignal": true; }; "connectedPositions": { "alias": "connectedPositions"; "r