API @deepkit/desktop-ui

export class BrowserText {
    constructor(public fontSize: number = , public fontFamily: string = getComputedStyle(document.querySelector() || document.body).fontFamily);
    destroy();
    getDimensions(text: string);
}

@Directive()
export class ValueAccessorBase<T> implements ControlValueAccessor, OnDestroy {
    value;
    disabled;
    valid?: boolean;
    error?: boolean;
    get isDisabled(): boolean;
    get isValid();
    get isError();
    required;
    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);
    /**
     * Set the value from UI code.
     */
    setValue(value: T | undefined);
    /**
     * Call this method to signal Angular's form or other users that this widget has been touched.
     */
    touch();
    registerOnChange(fn: (value: T | undefined) => void);
    registerOnTouched(fn: () => void);
}

@Injectable({ providedIn:  })
export class BrowserWindow {
    constructor(
    @Inject(DOCUMENT)
    private window?: ElectronOrBrowserWindow);
    isElectron();
    getWindow(): ElectronOrBrowserWindow | undefined;
    setVibrancy(vibrancy: string): void;
    addListener(event: string, listener: (...args: any[]) => void): void;
    removeListener(event: string, listener: (...args: any[]) => void): void;
}

@Injectable({ providedIn:  })
export class Electron {
    static getRemote(): any;
    static getIpc(): any;
    static isAvailable(): any;
    static getRemoteOrUndefined(): any;
    static getProcess();
}

export class AsyncEventEmitter<T> extends EventEmitter<T> {
    emit(value?: T): void;
    subscribe(generatorOrNext?: any, error?: any, complete?: any): Subscription;
}

export class ExecutionState {
    running;
    error: string;
    constructor(protected readonly cd: ChangeDetectorRef, protected readonly func: (...args: any[]) => Promise<any> | any);
    async execute(...args: any[]);
}

@Injectable({ providedIn:  })
export class DuiDocument implements OnDestroy {
    document;
    activeElement;
    onFocus;
    constructor();
    ngOnDestroy();
}

@Component({
    selector: , host: {
        ngSkipHydration: , : , : , : , : ,
    }, template: , styleUrl: , imports: [
        DropdownComponent, forwardRef(() => AdaptiveHiddenContainer), DropdownContainerDirective,
    ],
})
export class AdaptiveContainerComponent implements OnInit, AfterViewInit, OnDestroy {
    dropdown;
    /**
     * Per default, the dui-adaptive-container will be made adaptive. Pass an Element or ElementRef to
     * use a different element as the container.
     */
    element;
    /**
     * The class to apply to the dropdown container.
     */
    dropdownClass;
    direction;
    /**
     * Triggers for elements that are now hidden.
     */
    visibilityChange;
    /**
     * Trigger for elements that were hidden and are now shown again.
     */
    showElements;
    hiddenElements;
    /**
     * The elements that are currently hidden, either currently hidden (display: none) or moved to the hidden container.
     */
    hiddenContainer;
    registerHiddenContainer(hiddenContainer: HTMLElement);
    unregisterHiddenContainer(hiddenContainer: HTMLElement);
    update();
    constructor();
    ngOnDestroy();
    ngOnInit();
    ngAfterViewInit();
}

@Directive({
    selector: , standalone: true,
})
export class AdaptiveHiddenContainer implements OnDestroy {
    constructor(private host: ElementRef, private container: AdaptiveContainerComponent);
    ngOnDestroy();
}

@Injectable({ providedIn:  })
export class BetterPendingTasks {
    constructor(private pendingTasks: PendingTasks);
    async run<T>(task: () => Promise<T>): Promise<T>;
    callback<T>(task: () => Promise<T>): () => Promise<T>;
    patchPrototype<T>(prototype: T, methods: (keyof T)[]);
}

@Directive()
export class BaseComponent {
    disabled;
    get isDisabled();
}

@Component({
    selector: , template: , styles: [], host: {
        : ,
    },
})
export class UiComponentComponent extends BaseComponent {
    name;
}

export class OverlayStackItem {
    constructor(public level: number, public host: HTMLElement, public component: any, public close: () => void, protected stack: OverlayStackItem[], public release: () => void);
    getAllAfter(): OverlayStackItem[];
    getPrevious(): OverlayStackItem | undefined;
    isLast(): boolean;
    getAllBefore(): OverlayStackItem[];
}

@Injectable({ providedIn:  })
export class OverlayStack {
    stack: OverlayStackItem[];
    register(host: HTMLElement, component: any, onClose: () => void): OverlayStackItem;
    forEach(callback: (item: OverlayStackItem) => void): void;
    getCurrentLevel();
    getLevel(item: OverlayStackItem): number;
    getForComponent(component: any): OverlayStackItem | undefined;
}

@Injectable({ providedIn:  })
export class Storage {
    getItem(key: string): any;
    setItem(key: string, value: any): void;
    removeItem(key: string): void;
}

@Injectable({ providedIn:  })
export class DuiApp {
    darkMode;
    platform;
    themeDetection: boolean;
    constructor(protected app: ApplicationRef, 
    @Inject(DOCUMENT)
    protected document: Document, rendererFactory: RendererFactory2, protected storage: Storage, 
    @Optional()
    protected windowRegistry?: WindowRegistry, 
    @Optional()
    protected router?: Router);
    start();
    setPlatform(platform:  |  |  | );
    getPlatform(): string;
    isDarkMode(): boolean;
    setAutoDarkMode(): void;
    get theme():  |  | ;
    isDarkModeOverwritten(): boolean;
    setGlobalDarkMode(darkMode: boolean): void;
    getVibrancy():  | ;
    disableThemeDetection();
    setDarkMode(darkMode?: boolean);
}

