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

mantic UI for Angular

import * as i0 from '@angular/core';
import { OnDestroy, OnInit, ElementRef, TypeProvider, TemplateRef, EventEmitter, QueryList, DoCheck, IterableDiffers, AfterViewInit, Type, EnvironmentProviders, ViewContainerRef, NgZone, ApplicationRef, ComponentRef, InjectionToken, SimpleChange, PipeTransform } from '@angular/core';
import * as rxjs from 'rxjs';
import { MonoTypeOperatorFunction, ReplaySubject, 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 { ActivatedRoute, Router, TitleStrategy, RouterStateSnapshot, DefaultUrlSerializer, UrlTree } from '@angular/router';
import * as _mantic_ui_angular from '@mantic-ui/angular';

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: i0.ɵɵFactoryDeclaration<SortedClassesService, never>;
    static ɵprov: i0.ɵɵ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: i0.ɵɵFactoryDeclaration<Destroyable, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<Destroyable>;
}

declare abstract class BaseComponent extends Destroyable implements OnInit {
    protected static readonly providers: (typeof SortedClassesService)[];
    protected readonly classes: SortedClassesService;
    private noClassesValue;
    private initialized;
    protected readonly elementRef: ElementRef<HTMLElement>;
    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: i0.ɵɵFactoryDeclaration<BaseComponent, [{ optional: true; }]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseComponent, never, never, {}, {}, never, never, true, never>;
}

/**
 * @deprecated Use Destroyable instead
 */
declare abstract class DestroyableComponent extends Destroyable {
    static ɵfac: i0.ɵɵFactoryDeclaration<DestroyableComponent, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DestroyableComponent, never, never, {}, {}, never, never, true, never>;
}

/**
 * @deprecated Use Destroyable instead
 */
declare abstract class DestroyableDirective extends Destroyable {
    static ɵfac: i0.ɵɵFactoryDeclaration<DestroyableDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DestroyableDirective, never, never, {}, {}, never, never, true, never>;
}

declare abstract class InvertibleComponent extends BaseComponent {
    protected static readonly providers: typeof SortedClassesService[];
    private isInverted;
    private isInvertedChanged;
    get inverted(): boolean;
    set inverted(value: BooleanLike);
    protected constructor(useUiClass?: boolean);
    protected refreshInverted(value: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InvertibleComponent, [{ optional: true; }]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<InvertibleComponent, never, never, { "inverted": { "alias": "inverted"; "required": false; }; }, {}, never, never, true, never>;
}

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

declare class ColorDirective {
    static readonly color = "color";
    static readonly default: {
        directive: typeof ColorDirective;
        inputs: string[];
    };
    private readonly classes;
    private colorValue;
    constructor();
    get color(): ColorName | undefined;
    set color(value: ColorName | undefined);
    static ɵfac: i0.ɵɵFactoryDeclaration<ColorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ColorDirective, "[-m-color]", never, { "color": { "alias": "color"; "required": false; }; }, {}, never, never, true, never>;
}

declare class BasicDirective {
    static readonly basic = "basic";
    static readonly default: {
        directive: typeof BasicDirective;
        inputs: string[];
    };
    private readonly classes;
    private isBasic;
    constructor();
    get basic(): boolean;
    set basic(value: BooleanLike);
    static ɵfac: i0.ɵɵFactoryDeclaration<BasicDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BasicDirective, "[-m-basic]", never, { "basic": { "alias": "basic"; "required": false; }; }, {}, never, never, true, never>;
}

declare class InvertedDirective {
    static readonly inverted = "inverted";
    static readonly default: {
        directive: typeof InvertedDirective;
        inputs: string[];
    };
    private readonly classes;
    private isInverted;
    private isInvertedDefault;
    get inverted(): boolean;
    set inverted(value: BooleanLike);
    constructor();
    setInvertedDefault(value: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InvertedDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<InvertedDirective, "[-m-inverted]", never, { "inverted": { "alias": "inverted"; "required": false; }; }, {}, never, never, true, never>;
}

declare class DisabledDirective {
    static readonly disabled = "disabled";
    static readonly default: {
        directive: typeof DisabledDirective;
        inputs: string[];
    };
    private readonly classes;
    private isDisabled;
    constructor();
    get disabled(): boolean;
    set disabled(value: BooleanLike);
    static ɵfac: i0.ɵɵFactoryDeclaration<DisabledDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DisabledDirective, "[-m-disabled]", never, { "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
}

declare class LoadingDirective {
    static readonly loading = "loading";
    static readonly default: {
        directive: typeof LoadingDirective;
        inputs: string[];
    };
    private readonly classes;
    private isLoading;
    constructor();
    get loading(): boolean;
    set loading(value: BooleanLike);
    static ɵfac: i0.ɵɵFactoryDeclaration<LoadingDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LoadingDirective, "[-m-loading]", never, { "loading": { "alias": "loading"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ActiveDirective {
    static readonly active = "active";
    static readonly default: {
        directive: typeof ActiveDirective;
        inputs: string[];
    };
    private readonly classes;
    private isActive;
    constructor();
    get active(): boolean;
    set active(value: BooleanLike);
    static ɵfac: i0.ɵɵFactoryDeclaration<ActiveDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ActiveDirective, "[-m-active]", never, { "active": { "alias": "active"; "required": false; }; }, {}, never, never, true, never>;
}

declare abstract class ButtonBaseComponent extends InvertibleComponent {
    protected static readonly providers: typeof SortedClassesService[];
    private sizeValue;
    private isPrimary;
    private isSecondary;
    private isPositive;
    private isNegative;
    private isCircular;
    private isAttachedLeft;
    private isAttachedTop;
    private isAttachedRight;
    private isAttachedBottom;
    get primary(): boolean;
    set primary(value: BooleanLike);
    get secondary(): boolean;
    set secondary(value: BooleanLike);
    get positive(): boolean;
    set positive(value: BooleanLike);
    get negative(): boolean;
    set negative(value: BooleanLike);
    get size(): string;
    set size(value: string);
    get circular(): boolean;
    set circular(value: BooleanLike);
    get attachedLeft(): boolean;
    set attachedLeft(value: BooleanLike);
    get attachedTop(): boolean;
    set attachedTop(value: BooleanLike);
    get attachedRight(): boolean;
    set attachedRight(value: BooleanLike);
    get attachedBottom(): boolean;
    set attachedBottom(value: BooleanLike);
    protected get attached(): boolean;
    protected readonly button = true;
    protected constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonBaseComponent, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ButtonBaseComponent, never, never, { "primary": { "alias": "primary"; "required": false; }; "secondary": { "alias": "secondary"; "required": false; }; "positive": { "alias": "positive"; "required": false; }; "negative": { "alias": "negative"; "required": false; }; "size": { "alias": "size"; "required": false; }; "circular": { "alias": "circular"; "required": false; }; "attachedLeft": { "alias": "attachedLeft"; "required": false; }; "attachedTop": { "alias": "attachedTop"; "required": false; }; "attachedRight": { "alias": "attachedRight"; "required": false; }; "attachedBottom": { "alias": "attachedBottom"; "required": false; }; }, {}, never, never, true, [{ directive: typeof ColorDirective; inputs: { "color": "color"; }; outputs: {}; }, { directive: typeof BasicDirective; inputs: { "basic": "basic"; }; outputs: {}; }, { directive: typeof InvertedDirective; inputs: { "inverted": "inverted"; }; outputs: {}; }, { directive: typeof DisabledDirective; inputs: { "disabled": "disabled"; }; outputs: {}; }, { directive: typeof LoadingDirective; inputs: { "loading": "loading"; }; outputs: {}; }, { directive: typeof ActiveDirective; inputs: { "active": "active"; }; outputs: {}; }]>;
}

declare abstract class BaseDirective extends Destroyable implements OnInit {
    protected static readonly providers: TypeProvider[];
    protected readonly classes: SortedClassesService;
    private noClassesValue;
    private initialized;
    protected readonly elementRef: ElementRef<HTMLElement>;
    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: i0.ɵɵFactoryDeclaration<BaseDirective, [{ optional: true; }]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseDirective, never, never, {}, {}, never, never, true, never>;
}

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

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

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

declare class ToggleButtonComponent extends ButtonBaseComponent {
    private readonly activeDirective;
    activeTemplate: TemplateRef<NgIfContext<boolean>> | null;
    protected get active(): boolean;
    protected set active(value: BooleanLike);
    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: i0.ɵɵFactoryDeclaration<ToggleButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ToggleButtonComponent, "m-toggle-button", never, { "checked": { "alias": "checked"; "required": false; }; }, { "checkedChange": "checkedChange"; }, ["activeTemplate"], ["*"], true, never>;
}

declare class ButtonGroupComponent extends BaseComponent {
    private toggleButtonsChangeSubscription?;
    private toggleButtonSubscriptions?;
    private toggleButtonsValue?;
    private isAttachedLeft;
    private isAttachedTop;
    private isAttachedRight;
    private isAttachedBottom;
    get attachedLeft(): boolean;
    set attachedLeft(value: BooleanLike);
    get attachedTop(): boolean;
    set attachedTop(value: BooleanLike);
    get attachedRight(): boolean;
    set attachedRight(value: BooleanLike);
    get attachedBottom(): boolean;
    set attachedBottom(value: BooleanLike);
    protected get attached(): boolean;
    protected get toggleButtons(): QueryList<ToggleButtonComponent> | undefined;
    protected set toggleButtons(query: QueryList<ToggleButtonComponent> | undefined);
    constructor();
    private subscribeToggleButtons;
    private uncheckOthers;
    private keepOneChecked;
    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonGroupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ButtonGroupComponent, "m-button-group", never, { "attachedLeft": { "alias": "attachedLeft"; "required": false; }; "attachedTop": { "alias": "attachedTop"; "required": false; }; "attachedRight": { "alias": "attachedRight"; "required": false; }; "attachedBottom": { "alias": "attachedBottom"; "required": false; }; }, {}, ["toggleButtons"], ["*"], true, [{ directive: typeof ColorDirective; inputs: { "color": "color"; }; outputs: {}; }]>;
}

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: LabelPosition;
}

declare type LabelPointing = 'left' | 'right' | 'top' | 'bottom' | undefined;
declare class LabelComponent extends BaseComponent implements LabelOptions {
    private positionValue;
    private pointingValue;
    private isHorizontal;
    get position(): LabelPosition;
    set position(value: LabelPosition);
    get pointing(): LabelPointing;
    set pointing(value: LabelPointing);
    get horizontal(): boolean;
    set horizontal(value: BooleanLike);
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<LabelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LabelComponent, "m-label", never, { "position": { "alias": "position"; "required": false; }; "pointing": { "alias": "pointing"; "required": false; }; "horizontal": { "alias": "horizontal"; "required": false; }; }, {}, never, ["*"], true, [{ directive: typeof BasicDirective; inputs: { "basic": "basic"; }; outputs: {}; }, { directive: typeof ColorDirective; inputs: { "color": "color"; }; outputs: {}; }]>;
}

declare class FluidDirective {
    static readonly fluid = "fluid";
    static readonly default: {
        directive: typeof FluidDirective;
        inputs: string[];
    };
    private readonly classes;
    private isFluid;
    constructor();
    get fluid(): boolean;
    set fluid(value: BooleanLike);
    static ɵfac: i0.ɵɵFactoryDeclaration<FluidDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FluidDirective, "[-m-fluid]", never, { "fluid": { "alias": "fluid"; "required": false; }; }, {}, never, never, true, never>;
}

declare class PointingDirective {
    static readonly pointing = "pointing";
    static readonly default: {
        directive: typeof PointingDirective;
        inputs: string[];
    };
    private readonly classes;
    private isPointing;
    constructor();
    get pointing(): boolean;
    set pointing(value: BooleanLike);
    static ɵfac: i0.ɵɵFactoryDeclaration<PointingDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PointingDirective, "[-m-pointing]", never, { "pointing": { "alias": "pointing"; "required": false; }; }, {}, never, never, true, never>;
}

declare type Pointing = 'left' | 'right' | 'top' | 'bottom' | undefined;
declare class ButtonComponent extends ButtonBaseComponent {
    static readonly defaults: {
        inverted: boolean;
        invertedChange: ReplaySubject<boolean>;
    };
    private readonly basicDirective;
    private readonly colorDirective;
    private animatedField?;
    private labelField?;
    private socialValue?;
    private iconPositionValue;
    private icoValue?;
    protected get basic(): boolean;
    protected get color(): ColorName | undefined;
    get animated(): AnimationComponent | undefined;
    set animated(value: AnimationComponent | undefined);
    get animation(): AnimationDirection;
    get label(): LabelComponent | undefined;
    set label(value: LabelComponent | undefined);
    get labelPosition(): LabelPosition;
    get icon(): IconType | undefined;
    set icon(value: IconType | undefined);
    iconSize: IconSize;
    get iconPosition(): LabelPosition;
    set iconPosition(value: LabelPosition);
    get social(): string | undefined;
    set social(value: string | undefined);
    constructor();
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ButtonComponent, "m-button", never, { "icon": { "alias": "icon"; "required": false; }; "iconSize": { "alias": "iconSize"; "required": false; }; "iconPosition": { "alias": "iconPosition"; "required": false; }; "social": { "alias": "social"; "required": false; }; }, {}, ["animated", "label"], ["m-animation", "m-label", "*"], true, [{ directive: typeof FluidDirective; inputs: { "fluid": "fluid"; }; outputs: {}; }, { directive: typeof PointingDirective; inputs: { "pointing": "pointing"; }; outputs: {}; }]>;
}

declare class ButtonDefaultsComponent {
    set inverted(value: boolean);
    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonDefaultsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ButtonDefaultsComponent, "m-button-defaults", never, { "inverted": { "alias": "inverted"; "required": false; }; }, {}, never, never, true, never>;
}

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

declare class CardGroupComponent {
    protected readonly host = true;
    static ɵfac: i0.ɵɵFactoryDeclaration<CardGroupComponent, never>;
    static ɵcmp: i0.ɵɵ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 CellFloat = 'left' | 'right';
declare type CellAlign = 'left' | 'right';
declare class CellComponent extends BaseComponent {
    private sizeValue?;
    private floatValue?;
    private alignValue?;
    get size(): FieldSize | undefined;
    set size(value: ParsableFieldSize | undefined);
    get float(): CellFloat | undefined;
    set float(value: CellFloat | undefined);
    get align(): CellAlign | undefined;
    set align(value: CellAlign | undefined);
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<CellComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CellComponent, "m-cell", never, { "size": { "alias": "size"; "required": false; }; "float": { "alias": "float"; "required": false; }; "align": { "alias": "align"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ReadOnlyDirective {
    static readonly readonly = "readonly";
    private static readonly readOnly;
    static readonly default: {
        directive: typeof ReadOnlyDirective;
        inputs: string[];
    };
    private readonly classes;
    private isReadonly;
    constructor();
    get readonly(): boolean;
    set readonly(value: BooleanLike);
    static ɵfac: i0.ɵɵFactoryDeclaration<ReadOnlyDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ReadOnlyDirective, "[-m-read-only]", never, { "readonly": { "alias": "readonly"; "required": false; }; }, {}, never, never, true, never>;
}

declare class CheckboxComponent extends InvertibleComponent {
    static readonly defaults: {
        checkIcon: IconType;
        checkIconSize: IconSize;
        indeterminateIcon: IconType;
        indeterminateIconSize: IconSize;
        inverted: boolean;
        invertedChange: ReplaySubject<boolean>;
    };
    protected static readonly providers: typeof SortedClassesService[];
    private readonly readOnlyDirective;
    private readonly disabledDirective;
    private nameValue?;
    private labelValue?;
    private isChecked;
    private isIndeterminate;
    protected readonly defaults: {
        checkIcon: IconType;
        checkIconSize: IconSize;
        indeterminateIcon: IconType;
        indeterminateIconSize: IconSize;
        inverted: boolean;
        invertedChange: ReplaySubject<boolean>;
    };
    get readonly(): boolean;
    set readonly(value: BooleanLike);
    get disabled(): boolean;
    set disabled(value: BooleanLike);
    get value(): boolean | undefined;
    set value(value: BooleanLike);
    get name(): string;
    set name(value: string | undefined);
    get label(): string | undefined;
    set label(value: string | undefined);
    get checked(): boolean;
    set checked(value: BooleanLike);
    readonly valueChange: EventEmitter<boolean | undefined>;
    readonly checkedChange: EventEmitter<boolean>;
    get indeterminate(): boolean;
    set indeterminate(value: BooleanLike);
    readonly indeterminateChange: EventEmitter<boolean | undefined>;
    canUncheck: boolean;
    checkIcon?: IconType;
    checkIconSize?: IconSize;
    indeterminateIcon?: IconType;
    indeterminateIconSize?: IconSize;
    readonly checkbox = true;
    constructor();
    protected onClick(event: MouseEvent): void;
    protected onKeyDown(event: KeyboardEvent): void;
    protected set(value: boolean): void;
    protected onChange(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CheckboxComponent, "m-checkbox", never, { "value": { "alias": "value"; "required": false; }; "name": { "alias": "name"; "required": false; }; "label": { "alias": "label"; "required": false; }; "checked": { "alias": "checked"; "required": false; }; "indeterminate": { "alias": "indeterminate"; "required": false; }; "canUncheck": { "alias": "canUncheck"; "required": false; }; "checkIcon": { "alias": "checkIcon"; "required": false; }; "checkIconSize": { "alias": "checkIconSize"; "required": false; }; "indeterminateIcon": { "alias": "indeterminateIcon"; "required": false; }; "indeterminateIconSize": { "alias": "indeterminateIconSize"; "required": false; }; }, { "valueChange": "valueChange"; "checkedChange": "checkedChange"; "indeterminateChange": "indeterminateChange"; }, never, ["*"], true, [{ directive: typeof DisabledDirective; inputs: { "disabled": "disabled"; }; outputs: {}; }, { directive: typeof ReadOnlyDirective; inputs: { "readonly": "readonly"; }; outputs: {}; }]>;
}

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?;
    set checkIcon(value: IconType);
    set checkIconSize(value: IconSize);
    set indeterminateIcon(value: IconType);
    set indeterminateIconSize(value: IconSize);
    set inverted(value: boolean);
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxDefaultsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CheckboxDefaultsComponent, "m-checkbox-defaults", never, { "checkIcon": { "alias": "checkIcon"; "required": false; }; "checkIconSize": { "alias": "checkIconSize"; "required": false; }; "indeterminateIcon": { "alias": "indeterminateIcon"; "required": false; }; "indeterminateIconSize": { "alias": "indeterminateIconSize"; "required": false; }; "inverted": { "alias": "inverted"; "required": false; }; }, {}, never, never, 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 IconButtonComponent extends ButtonBaseComponent implements OnInit {
    icon: IconType | undefined;
    iconSize: IconSize;
    social: string | undefined;
    constructor();
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<IconButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IconButtonComponent, "m-icon-button", never, { "icon": { "alias": "icon"; "required": false; }; "iconSize": { "alias": "iconSize"; "required": false; }; "social": { "alias": "social"; "required": false; }; }, {}, never, never, true, never>;
}

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

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

declare abstract class InputBaseComponent extends LabeledBaseComponent implements OnDestroy {
    protected readonly colorForId: string;
    static readonly defaults: {
        inverted: boolean;
        invertedChange: ReplaySubject<boolean>;
    };
    protected static readonly providers: typeof SortedClassesService[];
    private iconPositionValue;
    private transparentValue;
    private hasErrorValue;
    private readonlyValue;
    private disabledValue;
    private isAutoFocused;
    inputElement: ElementRef<HTMLInputElement> | undefined;
    get iconPosition(): InputIconPosition | undefined;
    set iconPosition(value: InputIconPosition | undefined);
    icon: IconType | undefined;
    iconSize: IconSize;
    focused: boolean;
    get disabled(): boolean;
    set disabled(value: BooleanLike);
    get readonly(): boolean;
    set readonly(value: BooleanLike);
    get hasError(): boolean;
    set hasError(value: BooleanLike);
    get transparent(): boolean;
    set transparent(value: BooleanLike);
    get autofocus(): boolean;
    set autofocus(value: BooleanLike);
    placeholder: string | undefined;
    name: string | undefined;
    for: string | undefined;
    readonly keyDown: EventEmitter<KeyboardEvent>;
    readonly keyUp: EventEmitter<KeyboardEvent>;
    readonly keyPress: EventEmitter<Event>;
    readonly blur: EventEmitter<FocusEvent>;
    readonly focus: EventEmitter<FocusEvent>;
    readonly focusin: EventEmitter<FocusEvent>;
    readonly focusout: EventEmitter<FocusEvent>;
    protected isColor: 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: i0.ɵɵFactoryDeclaration<InputBaseComponent, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<InputBaseComponent, never, never, { "iconPosition": { "alias": "iconPosition"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "iconSize": { "alias": "iconSize"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "hasError": { "alias": "hasError"; "required": false; }; "transparent": { "alias": "transparent"; "required": false; }; "autofocus": { "alias": "autofocus"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "name": { "alias": "name"; "required": false; }; "for": { "alias": "for"; "required": false; }; }, { "keyDown": "keyDown"; "keyUp": "keyUp"; "keyPress": "keyPress"; "blur": "blur"; "focus": "focus"; "focusin": "focusin"; "focusout": "focusout"; }, never, never, true, [{ directive: typeof LoadingDirective; inputs: { "loading": "loading"; }; outputs: {}; }, { directive: typeof FluidDirective; inputs: { "fluid": "fluid"; }; outputs: {}; }]>;
}

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 {
    private typeValue?;
    value: string | undefined;
    get text(): string;
    set text(value: string | undefined);
    default: string;
    get type(): InputType | undefined;
    set type(value: InputType | undefined);
    maxlength: string | number | undefined;
    readonly valueChange: EventEmitter<string | undefined>;
    readonly textChange: EventEmitter<string>;
    protected set contentInputElement(input: ElementRef<HTMLInputElement>);
    protected set viewInputElement(input: ElementRef<HTMLInputElement>);
    constructor();
    protected onChange(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputComponent, "m-input", never, { "value": { "alias": "value"; "required": false; }; "text": { "alias": "text"; "required": false; }; "default": { "alias": "default"; "required": false; }; "type": { "alias": "type"; "required": false; }; "maxlength": { "alias": "maxlength"; "required": false; }; }, { "valueChange": "valueChange"; "textChange": "textChange"; }, ["contentInputElement"], ["*", "m-label", "m-label-dropdown", "m-button", "m-icon-button"], true, never>;
}

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

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

declare class ChatMessageComponent {
    message: ChatMessage | undefined;
    get in(): boolean;
    get out(): boolean;
    get grouped(): boolean;
    readonly execute: EventEmitter<string>;
    open(url: string): void;
    onExecute(action: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ChatMessageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ChatMessageComponent, "m-chat-message", never, { "message": { "alias": "message"; "required": true; }; }, { "execute": "execute"; }, never, never, true, never>;
}

declare class CircularProgressComponent extends BaseComponent {
    private readonly colorDirective;
    private isSuccess;
    private isWarning;
    private isError;
    value: number;
    min: number;
    max: number;
    size: number;
    strokeWidth: number;
    centerContent: boolean;
    protected readonly host = true;
    get success(): boolean;
    set success(value: BooleanLike);
    get error(): boolean;
    set error(value: BooleanLike);
    get warning(): boolean;
    set warning(value: BooleanLike);
    protected get color(): ColorName | undefined;
    protected get radius(): number;
    protected get total(): number;
    protected get offset(): number;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<CircularProgressComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CircularProgressComponent, "m-circular-progress", never, { "value": { "alias": "value"; "required": true; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "size": { "alias": "size"; "required": false; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; }; "centerContent": { "alias": "centerContent"; "required": false; }; "success": { "alias": "success"; "required": false; }; "error": { "alias": "error"; "required": false; }; "warning": { "alias": "warning"; "required": false; }; }, {}, never, ["*"], true, [{ directive: typeof ColorDirective; inputs: { "color": "color"; }; outputs: {}; }]>;
}

declare type MenuPosition = 'top' | 'left' | 'bottom' | 'right' | undefined;
declare class MenuComponent extends InvertibleComponent {
    private isFixed;
    private positionValue;
    private isSecondary;
    private attachedValue;
    private isTabular;
    private isText;
    private isVertical;
    readonly element: i0.ElementRef<HTMLElement>;
    get position(): MenuPosition;
    set position(value: MenuPosition);
    get fixed(): boolean;
    set fixed(value: BooleanLike);
    get secondary(): boolean;
    set secondary(value: BooleanLike);
    get attached(): MenuPosition;
    set attached(value: MenuPosition);
    get tabular(): boolean;
    set tabular(value: BooleanLike);
    get text(): boolean;
    set text(value: BooleanLike);
    get vertical(): boolean;
    set vertical(value: BooleanLike);
    constructor(parentMenu?: MenuComponent);
    static ɵfac: i0.ɵɵFactoryDeclaration<MenuComponent, [{ optional: true; skipSelf: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MenuComponent, "m-menu", never, { "position": { "alias": "position"; "required": false; }; "fixed": { "alias": "fixed"; "required": false; }; "secondary": { "alias": "secondary"; "required": false; }; "attached": { "alias": "attached"; "required": false; }; "tabular": { "alias": "tabular"; "required": false; }; "text": { "alias": "text"; "required": false; }; "vertical": { "alias": "vertical"; "required": false; }; }, {}, never, ["*"], true, [{ directive: typeof PointingDirective; inputs: { "pointing": "pointing"; }; outputs: {}; }]>;
}

interface ContextMenuEvent extends Event {
    contextMenuTarget?: ContextMenuComponent;
}

declare class ContextMenuComponent extends BaseComponent implements AfterViewInit {
    private isOpenOnLeftClick;
    private isOpenOnRightClick;
    private isVertical;
    private isShared;
    left: number | undefined;
    top: number | undefined;
    isVisible: boolean;
    get openOnLeftClick(): boolean;
    set openOnLeftClick(value: BooleanLike);
    get openOnRightClick(): boolean;
    set openOnRightClick(value: BooleanLike);
    get vertical(): boolean;
    set vertical(value: BooleanLike);
    get shared(): boolean;
    set shared(value: BooleanLike);
    margin: number;
    readonly onclose: EventEmitter<void>;
    readonly onopen: EventEmitter<void>;
    protected menu: MenuComponent | undefined;
    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: i0.ɵɵFactoryDeclaration<ContextMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ContextMenuComponent, "m-context-menu", never, { "openOnLeftClick": { "alias": "openOnLeftClick"; "required": false; }; "openOnRightClick": { "alias": "openOnRightClick"; "required": false; }; "vertical": { "alias": "vertical"; "required": false; }; "shared": { "alias": "shared"; "required": false; }; "margin": { "alias": "margin"; "required": false; }; }, { "onclose": "close"; "onopen": "open"; }, never, ["*"], true, never>;
}

declare class MenuItemComponent extends BaseComponent {
    protected static readonly providers: (typeof SortedClassesService)[];
    protected readonly activeDirective: ActiveDirective;
    private isLink;
    get active(): boolean;
    protected set active(value: BooleanLike);
    get link(): boolean;
    set link(value: BooleanLike);
    readonly activeChange: EventEmitter<boolean>;
    constructor(useUiClass?: boolean);
    static ɵfac: i0.ɵɵFactoryDeclaration<MenuItemComponent, [{ optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MenuItemComponent, "m-menu-item", never, { "link": { "alias": "link"; "required": false; }; }, { "activeChange": "activeChange"; }, never, ["*"], true, [{ directive: typeof ActiveDirective; inputs: { "active": "active"; }; outputs: {}; }]>;
}

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

declare class DimmerComponent extends InvertibleComponent implements OnInit, OnDestroy {
    static readonly defaults: {
        inverted: boolean;
        invertedChange: ReplaySubject<boolean>;
    };
    private visibleValue;
    private isPage;
    private isHideOnClick;
    get page(): boolean;
    set page(value: BooleanLike);
    get hideOnClick(): boolean;
    set hideOnClick(value: BooleanLike);
    get visible(): boolean;
    set visible(value: BooleanLike);
    constructor();
    ngOnInit(): void;
    ngOnDestroy(): void;
    show(): void;
    hide(): void;
    protected onClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DimmerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DimmerComponent, "m-dimmer", never, { "page": { "alias": "page"; "required": false; }; "hideOnClick": { "alias": "hideOnClick"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class DimmerDefaultsComponent {
    set inverted(value: boolean);
    static ɵfac: i0.ɵɵFactoryDeclaration<DimmerDefaultsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DimmerDefaultsComponent, "m-dimmer-defaults", never, { "inverted": { "alias": "inverted"; "required": false; }; }, {}, 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: Observable<DataSourceRequest>;
    get(key: string): Observable<Record<string, unknown>[]>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DataSourceComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DataSourceComponent, "m-data-source", never, {}, { "request": "request"; }, never, never, true, never>;
}

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

declare class DynamicComponentComponent {
    private readonly viewContainerRef;
    private codeValue;
    get code(): string | undefined;
    set code(value: string | undefined);
    data: Record<string, unknown> | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicComponentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicComponentComponent, "m-dynamic-component", never, { "code": { "alias": "code"; "required": true; }; "data": { "alias": "data"; "required": false; }; }, {}, 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 appendTo;
}

declare class DropDownSelectionService {
    private readonly selectedSubject;
    readonly selected: rxjs.Observable<unknown>;
    select(value: unknown): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DropDownSelectionService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DropDownSelectionService>;
}

declare class DropdownItemComponent extends BaseComponent {
    private readonly dropDownSelectionService;
    private isFilteredOut;
    private isSelected;
    value: unknown;
    get filteredOut(): boolean;
    set filteredOut(value: BooleanLike);
    get selected(): boolean;
    set selected(value: BooleanLike);
    icon: string | undefined;
    readonly element: i0.ElementRef<HTMLElement>;
    constructor(dropDownSelectionService: DropDownSelectionService);
    protected click(event: MouseEvent): void;
    select(value?: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DropdownItemComponent, "m-dropdown-item", never, { "value": { "alias": "value"; "required": false; }; "filteredOut": { "alias": "filteredOut"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; }, {}, 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?;
    set dropdownIcon(value: IconType);
    set dropdownIconSize(value: IconSize);
    set deleteIcon(value: IconType);
    set deleteIconSize(value: IconSize);
    set inverted(value: boolean);
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownDefaultsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DropdownDefaultsComponent, "m-dropdown-defaults", never, { "dropdownIcon": { "alias": "dropdownIcon"; "required": false; }; "dropdownIconSize": { "alias": "dropdownIconSize"; "required": false; }; "deleteIcon": { "alias": "deleteIcon"; "required": false; }; "deleteIconSize": { "alias": "deleteIconSize"; "required": false; }; "inverted": { "alias": "inverted"; "required": false; }; }, {}, never, never, true, never>;
}

declare class DropdownComponent extends InvertibleComponent implements OnInit {
    private readonly dropDownSelectionService;
    private readonly zone;
    static readonly defaults: {
        dropdownIcon: IconType;
        dropdownIconSize: IconSize;
        deleteIcon: IconType;
        deleteIconSize: IconSize;
        inverted: boolean;
        invertedChange: ReplaySubject<boolean>;
    };
    private isMultiple;
    private isSearch;
    private isSelectFirst;
    private isAttachedLeft;
    private isAttachedTop;
    private isAttachedRight;
    private isAttachedBottom;
    private isFreeTextAllowed;
    private isUserUpward;
    private isSystemUpward;
    private isDisabled;
    private isReadonly;
    protected readonly defaults: {
        dropdownIcon: IconType;
        dropdownIconSize: IconSize;
        deleteIcon: IconType;
        deleteIconSize: IconSize;
        inverted: boolean;
        invertedChange: ReplaySubject<boolean>;
    };
    protected textElement: ElementRef<HTMLDivElement> | undefined;
    protected menuElement: ElementRef<HTMLDivElement> | undefined;
    protected inputElement: ElementRef<HTMLInputElement> | undefined;
    protected set contentItemComponentsQuery(query: QueryList<DropdownItemComponent>);
    protected set viewItemComponentsQuery(query: QueryList<DropdownItemComponent>);
    get multiple(): boolean;
    set multiple(value: BooleanLike);
    get search(): boolean;
    set search(value: BooleanLike);
    get attachedLeft(): boolean;
    se