@mantic-ui/angular/types/mantic-ui-angular.d.ts

mantic UI for Angular

import * as _angular_core from '@angular/core';
import { OnDestroy, OnInit, ElementRef, Signal, TypeProvider, TemplateRef, EventEmitter, DoCheck, AfterViewInit, Type, EnvironmentProviders, ViewContainerRef, OutputEmitterRef, ComponentRef, InjectionToken, WritableSignal, SimpleChange, PipeTransform } from '@angular/core';
import * as rxjs from 'rxjs';
import { MonoTypeOperatorFunction, Observable, InteropObservable, Subscribable } from 'rxjs';
import { NgIfContext } from '@angular/common';
import { SizeProp, IconProp } from '@fortawesome/fontawesome-svg-core';
import { Title, DomSanitizer, SafeResourceUrl } from '@angular/platform-browser';
import * as _mantic_ui_angular from '@mantic-ui/angular';
import * as _fortawesome_fontawesome_common_types from '@fortawesome/fontawesome-common-types';
import { TitleStrategy, RouterStateSnapshot, ActivatedRoute, DefaultUrlSerializer, UrlTree } from '@angular/router';

type BooleanLike = boolean | '' | 'true' | 'false' | undefined;

declare class SortedClassesService {
    private readonly entries;
    private readonly elementRef;
    /**
     * Registers one or more keys. The keys will only registered if they are not already registered.
     */
    registerFallback(...keys: string[]): SortedClassesService;
    /**
     * Registers one or more keys. If they are already registered, the order will be updated.
     */
    register(...keys: string[]): SortedClassesService;
    registerFixed(...keys: string[]): SortedClassesService;
    unregister(...keys: string[]): SortedClassesService;
    ignore(...keys: string[]): SortedClassesService;
    private registerEntry;
    private getEntry;
    set(key: string, value: unknown, options?: {
        refresh: boolean;
    }): SortedClassesService;
    get(key: string): unknown;
    has(key: string): boolean;
    toString(): string;
    update(): void;
    private updateEntry;
    private static sortByOrder;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SortedClassesService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SortedClassesService>;
}

declare abstract class Destroyable implements OnDestroy {
    private readonly destroySubject;
    /**
     * An observable that emits when the component is destroyed.
     */
    readonly destroy: rxjs.Observable<void>;
    /**
     * Pipe this method to a subject to take values until the component is destroyed.
     * Example: `observable.pipe(this.takeUntilDestroy()).subscribe(...);`
     * Equals to `observable.pipe(takeUntil(this.destroy)).subscribe(...);`.
     */
    takeUntilDestroy<T>(): MonoTypeOperatorFunction<T>;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Destroyable, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<Destroyable>;
}

declare abstract class BaseComponent extends Destroyable implements OnInit {
    protected static readonly providers: (typeof SortedClassesService)[];
    protected readonly classes: SortedClassesService;
    protected readonly elementRef: ElementRef<HTMLElement>;
    private noClassesValue;
    private initialized;
    protected readonly tag: string;
    protected validateAttributes: boolean;
    protected get noClasses(): boolean;
    protected set noClasses(value: boolean);
    protected constructor(useUiClass?: boolean);
    ngOnInit(): void;
    private readPropertiesFromAttributes;
    protected refreshClasses(): void;
    protected toBoolean(value: BooleanLike): boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseComponent, [{ optional: true; }]>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BaseComponent, never, never, {}, {}, never, never, true, never>;
}

interface TransformableModel<TRead, TWrite> extends Signal<TRead> {
    set(value: TWrite): void;
    update(updateFn: (value: TRead) => TRead): void;
    asReadonly(): Signal<TRead>;
}

type ColorName = 'black' | 'grey' | 'red' | 'orange' | 'yellow' | 'olive' | 'green' | 'teal' | 'blue' | 'violet' | 'purple' | 'pink' | 'brown' | 'transparent';