@Directive({
    selector: ,
})
export class DragDirective {
    duiDragThreshold;
    duiDragAbortOnEscape;
    duiDrag;
    duiDragStart;
    duiDragEnd;
    duiDragCancel;
    constructor();
    ngOnDestroy();
}

@Directive({
    selector: ,
})
export class DuiResponsiveDirective implements OnInit {
    clazz: {
        [className: string]: boolean;
    };
    duiClassMin;
    element;
    ngOnInit();
    onResize();
}

@Directive()
export abstract class MenuBase implements ActiveComponent, OnDestroy {
    destroy;
    label;
    sublabel;
    icon;
    disabled;
    accelerator;
    role;
    hotkey;
    visible;
    onlyMacOs;
    noMacOs;
    id;
    before;
    after;
    beforeGroupContaining;
    afterGroupContaining;
    template;
    registeredHotkey;
    click;
    checkboxStyle;
    type;
    level;
    children;
    active;
    ngOnDestroy();
    buildTemplate(item: BuiltTemplateItem);
    activate();
    constructor();
    validOs(): boolean;
}

@Component({
    selector: , providers: [{ provide: MenuBase, useExisting: forwardRef(() => MenuItemComponent) }], template: , styles: ,
})
export class MenuItemComponent extends MenuBase {
    type;
}

@Component({
    selector: , providers: [{ provide: MenuBase, useExisting: forwardRef(() => MenuDivComponent) }], template: , styles: ,
})
export class MenuDivComponent extends MenuBase {
    type;
}

@Directive({
    selector: , providers: [{ provide: MenuBase, useExisting: forwardRef(() => MenuCheckboxDirective) }],
})
export class MenuCheckboxDirective extends MenuBase {
    checked;
    type;
    buildTemplate(item: BuiltTemplateItem);
}

@Directive({
    selector: , providers: [{ provide: MenuBase, useExisting: forwardRef(() => MenuRadioComponent) }],
})
export class MenuRadioComponent extends MenuBase {
    checked;
    type;
    buildTemplate(item: BuiltTemplateItem);
}

@Directive({
    selector: , providers: [{ provide: MenuBase, useExisting: forwardRef(() => MenuSeparatorComponent) }],
})
export class MenuSeparatorComponent extends MenuBase {
    type;
}

@Directive({
    selector: ,
})
export class MenuRenderDirective implements OnDestroy {
    duiMenuRender;
    template;
    rootAsButton;
    constructor();
    ngOnDestroy();
}

@Directive({
    selector: ,
})
export class MenuItemTemplate {
    static ngTemplateContextGuard(directive: unknown, context: unknown): context is TemplateContext;
}

@Component({
    selector: , host: {
        : ,
    }, template: , styles: , imports: [
        forwardRef(() => AdaptiveContainerComponent), forwardRef(() => AdaptiveHiddenContainer), forwardRef(() => DropdownItemComponent), MenuRenderDirective, MenuItemTemplate, DropdownComponent, DropdownContainerDirective, OpenDropdownDirective, DropdownSplitterComponent, NgTemplateOutlet, ButtonHotkeyComponent, IconComponent, OnDomCreationDirective,
    ],
})
export class MenuComponent implements OnDestroy {
    /**
     * If true, this menu is used for the application menu bar (only works in Electron).
     */
    forApp;
    moreLabel;
    children;
    adaptiveContainer;
    dropdownPositionsRoot: ConnectedPosition[];
    dropdownPositions: ConnectedPosition[];
    registerDropdownItem(item: Element, menu: MenuBase);
    selected(item: MenuBase): boolean;
    constructor();
    activate(item: MenuBase);
    close();
    lostFocus(event: FocusEvent);
    dropdownHidden(dropdown: DropdownComponent, level: number);
    dropdownShown(dropdown: DropdownComponent, level: number);
    ngOnDestroy();
}

@Pipe({ name: , pure: false })
export class AsyncRenderPipe implements OnDestroy, PipeTransform {
    constructor(protected cd: ChangeDetectorRef);
    ngOnDestroy(): void;
    transform<T>(value?: Observable<T> | Promise<T>): T | undefined;
}

@Pipe({ name:  })
export class ObjectURLPipe implements PipeTransform, OnDestroy {
    constructor(private sanitizer: DomSanitizer);
    ngOnDestroy(): void;
    transform(buffer?: ArrayBuffer | ArrayBufferView, mimeType?: string): SafeUrl | undefined;
}

@Pipe({ name:  })
export class HumanFileSizePipe implements PipeTransform {
    transform(bytes: number, si: boolean = false): string;
}

@Directive({
    selector: ,
})
export class PositionChangeDirective implements OnInit, OnDestroy {
    duiPositionChange;
    elementRef;
    observer;
    ngOnInit();
    ngOnDestroy();
}

export class EfficientState {
    call: FilterActions<this> & Excluded;
    constructor(injector?: Injector);
}

@Component({
    selector: , template: , styleUrl: , encapsulation: ViewEncapsulation.None,
})
export class DuiStyleComponent {
    duiApp;
    document;
    /**
     * If true, the body applies the 'dui-normalized' class to normalize all elements.
     */
    normalizeStyle;
    constructor();
}

@Directive({ selector:  })
export class OpenExternalDirective implements OnChanges {
    openExternal;
    href;
    constructor(private element: ElementRef);
    ngOnChanges(): void;
    getLink();
    onClick(event: Event);
}

@Directive({ selector:  })
export class TemplateContextTypeDirective<T> {
    static ngTemplateContextGuard<T>(dir: TemplateContextTypeDirective<T>, ctx: unknown): ctx is T;
}

@Directive({ selector:  })
export class OnDomCreationDirective implements OnInit, OnDestroy {
    onDomCreation;
    onDomCreationDestroy;
    ngOnInit();
    ngOnDestroy();
}

export abstract class ActiveComponent {
    abstract active: WritableSignal<boolean>;
    abstract registeredHotkey?: WritableSignal<string>;
    abstract showHotkey?: WritableSignal<boolean>;
    abstract destroy: OutputEmitterRef<void>;
    abstract activate(): void;
}

@Component({
    selector: , styles: [], template: , imports: [],
})
export class ButtonHotkeyComponent implements OnChanges, OnInit {
    hotkey;
    ngOnInit();
    ngOnChanges();
}

@Component({
    selector: , template: , host: {
        : , : , : , : , : , : , : , : , : , : , : , : , : , : ,
    }, styleUrls: [], hostDirectives: [
        { directive: RouterLinkActive, inputs: [] },
    ], providers: [
        { provide: ActiveComponent, useExisting: forwardRef(() => ButtonComponent) },
    ], imports: [
        IconComponent, ButtonHotkeyComponent,
    ],
})
export class ButtonComponent implements OnInit, ActiveComponent, OnDestroy {
    hotKeySize;
    destroy;
    /**
     * The icon for this button. Either a icon name same as for dui-icon, or an image path.
     */
    icon;
    /**
     * Change in the icon size. Should not be necessary usually.
     */
    iconSize;
    iconRight;
    iconColor;
    showHotkey;
    registeredHotkey;
    /**
     * Whether the button is active (pressed)
     */
    active;
    /**
     * Whether the button has no padding and smaller font size
     */
    small;
    /**
     * Whether the button has smaller padding. Better for button with icons.
     */
    tight;
    /**
     * Whether the button is highlighted.
     */
    highlighted;
    /**
     * Whether the button is primary.
     */
    primary;
    /**
     * Whether the button is focused on initial loading.
     */
    autoFocus;
    /**
     * The form to submit when this button is clicked.
     */
    submitForm;
    disabled;
    square;
    textured;
    iconOnly;
    isDisabled;
    constructor();
    ngOnDestroy();
    activate();
    ngOnInit();
}

@Injectable({ providedIn:  })
export class HotkeyRegistry implements OnDestroy {
    active: {
        key: HotKey;
        component: ActiveComponent;
    }[];
    showHotKeyOn;
    constructor();
    activate(component: ActiveComponent);
    ngOnDestroy();
    unregister(component: ActiveComponent);
    register(key: HotKey, component: ActiveComponent);
}

@Directive({ selector:  })
export class HotkeyDirective implements OnDestroy {
    hotkey;
    registeredHotkey;
    active;
    destroy;
    ngOnDestroy();
    constructor();
    activate();
}

@Component({
    selector: , template: , host: {
        : , : ,
    }, styleUrls: [],
})
export class ButtonGroupComponent implements AfterViewInit, OnDestroy, AlignedButtonGroup {
    /**
     * 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;
    /**
     * If set to none, buttons inside this group will be tightly packed together without any padding.
     */
    padding;
    get isPaddingNone();
    constructor(private element: ElementRef<HTMLElement>, 
    @SkipSelf()
    protected cd: ChangeDetectorRef, 
    @Optional()
    private windowState?: WindowState, 
    @Optional()
    private windowComponent?: WindowComponent);
    /**
     * @hidden
     */
    activateOneTimeAnimation();
    ngOnDestroy(): void;
    ngAfterViewInit(): void;
}

@Component({
    selector: , template: , host: {
        : , : , : ,
    }, styleUrls: [],
})
export class ButtonGroupsComponent {
    align;
}

@Directive({
    selector: , providers: [ngValueAccessor(FileChooserDirective)],
})
export class FileChooserDirective extends ValueAccessorBase<File[]> implements OnDestroy, OnChanges {
    duiFileMultiple;
    duiFileDirectory;
    duiFileChooserChange;
    constructor();
    ngOnDestroy();
    ngOnChanges(): void;
}

@Directive({
    selector: , providers: [ngValueAccessor(FileChooserDirective)],
})
export class FilePickerDirective extends ValueAccessorBase<FilePickerItem[]> implements OnDestroy, AfterViewInit {
    duiFileMultiple;
    duiFileAutoOpen;
    duiFilePickerChange;
    constructor();
    ngOnDestroy();
    ngAfterViewInit();
}

@Directive({
    selector: , host: {
        : ,
    }, providers: [ngValueAccessor(FileChooserDirective)],
})
export class FileDropDirective extends ValueAccessorBase<FilePickerItem[]> implements OnDestroy {
    duiFileDropMultiple;
    duiFileDropChange;
    i;
    ngOnDestroy();
}

@Component({
    selector: , template: , host: {
        : ,
    }, changeDetection: ChangeDetectionStrategy.OnPush, styleUrls: [], imports: [NgTemplateOutlet],
})
export class DropdownComponent implements OnChanges, OnDestroy, AfterViewInit {
    isOpen;
    overlayRef?: OverlayRef;
    /**
     * 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;
    /**
     * Additional elements that are allowed to have focus without closing the dropdown.cdk-global-overlay-wrapper
     */
    allowedFocus;
    normalizeStyle;
    /**
     * Keeps the dropdown open when it should be closed, ideal for debugging purposes.
     */
    keepOpen;
    height;
    width;
    minWidth;
    minHeight;
    maxWidth;
    maxHeight;
    /**
     * Whether the dropdown should allow scrollbars.
     */
    scrollbars;
    /**
     * Whether the dropdown aligns to the horizontal center.
     */
    center;
    dropdownClass;
    /**
     * Whether is styled as overlay
     */
    overlay;
    hasBackdrop;
    show;
    /**
     * Additional positions to connect the dropdown to the target element.
     */
    connectedPositions;
    /**
     * Triggered when the dropdown is opened or closed.
     */
    showChange;
    /**
     * Triggered when the dropdown is opened.
     */
    shown;
    /**
     * Triggered when the dropdown is closed.
     */
    hidden;
    /**
     * Triggered when the dropdown loses focus and is about to close.
     */
    lostFocus;
    dropdownTemplate?: TemplateRef<any>;
    constructor(protected overlayService: Overlay, protected injector: Injector, protected overlayStack: OverlayStack, protected viewContainerRef: ViewContainerRef);
    ngOnChanges(changes: SimpleChanges): void;
    ngAfterViewInit();
    ngOnDestroy(): void;
    /**
     * Toggles the dropdown open or closed.
     */
    toggle(target?: Element | ElementRef | MouseEvent | EventTarget |  | null): boolean;
    /**
     * Sets the container template for the dropdown.
     */
    setContainer(container: TemplateRef<any> | undefined);
    /**
     * Opens the dropdown at the given target element or mouse position.
     */
    open(target?: Element | ElementRef | MouseEvent | EventTarget |  | null, initiator?: HTMLElement | ElementRef | {
        x: number;
        y: number;
        width: number;
        height: number;
    });
    setInitiator(initiator?: HTMLElement | ElementRef | {
        x: number;
        y: number;
        width: number;
        height: number;
    });
    /**
     * Focuses the dropdown element.
     */
    focus();
    /**
     * Closes the dropdown if it is open.
     */
    close();
}

@Directive({ selector:  })
export class OpenDropdownDirective implements AfterViewInit, OnDestroy {
    openDropdown;
    openDropdownHover;
    openSub?: OutputRefSubscription;
    hiddenSub?: OutputRefSubscription;
    activeComponent;
    ngAfterViewInit();
    ngOnDestroy();
}

@Directive({ selector:  })
export class OpenDropdownHoverDirective implements OnDestroy {
    openDropdownHover;
    /**
     * In milliseconds.
     */
    openDropdownHoverCloseTimeout;
    constructor(protected elementRef: ElementRef);
    ngOnDestroy();
}

@Directive({ selector:  })
export class ContextDropdownDirective {
    contextDropdown;
}

@Component({
    selector: , template: , host: {
        : ,
    }, styles: [],
})
export class DropdownSplitterComponent {
}

@Directive({ selector:  })
export class DropdownContainerDirective {
    constructor(protected dropdown: DropdownComponent, public template: TemplateRef<any>);
}

@Component({
    selector: , template: , host: {
        : , : , : , : , : , : ,
    }, styleUrls: [], providers: [
        { provide: ActiveComponent, useExisting: forwardRef(() => DropdownItemComponent) },
    ], imports: [IconComponent],
})
export class DropdownItemComponent implements ActiveComponent, OnDestroy {
    selected;
    /**
     * Whether the button is active (pressed)
     */
    active;
    destroy;
    disabled;
    /**
     * When set to true, the item is optimised to display left-aligned checkboxes next to the text.
     */
    checkbox;
    closeOnClick;
    activate();
    ngOnDestroy();
}

@Component({
    selector: , template: , host: {
        : , : ,
    }, styleUrls: [], hostDirectives: [
        { directive: RouterLinkActive, inputs: [] },
    ], providers: [ngValueAccessor(TabButtonComponent)],
})
export class TabButtonComponent extends ValueAccessorBase<any> {
    /**
     * Whether the button is active (pressed).
     *
     * Use alternatively form API, e.g. <dui-tab-button [(ngModel)]="chosen" value="overview"></dui-tab-button>
     */
    active;
    routerLinkActive;
}

@Component({
    selector: , template: , styleUrls: [], providers: [ngValueAccessor(CheckboxComponent)], changeDetection: ChangeDetectionStrategy.OnPush, imports: [IconComponent], host: {
        : ,
    },
})
export class CheckboxComponent extends ValueAccessorBase<boolean> {
    constructor();
}

@Directive({ selector:  })
export class RenderComponentDirective implements AfterViewInit, OnDestroy {
    renderComponent;
    renderComponentInputs;
    component?: ComponentRef<any>;
    constructor(protected viewContainerRef: ViewContainerRef);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
}

@Component({
    template: , imports: [DialogActionsComponent, ButtonComponent, HotkeyDirective, CloseDialogDirective],
})
export class DuiDialogConfirm {
    title;
    content;
    static dialogDefaults;
}

@Component({
    template: , imports: [DialogActionsComponent, ButtonComponent, HotkeyDirective, CloseDialogDirective],
})
export class DuiDialogAlert {
    title;
    content;
    static dialogDefaults;
}

@Component({
    template: , imports: [InputComponent, FormsModule, DialogActionsComponent, ButtonComponent, HotkeyDirective, CloseDialogDirective],
})
export class DuiDialogPrompt {
    title;
    content;
    value;
    static dialogDefaults;
    constructor(public dialog: DialogComponent);
}

@Injectable({ providedIn:  })
export class DuiDialog {
    constructor(protected resolver: ComponentFactoryResolver, protected app: ApplicationRef, protected injector: Injector, protected registry: WindowRegistry, protected overlay: Overlay);
    open<T>(component: Type<T>, inputs: {
        [name in keyof T]?: any;
    } = {}, dialogInputs: Inputs<DialogComponent> = {}, viewContainerRef: ViewContainerRef | null = null): {
        dialog: DialogComponent;
        close: Promise<any>;
        component: T;
    };
    async alert(title: string, content: string = , inputs: {
        [name: string]: any;
    } = {}): Promise<boolean>;
    async confirm(title: string, content: string = , inputs: {
        [name: string]: any;
    } = {}): Promise<boolean>;
    async prompt(title: string, value: string, content?: string, inputs: {
        [name: string]: any;
    } = {}): Promise<false | string>;
}

@Directive({ selector:  })
export class DuiDialogConfirmDirective implements OnDestroy {
    /**
     * The confirm message to show when the user clicks on the element.
     *
     * Use `Title\nText` to specify a title and text, separated by a newline.
     */
    confirm;
    constructor(protected element: ElementRef<HTMLElement>, protected dialog: DuiDialog, 
    @Inject(DOCUMENT)
    protected document: any);
    ngOnDestroy();
}

@Component({
    template: , host: {
        : ,
    }, styleUrls: [], imports: [WindowComponent, WindowContentComponent, RenderComponentDirective, NgTemplateOutlet],
})
export class DialogWrapperComponent {
    component;
    componentInputs;
    actions;
    container;
    content;
    class;
    normalizeStyle;
    renderComponentDirective?: RenderComponentDirective;
    windowComponent;
    setActions(actions: TemplateRef<any> | undefined);
    setDialogContainer(container: TemplateRef<any> | undefined);
}

@Component({
    selector: , template: , styles: [],
})
export class DialogComponent implements AfterViewInit, OnDestroy, OnChanges {
    title;
    visible;
    class;
    noPadding;
    minWidth;
    minHeight;
    width;
    height;
    maxWidth;
    maxHeight;
    center;
    backDropCloses;
    normalizeStyle;
    component;
    componentInputs;
    closed;
    open;
    template?: TemplateRef<any>;
    actions?: TemplateRef<any> | undefined;
    container?: TemplateRef<any> | undefined;
    overlayRef?: OverlayRef;
    wrapperComponentRef?: ComponentRef<DialogWrapperComponent>;
    constructor(protected applicationRef: ApplicationRef, protected overlayStack: OverlayStack, protected viewContainerRef: ViewContainerRef, protected overlay: Overlay, protected injector: Injector, protected registry: WindowRegistry, 
    @Optional()
    protected window?: WindowComponent);
    toPromise(): Promise<any>;
    setDialogContainer(container: TemplateRef<any> | undefined);
    setActions(actions: TemplateRef<any> | undefined);
    ngOnChanges(changes: SimpleChanges): void;
    show();
    ngAfterViewInit();
    close(v?: any);
    ngOnDestroy(): void;
}

@Directive({ selector:  })
export class DialogDirective {
    constructor(protected dialog: DialogComponent, public template: TemplateRef<any>);
}

@Component({
    selector: , template: ,
})
export class DialogActionsComponent implements AfterViewInit, OnDestroy {
    template: TemplateRef<any>;
    constructor(protected dialog: DialogComponent);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
}

@Component({
    selector: , template: , styleUrls: [],
})
export class DialogErrorComponent {
}

@Directive({ selector:  })
export class CloseDialogDirective {
    closeDialog;
    constructor(protected dialog: DialogComponent);
}

@Directive({ selector:  })
export class OpenDialogDirective implements AfterViewInit, OnChanges, OnDestroy {
    openDialog;
    openSub?: Subscription;
    hiddenSub?: Subscription;
    constructor(protected elementRef: ElementRef, 
    @Optional()
    protected button?: ButtonComponent);
    ngOnDestroy();
    ngOnChanges();
    ngAfterViewInit();
}

@Injectable({ providedIn:  })
export class FilesystemState {
    uploadQueue;
    pendingQueue;
    upload;
    addUpload(file: FileQueueEntry);
    cleanQueue();
    checkNext();
}

@Injectable()
export abstract class FilesystemFileCache implements OnDestroy {
    constructor();
    ngOnDestroy();
    clean();
    nextQueue();
    connect(api: FilesystemApi, path: string): CacheData;
}

@Injectable()
export class FilesystemFileDataCache extends FilesystemFileCache {
}

@Injectable()
export class FilesystemFileQuickLookCache extends FilesystemFileCache {
}

@Injectable()
export class FilesystemFileThumbnailCache extends FilesystemFileCache {
}

@Component({
    selector: , template: , styleUrl: , host: {
        : ,
    }, providers: [
        FilesystemFileDataCache, FilesystemFileQuickLookCache, FilesystemFileThumbnailCache,
    ], imports: [
        DropdownComponent, DropdownItemComponent, FilePickerDirective, DropdownSplitterComponent, ButtonGroupsComponent, ButtonGroupComponent, ButtonComponent, InputComponent, FormsModule, FilesystemFileQuickLook, FileDropDirective, ContextDropdownDirective, IconComponent, FilesystemFileDetail, TableComponent, TableColumnDirective, TableCellDirective, HumanFileSizePipe, forwardRef(() => FilesystemFileThumbnail), DatePipe, DropdownContainerDirective, MenuComponent, MenuItemComponent, MenuCheckboxDirective, MenuSeparatorComponent,
    ],
})
export class FilesystemComponent implements OnInit, OnDestroy {
    mimeTypeToLabel;
    api;
    dialogMode;
    selectMultiple;
    path;
    media;
    files;
    sort;
    view;
    selected;
    renameFile;
    containerElementRef;
    loading;
    filesSelected;
    filesSorted;
    activeFile;
    quickLook?: DropdownComponent;
    thumbnails?: QueryList<FilesystemFileThumbnail>;
    element;
    dialog;
    state;
    intersectionObserver?: IntersectionObserver;
    constructor();
    registerThumbnail(thumbnail: FilesystemFileThumbnail);
    unregisterThumbnail(thumbnail: FilesystemFileThumbnail);
    tableSelect(selected: FilesystemApiFile[]);
    sortBy(by: string);
    sortDirection(direction:  | );
    toggleFolderFirst();
    async fileRenamed(newName?: string);
    keyDown(event: KeyboardEvent);
    openQuickLook();
    async openPublic(path: string);
    open(path: string, andSelect = false);
    goUp();
    closeQuickLook();
    async deleteSelected();
    selectBackground(event: MouseEvent);
    select(file: FilesystemApiFile);
    ngOnDestroy();
    upload(files: FilePickerItem[]);
    getFolder();
    async createFolder();
    ngOnInit();
    async load(andSelect = false);
    async loadActiveFolder();
    async loadFolder(dir: string);
}

@Component({
    selector: , standalone: true, template: , styles: [], imports: [
        AsyncPipe, ButtonComponent, IndicatorComponent,
    ],
})
export class FileUploaderComponent {
    truncateFileName;
    filesToUpload;
    currentIndex;
    constructor(public state: FilesystemState);
    cancel();
}

@Component({
    selector: , template: , styleUrl: , imports: [
        ObjectURLPipe, IndicatorComponent, ObjectURLPipe, LoadingSpinnerComponent,
    ],
})
export class FilesystemFileDetail implements OnDestroy {
    api;
    file;
    data;
    filesystemFileCache;
    cacheData;
    constructor();
    ngOnDestroy();
}

@Component({
    selector: , template: , styleUrl: , host: {
        : ,
    }, imports: [
        ButtonGroupsComponent, ButtonGroupComponent, IconComponent, ObjectURLPipe, DatePipe, LoadingSpinnerComponent, HumanFileSizePipe, LoadingSpinnerComponent, HumanFileSizePipe, AsyncPipe, IndicatorComponent,
    ],
})
export class FilesystemFileQuickLook implements OnDestroy {
    fileName;
    mimeTypeToLabel;
    api;
    files;
    close;
    file;
    filesystemFileCache;
    cacheData;
    dim;
    constructor();
    ngOnDestroy();
    next();
    prev();
    onClose($event: KeyboardEvent);
    select(file: FilesystemApiFile);
}

@Component({
    selector: , template: , host: {
        : , : ,
    }, styleUrl: , imports: [
        LoadingSpinnerComponent, FormsModule, ObjectURLPipe,
    ],
})
export class FilesystemFileThumbnail implements OnDestroy {
    truncateFileName;
    fileName;
    loading;
    loadingFailed;
    thumbnailCache;
    cacheData;
    newName;
    view:  | ;
    api;
    file;
    withTitle;
    selected;
    rename;
    intersection;
    select;
    renamed;
    image;
    elementRef;
    setNewName(name: string);
    constructor(
    @Inject(forwardRef(() => FilesystemComponent))
    private filesystemComponent: FilesystemComponent);
    ngOnDestroy();
    loaded(error: boolean = false);
    doRename(name: string | undefined, event?: Event);
    onContextMenu();
    selectFile();
}

@Component({
    styles: [], imports: [
        FilesystemComponent, ButtonGroupComponent, ButtonComponent, CloseDialogDirective,
    ], template: ,
})
export class FilesystemFileDialog {
    static dialogDefaults;
    selected;
    activeFile?: FilesystemApiFile;
    api;
    dialog;
    choose();
}

@Component({
    selector: , template: , host: {
        : ,
    }, styleUrls: [], imports: [KeyValuePipe],
})
export class FormRowComponent {
    label;
    description;
    labelWidth;
    left;
    ngControl?: NgControl;
    isString(v: any);
}

@Component({
    selector: , template: , styleUrls: [], imports: [FormsModule, ReactiveFormsModule],
})
export class FormComponent {
    formGroup;
    disabled;
    submit;
    success;
    error;
    errorText;
    submitting;
    constructor(protected cd: ChangeDetectorRef, 
    @SkipSelf()
    protected cdParent: ChangeDetectorRef);
    onEnter(event: KeyboardEvent);
    get invalid();
    async submitForm();
}

@Component({
    selector: , template: , host: {
        : , : , : , : , : ,
    }, styleUrls: [],
})
export class IconComponent implements OnInit, OnChanges {
    /**
     * The icon for this button.
     */
    name;
    /**
     * The icon size (default 17). Should not be necessary usually.
     */
    size;
    /**
     * Enables interactive style for this icon.
     */
    clickable;
    /**
     * The color of the icon. If not set, it will use `currentColor` by default.
     */
    color;
    /**
     * If true, the icon will be disabled and not clickable.
     */
    disabled;
    get isClickable();
    get isDisabled();
    constructor();
    ngOnChanges(): void;
    ngOnInit();
}

@Component({
    selector: , template: , styleUrls: []
})
export class IndicatorComponent {
    step;
}

@Component({
    selector: , styles: [], template: , imports: [IndicatorComponent, DecimalPipe, DialogActionsComponent, ButtonComponent, DialogActionsComponent, ButtonComponent],
})
export class ProgressIndicatorComponent implements OnChanges, OnDestroy {
    title;
    description;
    progressTracker;
    display;
    step: number;
    sub?: Subscription;
    constructor(private cd: ChangeDetectorRef);
    ngOnChanges(): void;
    ngOnDestroy(): void;
}

@Component({
    selector: , styles: [], template: 
})
export class LoadingSpinnerComponent {
}

@Component({
    selector: , template: , styleUrls: [], host: {
        : , : , : , : , : , : , : , : , : , : , : ,
    }, providers: [ngValueAccessor(InputComponent)], imports: [IconComponent, FormsModule],
})
export class InputComponent extends ValueAccessorBase<any> implements AfterViewInit {
    type;
    step;
    placeholder;
    name;
    icon;
    min;
    max;
    maxLength;
    minLength;
    iconSize;
    /**
     * Focuses this element once created (AfterViewInit).
     */
    autoFocus;
    /**
     * Uses a more decent focus border.
     */
    lightFocus;
    /**
     * Disables input controls (like for type=number the arrow buttons)
     */
    noControls;
    /**
     * Appears a little bit transparent. Perfect for blurry background.
     */
    semiTransparent;
    esc;
    enter;
    keydown;
    keyup;
    blur;
    focus;
    input;
    textured;
    readonly;
    isFocused;
    round;
    clearer;
    constructor();
    clear();
    setValue(value: any | undefined);
    focusInput();
    ngAfterViewInit();
}

@Component({
    selector: , template: , styles: []
})
export class LabelComponent {
    label;
}

@Component({
    selector: , template: , styles: [], host: {
        : 
    }
})
export class LabelGridComponent {
    labelWidth;
    labelMaxWidth;
}

@Component({
    selector: , template: , host: {
        : 
    }, styleUrls: []
})
export class SectionHeaderComponent {
    center;
}

@Component({
    selector: , template: , styleUrls: [],
})
export class ListTitleComponent {
    constructor();
}

@Component({
    selector: , template: , styleUrls: [], host: {
        : , : , : , : ,
    }, providers: [ngValueAccessor(ListComponent)],
})
export class ListComponent extends ValueAccessorBase<any> {
    static ids: number;
    id;
    white;
    focusable;
    delimiterLine;
    /**
     * @hidden
     */
    deregister(item: ListItemComponent);
    /**
     * @hidden
     */
    register(item: ListItemComponent);
    getSelectedItem(): ListItemComponent | undefined;
}

@Component({
    selector: , template: , host: {
        : , : , : ,
    }, styleUrls: [], hostDirectives: [
        { directive: RouterLinkActive, inputs: [] },
    ],
})
export class ListItemComponent implements OnDestroy {
    id;
    value;
    active;
    /**
     * When position is dynamic, it might be handy to define the position
     * explicitly to make arrow-up/arrow-down navigation possible.
     */
    position;
    onSelect;
    constructor();
    ngOnDestroy(): void;
    async select();
    isSelected(): boolean;
}

@Component({
    selector: , providers: [ngValueAccessor(RadioGroupComponent)], template: ,
})
export class RadioGroupComponent extends ValueAccessorBase<any> {
}

@Component({
    selector: , template: , host: {
        : , : , : ,
    }, styleUrls: [],
})
export class RadioButtonComponent {
    value;
    disabled;
    group;
}

@Directive({ selector:  })
export class DynamicOptionDirective {
    constructor(public template: TemplateRef<any>);
}

@Component({
    selector: , template: ,
})
export class OptionDirective {
    value;
    disabled;
    dynamic?: DynamicOptionDirective;
    constructor(public element: ElementRef);
}

@Directive({
    selector: , providers: [{ provide: OptionDirective, useExisting: OptionSeparatorDirective }],
})
export class OptionSeparatorDirective {
    constructor();
}

@Component({
    selector: , template: , styleUrls: [], host: {
        : , : , : , : ,
    }, providers: [ngValueAccessor(SelectBoxComponent)], imports: [
        ButtonGroupComponent, ButtonComponent, OpenDropdownDirective, NgTemplateOutlet, IconComponent, DropdownComponent, DropdownSplitterComponent, DropdownItemComponent,
    ],
})
export class SelectBoxComponent<T> extends ValueAccessorBase<T> implements OnDestroy {
    placeholder;
    /**
     * Different textured styled.
     */
    textured;
    /**
     * Smaller text and height.
     */
    small;
    button;
    options;
    dropdown;
    label: string;
    optionsValueMap;
    element;
    constructor();
    select(value: T);
    open();
}

@Component({
    selector: , template: , styleUrls: [], host: {
        : , : , : , : , : , : , : , : , : , : , : ,
    }, hostDirectives: [
        {
            directive: DragDirective, inputs: [], outputs: [, , , ],
        },
    ],
})
export class SplitterComponent {
    /**
     * When set, the splitter will show an indicator (handle) to indicate that it can be dragged.
     */
    indicator;
    size;
    inverted;
    /**
     * If set one of these, the splitter will be positioned absolutely in the layout.
     * Make sure to set a parent element with `position: relative;` to allow absolute positioning.
     */
    position;
    orientation;
    /**
     * Per default splitter is vertical (movement left-to-right), meaning vertical line.
     * If set to true, it will be horizontal (movement top-to-bottom).
     */
    horizontal;
    min;
    max;
    element;
    /**
     * When element is set, this CSS property will be used to set the size of the splitter.
     * Default is 'flex-basis', which is typically used in flexbox layouts.
     */
    property;
    isHorizontal;
    constructor();
}

@Directive({ selector:  })
export class TableCellDirective {
    constructor(public template: TemplateRef<any>);
}

@Directive({ selector:  })
export class TableCustomHeaderContextMenuDirective {
    constructor(public dropdown: DropdownComponent);
}

@Directive({ selector:  })
export class TableCustomRowContextMenuDirective {
    constructor(public dropdown: DropdownComponent);
}

@Directive({ selector:  })
export class TableHeaderDirective {
    constructor(public template: TemplateRef<any>);
}

@Directive({ selector:  })
export class TableColumnDirective implements OnInit {
    /**
     * The name of the column. Needs to be unique. If no renderer (*duiTableCell) is specified, this
     * name is used to render the content T[name].
     *
     * This supports dot notation, so you can use `user.name` to access the `name` property of the `user` object.
     */
    name;
    /**
     * A different header name. Use dui-table-header to render HTML there.
     */
    header;
    /**
     * Default width.
     */
    width;
    effectiveWidth;
    /**
     * Adds additional class to the columns cells.
     */
    class;
    /**
     * Whether this column is start hidden. User can unhide it using the context menu on the header.
     */
    hidden;
    effectiveHidden;
    sortable;
    hideable;
    /**
     * At which position this column will be placed.
     */
    position;
    /**
     * This is the new position when the user moved it manually.
     * @hidden
     */
    effectivePosition;
    cell;
    headerDirective;
    ngOnInit();
    getHidden(): boolean;
    toggleHidden();
    /**
     * @hidden
     */
    getWidth(): number;
    /**
     * @hidden
     */
    getPosition();
}

@Component({
    selector: , changeDetection: ChangeDetectionStrategy.OnPush, template: , styleUrls: [], host: {
        : , : , : , : , : , : ,
    }, imports: [
        DropdownComponent_1, DropdownContainerDirective, DropdownItemComponent, NgTemplateOutlet, DropdownSplitterComponent, ContextDropdownDirective, IconComponent, SplitterComponent, CdkVirtualScrollViewport, CdkFixedSizeVirtualScroll, CdkVirtualForOf, DragDirective,
    ],
})
export class TableComponent<T> implements AfterViewInit, OnInit, OnDestroy {
    /**
     * @hidden
     */
    tabindex;
    borderless;
    /**
     * Array of items that should be used for each row.
     */
    items;
    /**
     * Since dui-table has virtual-scroll active per default, it's required to define the itemHeight to
     * make scrolling actually workable correctly.
     */
    itemHeight;
    /**
     * Whether the table height just prints all rows, or if virtual scrolling is enabled.
     * If true, the row height depends on the content.
     */
    virtualScrolling;
    /**
     * Whether the table row should have a hover effect.
     */
    hover;
    /**
     * Whether the header should be shown.
     */
    showHeader;
    /**
     * How many columns (from the left) are frozen (stay visible even if user scrolls horizontally).
     */
    freezeColumns;
    /**
     * Default field of T for sorting.
     */
    defaultSort;
    /**
     * Default sorting order.
     */
    defaultSortDirection;
    /**
     * Whether rows are selectable.
     */
    selectable;
    /**
     * Whether multiple rows are selectable at the same time.
     */
    multiSelect;
    /**
     * TrackFn for ngFor to improve performance. Default is order by index.
     */
    trackFn;
    /**
     * Filter function.
     */
    filter;
    rowClass;
    cellClass;
    /**
     * When the user changes the order or width of the columns, the information is stored
     * in localStorage using this key, prefixed with `@dui/table/`.
     */
    preferenceKey;
    /**
     * Filter query.
     */
    filterQuery;
    /**
     * Against which fields filterQuery should run.
     */
    filterFields;
    /**
     * Alternate object value fetcher, important for sorting and filtering.
     */
    valueFetcher;
    /**
     * A hook to provide custom sorting behavior for certain columns.
     */
    sortFunction;
    /**
     * Whether sorting is enabled (clicking headers trigger sort).
     */
    sorting;
    noFocusOutline;
    /**
     * Allow text selection in the table.
     */
    textSelection;
    sort;
    sorted;
    /**
     * Elements that are selected, by reference.
     */
    selected;
    cellSelect;
    /**
     * When a row gets double-clicked.
     */
    rowDblClick;
    cellClick;
    cellDblClick;
    columnDefs;
    sortedColumns;
    sortedFilteredColumns;
    element;
    constructor();
    ngOnInit();
    ngOnDestroy(): void;
    filterSorted;
    onHeadDragStart(event: DuiDragStartEvent, index: number);
    onHeadDrag(event: DuiDragEvent);
    onHeadDragEnd(event: DuiDragEvent);
    ngAfterViewInit(): void;
    select(item: T, $event?: MouseEvent);
}

@Component({
    selector: , template: , host: {
        : ,
    }, styleUrls: [], imports: [IconComponent],
})
export class TabComponent {
    active;
    removable;
    close;
}

@Component({
    selector: , template: , styleUrls: []
})
export class TabsComponent {
}

@Component({
    selector: , template: , host: {
        : , : , : ,
    }, hostDirectives: [
        {
            directive: DragDirective, inputs: [], outputs: [, , , ],
        },
    ], styleUrls: [], providers: [ngValueAccessor(SliderComponent)],
})
export class SliderComponent extends ValueAccessorBase<number> {
    /**
     * The minimum value of the slider.
     */
    min;
    /**
     * The maximum value of the slider.
     */
    max;
    /**
     * The step size for the slider. The value will be rounded to the nearest step.
     */
    steps;
    /**
     * How many fractional digits to display.
     */
    fractionalDigits;
    /**
     * If true, the slider will be displayed in a compact form.
     */
    mini;
    writeValue(value?: number);
}

@Component({
    template: , host: {
        : ,
    }, imports: [
        RenderComponentDirective, NgTemplateOutlet,
    ],
})
export class ExternalDialogWrapperComponent {
    component;
    componentInputs;
    actions?: TemplateRef<any> | undefined;
    container?: TemplateRef<any> | undefined;
    content?: TemplateRef<any> | undefined;
    renderComponentDirective?: RenderComponentDirective;
    constructor(protected cd: ChangeDetectorRef, public injector: Injector);
    setDialogContainer(container: TemplateRef<any> | undefined);
}

@Component({
    selector: , template: ,
})
export class ExternalWindowComponent implements AfterViewInit, OnDestroy, OnChanges {
    alwaysRaised;
    visible;
    closed;
    component;
    componentInputs;
    wrapperComponentRef?: ComponentRef<ExternalDialogWrapperComponent>;
    template?: TemplateRef<any>;
    externalWindow?: Window;
    container?: TemplateRef<any> | undefined;
    observerStyles?: MutationObserver;
    observerClass?: MutationObserver;
    parentFocusSub?: Subscription;
    electronWindow?: any;
    parentWindow?: WindowComponent;
    constructor(protected componentFactoryResolver: ComponentFactoryResolver, protected applicationRef: ApplicationRef, protected injector: Injector, protected dialog: DuiDialog, protected registry: WindowRegistry, protected cd: ChangeDetectorRef, protected viewContainerRef: ViewContainerRef);
    ngOnChanges(changes: SimpleChanges): void;
    setDialogContainer(container: TemplateRef<any> | undefined);
    show();
    beforeUnload();
    ngAfterViewInit();
    close();
    ngOnDestroy(): void;
}