declare abstract class InvertibleComponent extends BaseComponent {
    protected static readonly providers: typeof SortedClassesService[];
    private readonly invertedDefault;
    readonly invertedInput: _angular_core.InputSignalWithTransform<boolean | undefined, BooleanLike>;
    readonly inverted: _angular_core.Signal<boolean>;
    protected constructor(useUiClass?: boolean);
    protected refreshInverted(value: boolean): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InvertibleComponent, [{ optional: true; }]>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<InvertibleComponent, never, never, { "invertedInput": { "alias": "inverted"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare abstract class ButtonBaseComponent extends InvertibleComponent {
    protected static readonly providers: typeof SortedClassesService[];
    readonly primary: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly secondary: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly positive: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly negative: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly size: _angular_core.InputSignal<string>;
    readonly circular: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly attachedLeft: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly attachedTop: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly attachedRight: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly attachedBottom: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly color: _angular_core.InputSignal<ColorName | undefined>;
    readonly basic: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly loading: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly activeInput: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly activeChange: _angular_core.OutputEmitterRef<boolean>;
    readonly active: TransformableModel<boolean, BooleanLike>;
    protected get attached(): boolean;
    protected constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ButtonBaseComponent, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ButtonBaseComponent, never, never, { "primary": { "alias": "primary"; "required": false; "isSignal": true; }; "secondary": { "alias": "secondary"; "required": false; "isSignal": true; }; "positive": { "alias": "positive"; "required": false; "isSignal": true; }; "negative": { "alias": "negative"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "circular": { "alias": "circular"; "required": false; "isSignal": true; }; "attachedLeft": { "alias": "attachedLeft"; "required": false; "isSignal": true; }; "attachedTop": { "alias": "attachedTop"; "required": false; "isSignal": true; }; "attachedRight": { "alias": "attachedRight"; "required": false; "isSignal": true; }; "attachedBottom": { "alias": "attachedBottom"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "basic": { "alias": "basic"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "activeInput": { "alias": "active"; "required": false; "isSignal": true; }; }, { "activeChange": "activeChange"; }, never, never, true, never>;
}

declare abstract class BaseDirective extends Destroyable implements OnInit {
    protected static readonly providers: TypeProvider[];
    protected readonly classes: SortedClassesService;
    protected readonly elementRef: ElementRef<HTMLElement>;
    private noClassesValue;
    private initialized;
    protected tag: string;
    protected validateAttributes: boolean;
    protected get noClasses(): boolean;
    protected set noClasses(value: boolean);
    protected constructor(useUiClass?: boolean);
    ngOnInit(): void;
    private readPropertiesFromAttributes;
    protected refreshClasses(): void;
    protected toBoolean(value: BooleanLike): boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseDirective, [{ optional: true; }]>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BaseDirective, never, never, {}, {}, never, never, true, never>;
}

type AnimationDirection = 'vertical' | 'fade' | undefined;

declare class AnimationComponent extends BaseComponent {
    readonly hidden: _angular_core.InputSignal<boolean>;
    readonly direction: _angular_core.InputSignal<AnimationDirection>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AnimationComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AnimationComponent, "m-animation", never, { "hidden": { "alias": "hidden"; "required": false; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class BreadcrumbComponent extends BaseComponent {
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BreadcrumbComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BreadcrumbComponent, "m-breadcrumb", never, {}, {}, never, never, true, never>;
}

declare class ToggleButtonComponent extends ButtonBaseComponent {
    readonly activeTemplate: _angular_core.Signal<TemplateRef<NgIfContext<boolean>> | null | undefined>;
    get checked(): boolean;
    set checked(value: BooleanLike);
    readonly checkedChange: EventEmitter<boolean>;
    constructor();
    protected toggle(): void;
    protected onKeyDown(event: KeyboardEvent): void;
    check(): void;
    uncheck(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToggleButtonComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ToggleButtonComponent, "m-toggle-button", never, { "checked": { "alias": "checked"; "required": false; }; }, { "checkedChange": "checkedChange"; }, ["activeTemplate"], ["*"], true, never>;
}

declare class ButtonGroupComponent extends BaseComponent {
    readonly attachedLeft: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly attachedTop: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly attachedRight: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly attachedBottom: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly color: _angular_core.InputSignal<ColorName | undefined>;
    protected readonly toggleButtons: _angular_core.Signal<readonly ToggleButtonComponent[]>;
    protected readonly attached: _angular_core.Signal<boolean>;
    constructor();
    private uncheckOthers;
    private keepOneChecked;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ButtonGroupComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ButtonGroupComponent, "m-button-group", never, { "attachedLeft": { "alias": "attachedLeft"; "required": false; "isSignal": true; }; "attachedTop": { "alias": "attachedTop"; "required": false; "isSignal": true; }; "attachedRight": { "alias": "attachedRight"; "required": false; "isSignal": true; }; "attachedBottom": { "alias": "attachedBottom"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; }, {}, ["toggleButtons"], ["*"], true, never>;
}

type LabelPosition = 'left' | 'right' | undefined;

type IconSize = ManticIconSize | SizeProp;
declare type ManticIconSize = 'mini' | 'tiny' | 'small' | 'large' | 'big' | 'huge' | 'massive' | undefined;

type IconType = string | IconProp;

interface LabelOptions {
    position: Signal<LabelPosition>;
}

declare type LabelPointing = 'left' | 'right' | 'top' | 'bottom' | undefined;

declare class LabelComponent extends BaseComponent implements LabelOptions {
    readonly position: _angular_core.InputSignal<LabelPosition>;
    readonly pointing: _angular_core.InputSignal<LabelPointing>;
    readonly horizontal: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly basic: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly color: _angular_core.InputSignal<ColorName | undefined>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LabelComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LabelComponent, "m-label", never, { "position": { "alias": "position"; "required": false; "isSignal": true; }; "pointing": { "alias": "pointing"; "required": false; "isSignal": true; }; "horizontal": { "alias": "horizontal"; "required": false; "isSignal": true; }; "basic": { "alias": "basic"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class ButtonComponent extends ButtonBaseComponent {
    static readonly defaults: {
        inverted: _angular_core.WritableSignal<boolean>;
    };
    readonly animated: _angular_core.Signal<AnimationComponent | undefined>;
    readonly animation: _angular_core.Signal<AnimationDirection>;
    readonly label: _angular_core.Signal<LabelComponent | undefined>;
    readonly labelPosition: _angular_core.Signal<LabelPosition>;
    readonly icon: _angular_core.InputSignal<IconType | undefined>;
    readonly iconSize: _angular_core.InputSignal<IconSize>;
    readonly iconPosition: _angular_core.InputSignal<LabelPosition>;
    readonly social: _angular_core.InputSignal<string | undefined>;
    readonly fluid: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly pointing: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ButtonComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ButtonComponent, "m-button", never, { "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconSize": { "alias": "iconSize"; "required": false; "isSignal": true; }; "iconPosition": { "alias": "iconPosition"; "required": false; "isSignal": true; }; "social": { "alias": "social"; "required": false; "isSignal": true; }; "fluid": { "alias": "fluid"; "required": false; "isSignal": true; }; "pointing": { "alias": "pointing"; "required": false; "isSignal": true; }; }, {}, ["animated", "label"], ["m-animation", "m-label", "*"], true, never>;
}

declare class ButtonDefaultsComponent {
    readonly inverted: _angular_core.InputSignal<boolean | undefined>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ButtonDefaultsComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ButtonDefaultsComponent, "m-button-defaults", never, { "inverted": { "alias": "inverted"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class ButtonDirective extends ButtonBaseComponent {
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ButtonDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ButtonDirective, "[m-button]", never, {}, {}, never, never, true, never>;
}

declare class CardComponent {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CardComponent, "m-card", never, {}, {}, never, ["*"], true, never>;
}

declare class CardGroupComponent {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardGroupComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CardGroupComponent, "m-card-group", never, {}, {}, never, ["*"], true, never>;
}

declare type FieldSize = '' | 'one' | 'two' | 'three' | 'four' | 'five' | 'six' | 'seven' | 'eight' | 'nine' | 'ten' | 'eleven' | 'twelve' | 'thirteen' | 'fourteen' | 'fifteen' | 'sixteen';
declare type ParsableFieldSize = FieldSize | number | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | '10' | '11' | '12' | '13' | '14' | '15' | '16' | undefined;

declare type CellAlign = 'left' | 'right';

declare type CellFloat = 'left' | 'right';

declare class CellComponent extends BaseComponent {
    readonly size: _angular_core.InputSignalWithTransform<FieldSize | undefined, ParsableFieldSize>;
    readonly float: _angular_core.InputSignal<CellFloat | undefined>;
    readonly align: _angular_core.InputSignal<CellAlign | undefined>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CellComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CellComponent, "m-cell", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "float": { "alias": "float"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class CheckboxComponent extends InvertibleComponent {
    static readonly defaults: {
        checkIcon: _angular_core.WritableSignal<IconType>;
        checkIconSize: _angular_core.WritableSignal<IconSize>;
        indeterminateIcon: _angular_core.WritableSignal<IconType>;
        indeterminateIconSize: _angular_core.WritableSignal<IconSize>;
        inverted: _angular_core.WritableSignal<boolean>;
    };
    protected static readonly providers: typeof SortedClassesService[];
    protected readonly defaults: {
        checkIcon: _angular_core.WritableSignal<IconType>;
        checkIconSize: _angular_core.WritableSignal<IconSize>;
        indeterminateIcon: _angular_core.WritableSignal<IconType>;
        indeterminateIconSize: _angular_core.WritableSignal<IconSize>;
        inverted: _angular_core.WritableSignal<boolean>;
    };
    protected readonly checkedState: _angular_core.WritableSignal<boolean | undefined>;
    private readonly indeterminateState;
    readonly valueInput: _angular_core.InputSignalWithTransform<boolean | undefined, BooleanLike>;
    readonly checkedInput: _angular_core.InputSignalWithTransform<boolean | undefined, BooleanLike>;
    readonly indeterminateInput: _angular_core.InputSignalWithTransform<boolean | undefined, BooleanLike>;
    readonly value: _angular_core.Signal<boolean | undefined>;
    readonly checked: _angular_core.Signal<boolean>;
    readonly indeterminate: _angular_core.Signal<boolean>;
    readonly valueChange: _angular_core.OutputEmitterRef<boolean | undefined>;
    readonly checkedChange: _angular_core.OutputEmitterRef<boolean>;
    readonly indeterminateChange: _angular_core.OutputEmitterRef<boolean>;
    readonly readonlyInput: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly readonlyChange: _angular_core.OutputEmitterRef<boolean>;
    readonly readonly: TransformableModel<boolean, BooleanLike>;
    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly disabledChange: _angular_core.OutputEmitterRef<boolean>;
    readonly disabled: TransformableModel<boolean, BooleanLike>;
    readonly name: _angular_core.ModelSignal<string | undefined>;
    readonly label: _angular_core.ModelSignal<string | undefined>;
    readonly canUncheck: _angular_core.ModelSignal<boolean>;
    readonly checkIcon: _angular_core.InputSignal<IconType | undefined>;
    readonly checkIconSize: _angular_core.InputSignal<IconSize>;
    readonly indeterminateIcon: _angular_core.InputSignal<IconType | undefined>;
    readonly indeterminateIconSize: _angular_core.InputSignal<IconSize>;
    readonly fitted: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    constructor();
    protected onClick(event: MouseEvent): void;
    protected onKeyDown(event: KeyboardEvent): void;
    protected set(value: boolean): void;
    protected onChange(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CheckboxComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CheckboxComponent, "m-checkbox", never, { "valueInput": { "alias": "value"; "required": false; "isSignal": true; }; "checkedInput": { "alias": "checked"; "required": false; "isSignal": true; }; "indeterminateInput": { "alias": "indeterminate"; "required": false; "isSignal": true; }; "readonlyInput": { "alias": "readonly"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "canUncheck": { "alias": "canUncheck"; "required": false; "isSignal": true; }; "checkIcon": { "alias": "checkIcon"; "required": false; "isSignal": true; }; "checkIconSize": { "alias": "checkIconSize"; "required": false; "isSignal": true; }; "indeterminateIcon": { "alias": "indeterminateIcon"; "required": false; "isSignal": true; }; "indeterminateIconSize": { "alias": "indeterminateIconSize"; "required": false; "isSignal": true; }; "fitted": { "alias": "fitted"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "checkedChange": "checkedChange"; "indeterminateChange": "indeterminateChange"; "readonlyChange": "readonlyChange"; "disabledChange": "disabledChange"; "name": "nameChange"; "label": "labelChange"; "canUncheck": "canUncheckChange"; }, never, ["*"], true, never>;
}

declare class CheckboxDefaultsComponent implements OnDestroy {
    private readonly previousDropdownIcon;
    private readonly previousDropdownIconSize;
    private readonly previousDeleteIcon;
    private readonly previousDeleteIconSize;
    private currentCheckIcon?;
    private currentCheckIconSize?;
    private currentIndeterminateIcon?;
    private currentIndeterminateIconSize?;
    readonly checkIcon: _angular_core.InputSignal<IconType | undefined>;
    readonly checkIconSize: _angular_core.InputSignal<IconSize>;
    readonly indeterminateIcon: _angular_core.InputSignal<IconType | undefined>;
    readonly indeterminateIconSize: _angular_core.InputSignal<IconSize>;
    readonly inverted: _angular_core.InputSignal<boolean | undefined>;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CheckboxDefaultsComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CheckboxDefaultsComponent, "m-checkbox-defaults", never, { "checkIcon": { "alias": "checkIcon"; "required": false; "isSignal": true; }; "checkIconSize": { "alias": "checkIconSize"; "required": false; "isSignal": true; }; "indeterminateIcon": { "alias": "indeterminateIcon"; "required": false; "isSignal": true; }; "indeterminateIconSize": { "alias": "indeterminateIconSize"; "required": false; "isSignal": true; }; "inverted": { "alias": "inverted"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class IconButtonComponent extends ButtonBaseComponent {
    readonly icon: _angular_core.InputSignal<IconType | undefined>;
    readonly iconSize: _angular_core.InputSignal<IconSize>;
    readonly social: _angular_core.InputSignal<string | undefined>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconButtonComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IconButtonComponent, "m-icon-button", never, { "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconSize": { "alias": "iconSize"; "required": false; "isSignal": true; }; "social": { "alias": "social"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class LabelDropdownComponent extends BaseComponent {
    static readonly defaults: {
        dropdownIcon: _angular_core.WritableSignal<IconType>;
        dropdownIconSize: _angular_core.WritableSignal<IconSize>;
    };
    protected readonly defaults: {
        dropdownIcon: _angular_core.WritableSignal<IconType>;
        dropdownIconSize: _angular_core.WritableSignal<IconSize>;
    };
    readonly isOpen: _angular_core.WritableSignal<boolean>;
    readonly position: _angular_core.InputSignal<LabelPosition>;
    readonly dropdownIcon: _angular_core.InputSignal<IconType | undefined>;
    readonly dropdownIconSize: _angular_core.InputSignal<IconSize>;
    readonly value: _angular_core.ModelSignal<string | undefined>;
    readonly items: _angular_core.InputSignal<string[] | undefined>;
    constructor();
    private readonly onOutsideClickHandler;
    protected onClick(event: MouseEvent): void;
    private close;
    select(value: string): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LabelDropdownComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LabelDropdownComponent, "m-label-dropdown", never, { "position": { "alias": "position"; "required": false; "isSignal": true; }; "dropdownIcon": { "alias": "dropdownIcon"; "required": false; "isSignal": true; }; "dropdownIconSize": { "alias": "dropdownIconSize"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "items": { "alias": "items"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
}

declare abstract class LabeledBaseComponent extends InvertibleComponent {
    protected static readonly providers: typeof SortedClassesService[];
    private readonly labelQuery;
    readonly label: _angular_core.WritableSignal<LabelOptions | undefined>;
    readonly labelDropdown: _angular_core.Signal<LabelDropdownComponent | undefined>;
    protected readonly iconButton: _angular_core.Signal<IconButtonComponent | undefined>;
    protected readonly button: _angular_core.Signal<ButtonComponent | undefined>;
    readonly buttonPosition: _angular_core.InputSignal<"left" | "right">;
    readonly isRight: _angular_core.Signal<boolean>;
    readonly isAction: _angular_core.Signal<boolean>;
    protected constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LabeledBaseComponent, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LabeledBaseComponent, never, never, { "buttonPosition": { "alias": "buttonPosition"; "required": false; "isSignal": true; }; }, {}, ["labelQuery", "labelDropdown", "iconButton", "button"], never, true, never>;
}

declare abstract class InputBaseComponent extends LabeledBaseComponent implements OnDestroy {
    static readonly defaults: {
        inverted: _angular_core.WritableSignal<boolean>;
    };
    protected static readonly providers: typeof SortedClassesService[];
    protected readonly colorForId: string;
    inputElement: ElementRef<HTMLInputElement> | undefined;
    readonly iconPosition: _angular_core.InputSignal<InputIconPosition | undefined>;
    readonly icon: _angular_core.InputSignal<IconType | undefined>;
    readonly iconSize: _angular_core.InputSignal<IconSize>;
    readonly loading: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly fluid: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly focused: _angular_core.WritableSignal<boolean>;
    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly disabledChange: _angular_core.OutputEmitterRef<boolean>;
    readonly disabled: TransformableModel<boolean, BooleanLike>;
    readonly readonlyInput: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly readonlyChange: _angular_core.OutputEmitterRef<boolean>;
    readonly readonly: TransformableModel<boolean, BooleanLike>;
    readonly hasError: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly transparent: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly autofocus: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly placeholder: _angular_core.InputSignal<string | undefined>;
    readonly name: _angular_core.ModelSignal<string | undefined>;
    readonly for: _angular_core.ModelSignal<string | undefined>;
    readonly keyDown: _angular_core.OutputEmitterRef<KeyboardEvent>;
    readonly keyUp: _angular_core.OutputEmitterRef<KeyboardEvent>;
    readonly keyPress: _angular_core.OutputEmitterRef<Event>;
    readonly blur: _angular_core.OutputEmitterRef<FocusEvent>;
    readonly focus: _angular_core.OutputEmitterRef<FocusEvent>;
    readonly focusin: _angular_core.OutputEmitterRef<FocusEvent>;
    readonly focusout: _angular_core.OutputEmitterRef<FocusEvent>;
    protected readonly isColor: _angular_core.WritableSignal<boolean>;
    protected constructor();
    ngOnDestroy(): void;
    protected refreshInput(): void;
    private readonly keyDownEventHandler;
    private readonly keyUpEventHandler;
    private readonly keyPressEventHandler;
    private readonly blurEventHandler;
    private readonly focusEventHandler;
    private readonly focusinEventHandler;
    private readonly focusoutEventHandler;
    protected bindEvents(): void;
    protected unbindEvents(): void;
    protected refreshFocus(): void;
    setFocus(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputBaseComponent, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<InputBaseComponent, never, never, { "iconPosition": { "alias": "iconPosition"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconSize": { "alias": "iconSize"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "fluid": { "alias": "fluid"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonlyInput": { "alias": "readonly"; "required": false; "isSignal": true; }; "hasError": { "alias": "hasError"; "required": false; "isSignal": true; }; "transparent": { "alias": "transparent"; "required": false; "isSignal": true; }; "autofocus": { "alias": "autofocus"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "for": { "alias": "for"; "required": false; "isSignal": true; }; }, { "disabledChange": "disabledChange"; "readonlyChange": "readonlyChange"; "name": "nameChange"; "for": "forChange"; "keyDown": "keyDown"; "keyUp": "keyUp"; "keyPress": "keyPress"; "blur": "blur"; "focus": "focus"; "focusin": "focusin"; "focusout": "focusout"; }, never, never, true, never>;
}

declare type InputIconPosition = 'left' | 'right';
declare type InputType = 'button' | 'checkbox' | 'color' | 'date' | 'datetime-local' | 'email' | 'file' | 'hidden' | 'image' | 'month' | 'number' | 'password' | 'radio' | 'range' | 'reset' | 'search' | 'submit' | 'tel' | 'text' | 'time' | 'urlweek';
declare class InputComponent extends InputBaseComponent {
    protected readonly valueState: _angular_core.WritableSignal<string | undefined>;
    readonly valueInput: _angular_core.InputSignal<string | undefined>;
    readonly textInput: _angular_core.InputSignal<string | undefined>;
    readonly default: _angular_core.InputSignal<string>;
    readonly type: _angular_core.InputSignal<InputType | undefined>;
    readonly maxlength: _angular_core.InputSignal<string | number | undefined>;
    readonly value: _angular_core.Signal<string | undefined>;
    readonly text: _angular_core.Signal<string>;
    readonly valueChange: _angular_core.OutputEmitterRef<string | undefined>;
    readonly textChange: _angular_core.OutputEmitterRef<string>;
    protected set contentInputElement(input: ElementRef<HTMLInputElement>);
    protected set viewInputElement(input: ElementRef<HTMLInputElement>);
    constructor();
    protected setValue(value: string | undefined): void;
    protected onChange(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InputComponent, "m-input", never, { "valueInput": { "alias": "value"; "required": false; "isSignal": true; }; "textInput": { "alias": "text"; "required": false; "isSignal": true; }; "default": { "alias": "default"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "maxlength": { "alias": "maxlength"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "textChange": "textChange"; }, ["contentInputElement"], ["*", "m-label", "m-label-dropdown", "m-button", "m-icon-button"], true, never>;
}

interface ChatOption {
    text: string;
    url?: string;
    action?: string;
    hideUrl?: boolean;
}

interface ChatMessage {
    sender: string;
    text: string;
    grouped?: boolean;
    direction?: 'in' | 'out';
    timestamp?: number;
    options?: ChatOption[];
}

declare class ChatComponent implements DoCheck {
    static readonly defaults: {
        sendIcon: _angular_core.WritableSignal<IconType>;
        sendIconSize: _angular_core.WritableSignal<IconSize>;
    };
    private readonly sendSubject;
    private readonly messagesDiffer;
    protected readonly defaults: {
        sendIcon: _angular_core.WritableSignal<IconType>;
        sendIconSize: _angular_core.WritableSignal<IconSize>;
    };
    readonly messages: _angular_core.InputSignal<ChatMessage[]>;
    message: string | undefined;
    readonly canSend: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly sender: _angular_core.InputSignal<string | undefined>;
    readonly sendIconTemplate: _angular_core.InputSignal<TemplateRef<NgIfContext<boolean>> | null>;
    readonly sendIcon: _angular_core.InputSignal<IconType | undefined>;
    readonly sendIconSize: _angular_core.InputSignal<IconSize>;
    readonly showSendIcon: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly placeholder: _angular_core.InputSignal<string>;
    readonly send: _angular_core.OutputRef<ChatMessage>;
    protected readonly chat: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
    protected readonly input: _angular_core.Signal<InputComponent | undefined>;
    constructor();
    ngDoCheck(): void;
    protected sendMessage(): void;
    protected onKeyDown(event: KeyboardEvent): void;
    private scrollDown;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatComponent, "m-chat", never, { "messages": { "alias": "messages"; "required": false; "isSignal": true; }; "canSend": { "alias": "canSend"; "required": false; "isSignal": true; }; "sender": { "alias": "sender"; "required": false; "isSignal": true; }; "sendIconTemplate": { "alias": "sendIconTemplate"; "required": false; "isSignal": true; }; "sendIcon": { "alias": "sendIcon"; "required": false; "isSignal": true; }; "sendIconSize": { "alias": "sendIconSize"; "required": false; "isSignal": true; }; "showSendIcon": { "alias": "showSendIcon"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, { "send": "send"; }, never, ["*"], true, never>;
}

declare class ChatDefaultsComponent implements OnDestroy {
    private readonly previousSendIcon;
    private readonly previousSendIconSize;
    private currentSendIcon?;
    private currentSendIconSize?;
    readonly sendIcon: _angular_core.InputSignal<IconType | undefined>;
    readonly sendIconSize: _angular_core.InputSignal<IconSize>;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatDefaultsComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatDefaultsComponent, "m-chat-defaults", never, { "sendIcon": { "alias": "sendIcon"; "required": false; "isSignal": true; }; "sendIconSize": { "alias": "sendIconSize"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class ChatMessageComponent {
    readonly message: _angular_core.InputSignal<ChatMessage | undefined>;
    readonly execute: _angular_core.OutputEmitterRef<string>;
    open(url: string): void;
    onExecute(action: string): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatMessageComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatMessageComponent, "m-chat-message", never, { "message": { "alias": "message"; "required": true; "isSignal": true; }; }, { "execute": "execute"; }, never, never, true, never>;
}

declare class CircularProgressComponent extends BaseComponent {
    readonly value: _angular_core.InputSignal<number>;
    readonly min: _angular_core.InputSignal<number>;
    readonly max: _angular_core.InputSignal<number>;
    readonly size: _angular_core.InputSignal<number>;
    readonly strokeWidth: _angular_core.InputSignal<number>;
    readonly centerContent: _angular_core.InputSignal<boolean>;
    readonly success: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly error: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly warning: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly color: _angular_core.InputSignal<ColorName | undefined>;
    protected readonly radius: _angular_core.Signal<number>;
    protected readonly total: _angular_core.Signal<number>;
    protected readonly offset: _angular_core.Signal<number>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CircularProgressComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CircularProgressComponent, "m-circular-progress", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; "isSignal": true; }; "centerContent": { "alias": "centerContent"; "required": false; "isSignal": true; }; "success": { "alias": "success"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "warning": { "alias": "warning"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare type MenuPosition = 'top' | 'left' | 'bottom' | 'right';

declare class MenuComponent extends InvertibleComponent {
    readonly element: _angular_core.ElementRef<HTMLElement>;
    readonly position: _angular_core.InputSignal<MenuPosition | undefined>;
    readonly fixed: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly secondary: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly attached: _angular_core.InputSignal<MenuPosition | undefined>;
    readonly tabular: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly text: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly vertical: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly pointing: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuComponent, "m-menu", never, { "position": { "alias": "position"; "required": false; "isSignal": true; }; "fixed": { "alias": "fixed"; "required": false; "isSignal": true; }; "secondary": { "alias": "secondary"; "required": false; "isSignal": true; }; "attached": { "alias": "attached"; "required": false; "isSignal": true; }; "tabular": { "alias": "tabular"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; "vertical": { "alias": "vertical"; "required": false; "isSignal": true; }; "pointing": { "alias": "pointing"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

interface ContextMenuEvent extends Event {
    contextMenuTarget?: ContextMenuComponent;
}

declare class ContextMenuComponent extends BaseComponent implements AfterViewInit {
    protected readonly menu: _angular_core.Signal<MenuComponent | undefined>;
    readonly left: _angular_core.WritableSignal<number | undefined>;
    readonly top: _angular_core.WritableSignal<number | undefined>;
    readonly isVisible: _angular_core.WritableSignal<boolean>;
    readonly openOnLeftClick: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly openOnRightClick: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly vertical: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly shared: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly margin: _angular_core.InputSignal<number>;
    readonly onclose: _angular_core.OutputEmitterRef<void>;
    readonly onopen: _angular_core.OutputEmitterRef<void>;
    constructor();
    ngAfterViewInit(): void;
    private onParentClick;
    protected onOutsideAction(event: ContextMenuEvent): void;
    private refreshPosition;
    open(left?: number, top?: number): void;
    open(event: MouseEvent): void;
    close(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ContextMenuComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ContextMenuComponent, "m-context-menu", never, { "openOnLeftClick": { "alias": "openOnLeftClick"; "required": false; "isSignal": true; }; "openOnRightClick": { "alias": "openOnRightClick"; "required": false; "isSignal": true; }; "vertical": { "alias": "vertical"; "required": false; "isSignal": true; }; "shared": { "alias": "shared"; "required": false; "isSignal": true; }; "margin": { "alias": "margin"; "required": false; "isSignal": true; }; }, { "onclose": "close"; "onopen": "open"; }, never, ["*"], true, never>;
}

declare class MenuItemComponent extends BaseComponent {
    protected static readonly providers: typeof SortedClassesService[];
    readonly activeInput: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly activeChange: _angular_core.OutputEmitterRef<boolean>;
    readonly active: TransformableModel<boolean, BooleanLike>;
    readonly linkInput: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly linkChange: _angular_core.OutputEmitterRef<boolean>;
    readonly link: TransformableModel<boolean, BooleanLike>;
    constructor(useUiClass?: boolean);
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuItemComponent, [{ optional: true; }]>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuItemComponent, "m-menu-item", never, { "activeInput": { "alias": "active"; "required": false; "isSignal": true; }; "linkInput": { "alias": "link"; "required": false; "isSignal": true; }; }, { "activeChange": "activeChange"; "linkChange": "linkChange"; }, never, ["*"], true, never>;
}

declare class ContextMenuItemComponent extends MenuItemComponent {
    private readonly contextMenu;
    readonly icon: _angular_core.InputSignal<IconType | undefined>;
    readonly iconColor: _angular_core.InputSignal<string | undefined>;
    readonly keepOpen: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    constructor();
    protected onClick(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ContextMenuItemComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ContextMenuItemComponent, "m-context-menu-item", never, { "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconColor": { "alias": "iconColor"; "required": false; "isSignal": true; }; "keepOpen": { "alias": "keepOpen"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class DimmerComponent extends InvertibleComponent implements OnDestroy {
    static readonly defaults: {
        inverted: _angular_core.WritableSignal<boolean>;
    };
    readonly page: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly hideOnClick: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly visibleInput: _angular_core.InputSignalWithTransform<boolean | undefined, BooleanLike>;
    private readonly visibleState;
    readonly visible: _angular_core.Signal<boolean>;
    constructor();
    ngOnDestroy(): void;
    show(): void;
    hide(): void;
    protected onClick(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DimmerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DimmerComponent, "m-dimmer", never, { "page": { "alias": "page"; "required": false; "isSignal": true; }; "hideOnClick": { "alias": "hideOnClick"; "required": false; "isSignal": true; }; "visibleInput": { "alias": "visible"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class DimmerDefaultsComponent {
    readonly inverted: _angular_core.InputSignal<boolean | undefined>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DimmerDefaultsComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DimmerDefaultsComponent, "m-dimmer-defaults", never, { "inverted": { "alias": "inverted"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class DataSourceRequest {
    readonly key: string;
    private readonly subject;
    readonly observable: Observable<Record<string, unknown>[]>;
    constructor(key: string);
    resolve(data: Record<string, unknown>[] | Observable<Record<string, unknown>[]>): void;
}

declare class DataSourceComponent {
    private readonly requestSubject;
    readonly request: _angular_core.OutputRef<DataSourceRequest>;
    get(key: string): Observable<Record<string, unknown>[]>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DataSourceComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DataSourceComponent, "m-data-source", never, {}, { "request": "request"; }, never, never, true, never>;
}

declare class DividerComponent extends BaseComponent {
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DividerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DividerComponent, "m-divider", never, {}, {}, never, ["*"], true, never>;
}

declare class DynamicComponentComponent {
    private readonly viewContainerRef;
    readonly code: _angular_core.InputSignal<string | undefined>;
    readonly data: _angular_core.InputSignal<Record<string, unknown> | undefined>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DynamicComponentComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DynamicComponentComponent, "m-dynamic-component", never, { "code": { "alias": "code"; "required": true; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare function provideDynamicComponent(type: Type<unknown>): EnvironmentProviders;

declare class ComponentParser {
    private static readonly registeredComponents;
    static register<T>(component: Type<T>): void;
    static parse(template: string | undefined, viewContainerRef: ViewContainerRef, data?: Record<string, unknown>): Node[];
    private static parseNode;
    private static applyAttributes;
    private static getInputNames;
}

declare class DropdownItemComponent extends BaseComponent {
    private readonly dropDownSelectionService;
    readonly value: _angular_core.InputSignal<unknown>;
    readonly icon: _angular_core.InputSignal<string | undefined>;
    readonly element: _angular_core.ElementRef<HTMLElement>;
    readonly filteredOutInput: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly filteredOutChange: _angular_core.OutputEmitterRef<boolean>;
    readonly filteredOut: TransformableModel<boolean, BooleanLike>;
    readonly selectedInput: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly selectedChange: _angular_core.OutputEmitterRef<boolean>;
    readonly selected: TransformableModel<boolean, BooleanLike>;
    constructor();
    protected click(event: MouseEvent): void;
    select(value?: boolean): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DropdownItemComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DropdownItemComponent, "m-dropdown-item", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "filteredOutInput": { "alias": "filteredOut"; "required": false; "isSignal": true; }; "selectedInput": { "alias": "selected"; "required": false; "isSignal": true; }; }, { "filteredOutChange": "filteredOutChange"; "selectedChange": "selectedChange"; }, never, ["*"], true, never>;
}

declare class DropdownValue<T = unknown> {
    value: T;
    text?: string | undefined;
    icon?: IconType | undefined;
    iconSize?: IconSize;
    filtered?: boolean;
    constructor(value: T, text?: string | undefined, icon?: IconType | undefined, iconSize?: IconSize);
}

declare class DropdownDefaultsComponent implements OnDestroy {
    private readonly previousDropdownIcon;
    private readonly previousDropdownIconSize;
    private readonly previousDeleteIcon;
    private readonly previousDeleteIconSize;
    private currentDropdownIcon?;
    private currentDropdownIconSize?;
    private currentDeleteIcon?;
    private currentDeleteIconSize?;
    readonly dropdownIcon: _angular_core.InputSignal<IconType | undefined>;
    readonly dropdownIconSize: _angular_core.InputSignal<IconSize>;
    readonly deleteIcon: _angular_core.InputSignal<IconType | undefined>;
    readonly deleteIconSize: _angular_core.InputSignal<IconSize>;
    readonly inverted: _angular_core.InputSignal<boolean | undefined>;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DropdownDefaultsComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDecla