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();
    private toggle;
    private onKeyDown;
    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;
    private onClick;
    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 {
    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: {}; }]>;
}

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;
    private onOutsideAction;
    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);
    private onClick;
    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;
    private onClick;
    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);
    private click;
    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;
    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);
    placeholder: string | undefined;
    get value(): unknown;
    set value(value: unknown);
    filter: string | undefined;
    animationDuration: number;
    get items(): DropdownValue[] | undefined;
    set items(value: DropdownValue[] | null | undefined);
    name?: string;
    filterValue: boolean;
    filterText: boolean;
    icon: IconType | undefined;
    iconSize: IconSize;
    dropdownIcon: IconType | undefined;
    dropdownIconSize: IconSize;
    deleteIcon: IconType | undefined;
    deleteIconSize: IconSize;
    filterType: 'startsWith' | 'contains';
    get selectFirst(): boolean;
    set selectFirst(value: BooleanLike);
    get allowFreeText(): boolean;
    set allowFreeText(value: BooleanLike);
    get tabIndex(): number;
    get searchClass(): boolean;
    isActive: boolean;
    get upwards(): boolean;
    set upwards(value: BooleanLike);
    set disabled(value: BooleanLike);
    get readonly(): boolean;
    set readonly(value: BooleanLike);
    get isUpwardClass(): boolean;
    isDefault: boolean;
    isMenuVisible: boolean;
    isHidden: boolean;
    isSlidingIn: boolean;
    isSlidingOut: boolean;
    isFiltered: boolean;
    isLoading: boolean;
    selectedIndex: number | undefined;
    selectedItem: DropdownValue | undefined;
    selectedItems: DropdownValue[];
    private isFocused;
    private keepOpen;
    private itemComponents;
    private valueField;
    private itemsField;
    get hasItems(): boolean;
    readonly valueChange: EventEmitter<any>;
    constructor(dropDownSelectionService: DropDownSelectionService, zone: NgZone);
    ngOnInit(): void;
    focus(): void;
    blur(): void;
    toggle(): void;
    protected onKeyDown(event: KeyboardEvent): void;
    protected deleteClick(item: DropdownValue, event: MouseEvent): void;
    open(): void;
    close(): void;
    protected select(value: unknown): void;
    protected deselect(item: DropdownValue): void;
    protected selectIndex(index: number): void;
    protected onFilter(): void;
    private isItemFilteredOut;
    private refreshItems;
    protected itemMouseDown(item: DropdownValue): void;
    protected itemMouseUp(item: DropdownValue): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DropdownComponent, "m-dropdown", never, { "multiple": { "alias": "multiple"; "required": false; }; "search": { "alias": "search"; "required": false; }; "attachedLeft": { "alias": "attachedLeft"; "required": false; }; "attachedTop": { "alias": "attachedTop"; "required": false; }; "attachedRight": { "alias": "attachedRight"; "required": false; }; "attachedBottom": { "alias": "attachedBottom"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "value": { "alias": "value"; "required": false; }; "filter": { "alias": "filter"; "required": false; }; "animationDuration": { "alias": "animationDuration"; "required": false; }; "items": { "alias": "items"; "required": false; }; "name": { "alias": "name"; "required": false; }; "filterValue": { "alias": "filterValue"; "required": false; }; "filterText": { "alias": "filterText"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "iconSize": { "alias": "iconSize"; "required": false; }; "dropdownIcon": { "alias": "dropdownIcon"; "required": false; }; "dropdownIconSize": { "alias": "dropdownIconSize"; "required": false; }; "deleteIcon": { "alias": "deleteIcon"; "required": false; }; "deleteIconSize": { "alias": "deleteIconSize"; "required": false; }; "filterType": { "alias": "filterType"; "required": false; }; "selectFirst": { "alias": "selectFirst"; "required": false; }; "allowFreeText": { "alias": "allowFreeText"; "required": false; }; "upwards": { "alias": "upwards"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; }, { "valueChange": "valueChange"; }, ["contentItemComponentsQuery"], ["*"], true, [{ directive: typeof FluidDirective; inputs: { "fluid": "fluid"; }; outputs: {}; }, { directive: typeof DisabledDirective; inputs: { "disabled": "disabled"; }; outputs: {}; }]>;
}

declare class DropdownGroupComponent implements AfterViewInit {
    private readonly viewContainerRef;
    label: string | undefined;
    icon: IconType | undefined;
    iconSize: IconSize;
    protected contentTemplate: TemplateRef<unknown> | undefined;
    constructor(viewContainerRef: ViewContainerRef);
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownGroupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DropdownGroupComponent, "m-dropdown-group", never, { "label": { "alias": "label"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "iconSize": { "alias": "iconSize"; "required": false; }; }, {}, never, ["*"], true, never>;
}

/**
 * @deprecated Use Route.title instead
 */
declare class DocumentTitleComponent implements DoCheck, OnDestroy {
    private readonly element;
    private readonly titleService;
    static globalPostfix: string;
    static globalPrefix: string;
    private previousTitle;
    private value;
    private title;
    get postfix(): string;
    set postfix(value: string);
    get prefix(): string;
    set prefix(value: string);
    constructor(element: ElementRef<HTMLElement>, titleService: Title);
    ngDoCheck(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DocumentTitleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DocumentTitleComponent, "m-document-title", never, { "postfix": { "alias": "postfix"; "required": false; }; "prefix": { "alias": "prefix"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class DocumentNoIndexComponent implements OnInit, OnDestroy {
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DocumentNoIndexComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DocumentNoIndexComponent, "m-document-no-index", never, {}, {}, never, never, true, never>;
}

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

declare class ErrorComponent extends InvertibleComponent {
    constructor();
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ErrorComponent, "m-error", never, {}, {}, never, ["*"], true, [{ directive: typeof IgnoredDirective; inputs: { "ignored": "ignored"; }; outputs: {}; }]>;
}

declare class ExpanderHeaderComponent {
    template: TemplateRef<NgIfContext<boolean>> | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<ExpanderHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ExpanderHeaderComponent, "m-expander-header", never, {}, {}, never, ["*"], true, never>;
}

declare class ExpanderComponent extends BaseComponent {
    static readonly defaults: {
        dropdownIcon: IconType;
        dropdownIconSize: IconSize;
    };
    private isExpanded;
    private isBasic;
    protected readonly defaults: {
        dropdownIcon: IconType;
        dropdownIconSize: IconSize;
    };
    header: string | undefined;
    get expanded(): boolean;
    set expanded(value: BooleanLike);
    dropdownIcon: IconType | undefined;
    dropdownIconSize: IconSize;
    get basic(): boolean;
    set basic(value: BooleanLike);
    iconPosition: 'left' | 'right';
    protected headerTemplate: ExpanderHeaderComponent | undefined;
    constructor();
    toggle(): void;
    collapse(): void;
    expand(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ExpanderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ExpanderComponent, "m-expander", never, { "header": { "alias": "header"; "required": false; }; "expanded": { "alias": "expanded"; "required": false; }; "dropdownIcon": { "alias": "dropdownIcon"; "required": false; }; "dropdownIconSize": { "alias": "dropdownIconSize"; "required": false; }; "basic": { "alias": "basic"; "required": false; }; "iconPosition": { "alias": "iconPosition"; "required": false; }; }, {}, ["headerTemplate"], ["*"], true, never>;
}

declare class ExpanderDefaultsComponent implements OnDestroy {
    private readonly previousDropdownIcon;
    private readonly previousDropdownIconSize;
    private currentDropdownIcon?;
    private currentDropdownIconSize?;
    set dropdownIcon(value: IconType);
    set dropdownIconSize(value: IconSize);
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ExpanderDefaultsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ExpanderDefaultsComponent, "m-expander-defaults", never, { "dropdownIcon": { "alias": "dropdownIcon"; "required": false; }; "dropdownIconSize": { "alias": "dropdownIconSize"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ExpanderIconComponent extends BaseComponent {
    private isExpanded;
    protected readonly defaults: {
        dropdownIcon: IconType;
        dropdownIconSize: IconSize;
    };
    get expanded(): boolean;
    set expanded(value: BooleanLike);
    dropdownIcon: IconType | undefined;
    dropdownIconSize: IconSize;
    readonly expandedChange: EventEmitter<boolean>;
    constructor();
    toggle(): void;
    collapse(): void;
    expand(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ExpanderIconComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ExpanderIconComponent, "m-expander-icon", never, { "expanded": { "alias": "expanded"; "required": false; }; "dropdownIcon": { "alias": "dropdownIcon"; "required": false; }; "dropdownIconSize": { "alias": "dropdownIconSize"; "required": false; }; }, { "expandedChange": "expandedChange"; }, never, never, true, never>;
}

declare class ExpanderPartComponent extends BaseComponent {
    private isExpanded;
    expandable: boolean | undefined;
    get expanded(): boolean;
    set expanded(value: BooleanLike);
    dropdownIcon: IconType | undefined;
    dropdownIconSize: IconSize;
    readonly expandedChange: EventEmitter<boolean>;
    protected icon: ExpanderIconComponent | undefined;
    constructor();
    private onClick;
    static ɵfac: i0.ɵɵFactoryDeclaration<ExpanderPartComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ExpanderPartComponent, "m-expander-part", never, { "expandable": { "alias": "expandable"; "required": false; }; "expanded": { "alias": "expanded"; "required": false; }; "dropdownIcon": { "alias": "dropdownIcon"; "required": false; }; "dropdownIconSize": { "alias": "dropdownIconSize"; "required": false; }; }, { "expandedChange": "expandedChange"; }, never, ["*"], true, never>;
}

declare class FlagComponent {
    flag: string | undefined;
    size: IconSize;
    static ɵfac: i0.ɵɵFactoryDeclaration<FlagComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FlagComponent, "m-flag", never, { "flag": { "alias": "flag"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, {}, never, never, true, never>;
}

interface FormError$1 {
    message: string;
    label: string;
}

interface FormValidation {
    label?: string;
    message: string | undefined;
    valid: boolean;
    value: unknown;
}
declare function isFormValidation(value: unknown): value is FormValidation;

declare class DateInputComponent extends InputBaseComponent implements OnInit {
    private valueField;
    private showDayValue;
    protected internalValue: string | null;
    get value(): Date | undefined;
    set value(value: Date | number | string | undefined);
    get date(): Date;
    set date(value: Date | number | string | undefined);
    default: Date;
    min: Date | undefined;
    max: Date | undefined;
    get showDay(): boolean;
    set showDay(value: BooleanLike);
    weekendColor: ColorName | undefined;
    readonly valueChange: EventEmitter<Date | undefined>;
    readonly dateChange: EventEmitter<Date>;
    protected set contentInputElement(input: ElementRef<HTMLInputElement>);
    protected set viewInputElement(input: ElementRef<HTMLInputElement>);
    constructor();
    ngOnInit(): void;
    protected onInternalChange(rawValue: string): void;
    private setInternalValue;
    static ɵfac: i0.ɵɵFactoryDeclaration<DateInputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DateInputComponent, "m-date-input", never, { "value": { "alias": "value"; "required": false; }; "date": { "alias": "date"; "required": false; }; "default": { "alias": "default"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "showDay": { "alias": "showDay"; "required": false; }; "weekendColor": { "alias": "weekendColor"; "required": false; }; }, { "valueChange": "valueChange"; "dateChange": "dateChange"; }, ["contentInputElement"], ["*", "m-label", "m-label-dropdown", "m-button", "m-icon-button"], true, never>;
}

declare class NumericInputComponent extends InputBaseComponent implements OnInit {
    private valueField;
    private rangeValue;
    protected internalValue: number | null;
    type: 'number' | 'range';
    default: number;
    min: number | undefined;
    max: number | undefined;
    zeroText: string | undefined;
    protected get placeholderInternal(): string;
    get value(): number | undefined;
    set value(value: number | undefined);
    get number(): number;
    set number(value: number | undefined);
    get range(): boolean;
    set range(value: BooleanLike);
    readonly valueChange: EventEmitter<number | undefined>;
    readonly numberChange: EventEmitter<number>;
    protected set contentInputElement(input: ElementRef<HTMLInputElement>);
    protected set viewInputElement(input: ElementRef<HTMLInputElement>);
    constructor();
    ngOnInit(): void;
    protected onInternalChange(rawValue: string | null | undefined): void;
    private setInternalValue;
    static ɵfac: i0.ɵɵFactoryDeclaration<NumericInputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NumericInputComponent, "m-numeric-input", never, { "default": { "alias": "default"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "zeroText": { "alias": "zeroText"; "required": false; }; "value": { "alias": "value"; "required": false; }; "number": { "alias": "number"; "required": false; }; "range": { "alias": "range"; "required": false; }; }, { "valueChange": "valueChange"; "numberChange": "numberChange"; }, ["contentInputElement"], ["*", "m-label", "m-label-dropdown", "m-button", "m-icon-button"], true, never>;
}

interface RadioCheckEvent {
    group: string;
    value: unknown;
}

declare class RadioService {
    private readonly checkedSubject;
    readonly checked: rxjs.Observable<RadioCheckEvent>;
    check(group: string, value: unknown): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RadioService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RadioService>;
}

declare class RadioComponent extends CheckboxComponent {
    private readonly radioService;
    constructor(radioService: RadioService);
    static ɵfac: i0.ɵɵFactoryDeclaration<RadioComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RadioComponent, "m-radio", never, {}, {}, never, ["*"], true, never>;
}

declare class SliderComponent extends CheckboxComponent {
    private readonly radioService;
    constructor(radioService: RadioService);
    static ɵfac: i0.ɵɵFactoryDeclaration<SliderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SliderComponent, "m-slider", never, {}, {}, never, ["*"], true, never>;
}

declare class TextareaComponent extends InvertibleComponent {
    private readonly applicationRef;
    static readonly defaults: {
        inverted: boolean;
        invertedChange: ReplaySubject<boolean>;
    };
    private readonlyValue;
    private disabledValue;
    textareaElement?: ElementRef<HTMLTextAreaElement>;
    name?: string;
    get disabled(): boolean;
    set disabled(value: BooleanLike);
    get readonly(): boolean;
    set readonly(value: BooleanLike);
    hasError: boolean;
    placeholder: string | undefined;
    value: string | undefined;
    get text(): string;
    set text(value: string | undefined);
    default: string;
    inputId: string | undefined;
    readonly valueChange: EventEmitter<string | undefined>;
    readonly textChange: EventEmitter<string>;
    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 set contentTextareaElement(textarea: ElementRef<HTMLTextAreaElement>);
    protected set viewInputElement(textarea: ElementRef<HTMLTextAreaElement>);
    constructor(applicationRef: ApplicationRef);
    protected onChange(): void;
    private refreshTextarea;
    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;
    static ɵfac: i0.ɵɵFactoryDeclaration<TextareaComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TextareaComponent, "m-textarea", never, { "name": { "alias": "name"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "hasError": { "alias": "hasError"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "value": { "alias": "value"; "required": false; }; "text": { "alias": "text"; "required": false; }; "default": { "alias": "default"; "required": false; }; "inputId": { "alias": "inputId"; "required": false; }; }, { "valueChange": "valueChange"; "textChange": "textChange"; "keyDown": "keyDown"; "keyUp": "keyUp"; "keyPress": "keyPress"; "blur": "blur"; "focus": "focus"; "focusin": "focusin"; "focusout": "focusout"; }, ["contentTextareaElement"], ["*"], true, never>;
}

declare class ToggleComponent extends CheckboxComponent {
    private readonly radioService;
    constructor(radioService: RadioService);
    static ɵfac: i0.ɵɵFactoryDeclaration<ToggleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ToggleComponent, "m-toggle", never, {}, {}, never, ["*"], true, never>;
}

declare class FieldComponent extends BaseComponent {
    static readonly defaults: {
        hintIcon: IconType;
        hintIconSize: IconSize;
        errorIcon: IconType;
        errorIconSize: IconSize;
    };
    private labelElementValue?;
    private inputComponentValue?;
    private numericInputComponentValue?;
    private dateInputComponentValue?;
    private checkboxComponentValue?;
    private sliderComponentValue?;
    private toggleComponentValue?;
    private radioComponentValue?;
    private textareaComponentValue?;
    private dropDownComponentValue?;
    private nameValue?;
    private labelValue?;
    private sizeValue;
    private disabledValue;
    private readonlyValue;
    private errorValue;
    private hideInitialErrorValue;
    private isInline;
    private isFill;
    protected wasAnytimeValid: boolean;
    readonly errors: FormError$1[];
    protected readonly defaults: {
        hintIcon: IconType;
        hintIconSize: IconSize;
        errorIcon: IconType;
        errorIconSize: IconSize;
    };
    private isInlineValidation;
    private hasOwnLabel;
    private isForceLabel;
    private originalLabel?;
    protected get labelElement(): HTMLLabelElement | undefined;
    protected set labelElement(value: HTMLLabelElement | undefined);
    protected get inputComponent(): InputComponent | undefined;
    protected set inputComponent(value: InputComponent | undefined);
    protected get numericInputComponent(): NumericInputComponent | undefined;
    protected set numericInputComponent(value: NumericInputComponent | undefined);
    protected get dateInputComponent(): DateInputComponent | undefined;
    protected set dateInputComponent(value: DateInputComponent | undefined);
    protected get checkboxComponent(): CheckboxComponent | undefined;
    protected set checkboxComponent(value: CheckboxComponent | undefined);
    protected get sliderComponent(): SliderComponent | undefined;
    protected set sliderComponent(value: SliderComponent | undefined);
    protected get toggleComponent(): ToggleComponent | undefined;
    protected set toggleComponent(value: ToggleComponent | undefined);
    protected get radioComponent(): RadioComponent | undefined;
    protected set radioComponent(value: RadioComponent | undefined);
    protected get textareaComponent(): TextareaComponent | undefined;
    protected set textareaComponent(value: TextareaComponent | undefined);
    protected get dropDownComponent(): DropdownComponent | undefined;
    protected set dropDownComponent(value: DropdownComponent | undefined);
    get name(): string | undefined;
    set name(value: string | undefined);
    get label(): string | undefined;
    set label(value: string | undefined);
    hint: string | undefined;
    get size(): FieldSize;
    set size(value: ParsableFieldSize);
    get error(): boolean;
    set error(value: BooleanLike);
    protected visibleError: boolean;
    set valid(value: boolean | FormValidation);
    get disabled(): boolean;
    set disabled(value: BooleanLike);
    get readonly(): boolean;
    set readonly(value: BooleanLike);
    get inline(): boolean;
    set inline(value: BooleanLike);
    get hideInitialError(): boolean;
    set hideInitialError(value: boolean);
    get fill(): boolean;
    set fill(value: BooleanLike);
    get inlineValidation(): boolean;
    set inlineValidation(value: BooleanLike);
    get ownLabel(): boolean;
    set ownLabel(value: BooleanLike);
    get forceLabel(): boolean;
    set forceLabel(value: BooleanLike);
    readonly errorChange: EventEmitter<boolean>;
    readonly change: EventEmitter<void>;
    constructor();
    forceValidation(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FieldComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FieldComponent, "m-field", never, { "name": { "alias": "name"; "required": false; }; "label": { "alias": "label"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "size": { "alias": "size"; "required": false; }; "error": { "alias": "error"; "required": false; }; "valid": { "alias": "valid"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "inline": { "alias": "inline"; "required": false; }; "hideInitialError": { "alias": "hideInitialError"; "required": false; }; "fill": { "alias": "fill"; "required": false; }; "inlineValidation": { "alias": "inlineValidation"; "required": false; }; "ownLabel": { "alias": "ownLabel"; "required": false; }; "forceLabel": { "alias": "forceLabel"; "required": false; }; }, { "errorChange": "errorChange"; "change": "change"; }, ["labelElement", "inputComponent", "numericInputComponent", "dateInputComponent", "checkboxComponent", "sliderComponent", "toggleComponent", "radioComponent", "textareaComponent", "dropDownComponent"], ["*"], true, never>;
}

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

declare type FieldsType = '' | 'two' | 'three' | 'four' | 'five' | 'six' | 'seven' | 'eight' | 'nine' | 'ten' | number;
declare class FieldGroupComponent extends BaseComponent {
    private readonly fieldClasses;
    private fieldsValue;
    private fieldsAutoValue;
    private isGrouped;
    private isInlineValidation;
    private errorValue;
    private changeSubscriptions;
    private fieldComponentsValue?;
    get fields(): FieldsType | undefined;
    set fields(value: FieldsType | undefined);
    get fieldComponents(): QueryList<FieldComponent> | undefined;
    set fieldComponents(value: QueryList<FieldComponent> | undefined);
    get grouped(): boolean;
    set grouped(value: BooleanLike);
    get inlineValidation(): boolean;
    set inlineValidation(value: BooleanLike);
    get error(): boolean;
    set error(value: BooleanLike);
    readonly errorChange: EventEmitter<boolean>;
    readonly change: EventEmitter<void>;
    constructor();
    private refreshFields;
    private refreshInlineValidation;
    private refreshChangeSubscriptions;
    private refreshIsValid;
    static ɵfac: i0.ɵɵFactoryDeclaration<FieldGroupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FieldGroupComponent, "m-field-group", never, { "fields": { "alias": "fields"; "required": false; }; "grouped": { "alias": "grouped"; "required": false; }; "inlineValidation": { "alias": "inlineValidation"; "required": false; }; "error": { "alias": "error"; "required": false; }; }, { "errorChange": "errorChange"; "change": "change"; }, ["fieldComponents"], ["*"], true, [{ directive: typeof InlineDirective; inputs: { "inline": "inline"; }; outputs: {}; }]>;
}

declare class FieldDefaultsComponent implements OnDestroy {
    private readonly previousHintIcon;
    private readonly previousHintIconSize;
    private readonly previousErrorIcon;
    private readonly previousErrorIconSize;
    private currentHintIcon?;
    private currentHintIconSize?;
    private currentErrorIcon?;
    private currentErrorIconSize?;
    set hintIcon(value: IconType);
    set hintIconSize(value: IconSize);
    set errorIcon(value: IconType);
    set errorIconSize(value: IconSize);
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FieldDefaultsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FieldDefaultsComponent, "m-field-defaults", never, { "hintIcon": { "alias": "hintIcon"; "required": false; }; "hintIconSize": { "alias": "hintIconSize"; "required": false; }; "errorIcon": { "alias": "errorIcon"; "required": false; }; "errorIconSize": { "alias": "errorIconSize"; "required": false; }; }, {}, never, never, true, never>;
}

declare type FlexDirection = 'row' | 'column' | 'row-reverse' | 'column-reverse';
declare type FlexAlignItems = 'flex-start' | 'flex-end' | 'center' | 'baseline' | 'stretch';
declare type FlexJustifyContent = 'flex-start' | 'flex-end' | 'center' | 'space-between' | 'space-around' | 'space-evenly';

declare class FlexDirective {
    static readonly default: {
        directive: typeof FlexDirective;
        inputs: string[];
    };
    protected display: string;
    direction: FlexDirection | '' | undefined;
    get 'm-flex'(): FlexDirection | '' | undefined;
    set 'm-flex'(value: FlexDirection | '' | undefined | null);
    get column(): boolean;
    set column(value: BooleanLike);
    get row(): boolean;
    set row(value: BooleanLike);
    alignItems: FlexAlignItems | undefined;
    justifyContent: FlexJustifyContent | undefined;
    gap: string | undefined;
    readonly wrap: i0.InputSignalWithTransform<boolean, BooleanLike>;
    readonly wrapReverse: i0.InputSignalWithTransform<boolean, BooleanLike>;
    get wrapStyle(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<FlexDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FlexDirective, "[m-flex]", never, { "direction": { "alias": "direction"; "required": false; }; "m-flex": { "alias": "m-flex"; "required": false; }; "column": { "alias": "column"; "required": false; }; "row": { "alias": "row"; "required": false; }; "alignItems": { "alias": "alignItems"; "required": false; }; "justifyContent": { "alias": "justifyContent"; "required": false; }; "gap": { "alias": "gap"; "required": false; }; "wrap": { "alias": "wrap"; "required": false; "isSignal": true; }; "wrapReverse": { "alias": "wrapReverse"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class FlexComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<FlexComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FlexComponent, "m-flex", never, {}, {}, never, ["*"], true, [{ directive: typeof FlexDirective; inputs: { "direction": "direction"; "alignItems": "alignItems"; "justifyContent": "justifyContent"; "row": "row"; "column": "column"; "gap": "gap"; "wrap": "wrap"; "wrapReverse": "wrapReverse"; }; outputs: {}; }]>;
}

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

declare class AutoDirective {
    readonly flex = "0 0 auto";
    static ɵfac: i0.ɵɵFactoryDeclaration<AutoDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AutoDirective, "[m-auto]", never, {}, {}, never, never, true, never>;
}

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

declare class FillDirective {
    readonly flex = "1";
    static ɵfac: i0.ɵɵFactoryDeclaration<FillDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FillDirective, "[m-fill]", never, {}, {}, never, never, true, never>;
}

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

declare class ShrinkDirective {
    protected readonly flex = "0 1 auto";
    static ɵfac: i0.ɵɵFactoryDeclaration<ShrinkDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ShrinkDirective, "[m-shrink]", never, {}, {}, never, never, true, never>;
}

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

declare class GrowDirective {
    readonly flex = "1 0 auto";
    static ɵfac: i0.ɵɵFactoryDeclaration<GrowDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrowDirective, "[m-grow]", never, {}, {}, never, never, true, never>;
}

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

declare class TemplateTarget {
    template: TemplateRef<unknown> | undefined;
}

declare class FooterLinkComponent {
    readonly target: TemplateTarget;
    static ɵfac: i0.ɵɵFactoryDeclaration<FooterLinkComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FooterLinkComponent, "m-footer-link", never, {}, {}, never, ["*"], true, never>;
}

declare class FormComponent extends InvertibleComponent implements OnInit {
    static readonly defaults: {
        inverted: boolean;
        invertedChange: ReplaySubject<boolean>;
    };
    private readonly loadingDirective;
    private readonly flexDirective;
    private readonly formValidationNotifier;
    private fieldComponentsValue?;
    private fieldGroupsComponentsValue?;
    private fieldSubscriptions?;
    private groupSubscriptions?;
    private isValidValue;
    private isSuccess;
    private isWarning;
    private isError;
    private isAutoSubmit;
    private readonly autoSubmitSubject;
    private autoSubmitThrottleValue;
    private autoSubmitSubscription;
    private isInlineValidation;
    protected get loading(): boolean;
    protected get flexDirection(): FlexDirection | '' | undefined;
    get fieldComponents(): QueryList<FieldComponent> | undefined;
    protected set fieldComponents(value: QueryList<FieldComponent> | undefined);
    get fieldGroupsComponents(): QueryList<FieldGroupComponent> | undefined;
    protected set fieldGroupsComponents(value: QueryList<FieldGroupComponent> | undefined);
    action?: string;
    autocomplete?: 'on' | 'off';
    enctype?: 'application/x-www-form-urlencoded' | 'multipart/form-data' | 'text/plain';
    method?: 'get' | 'post';
    name?: string;
    novalidate: boolean;
    get success(): boolean;
    set success(value: BooleanLike);
    get error(): boolean;
    set error(value: BooleanLike);
    get warning(): boolean;
    set warning(value: BooleanLike);
    target?: '_blank' | '_self' | '_parent' | '_top';
    get isValid(): boolean;
    set isValid(_: boolean);
    get autoSubmit(): boolean;
    set autoSubmit(value: BooleanLike);
    get autoSubmitThrottle(): number;
    set autoSubmitThrottle(value: number);
    get inlineValidation(): boolean;
    set inlineValidation(value: BooleanLike);
    readonly submit: EventEmitter<void>;
    readonly isValidChange: EventEmitter<boolean>;
    constructor();
    ngOnInit(): void;
    private releaseFields;
    private subscribeFields;
    private releaseGroups;
    private subscribeGroups;
    changed(): void;
    private refreshAutoSubmitSubscription;
    private refreshIsValid;
    validateAndSubmit(): void;
    protected onSubmit(event: SubmitEvent): void;
    private refreshInlineValidation;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormComponent, "m-form", never, { "action": { "alias": "action"; "required": false; }; "autocomplete": { "alias": "autocomplete"; "required": false; }; "enctype": { "alias": "enctype"; "required": false; }; "method": { "alias": "method"; "required": false; }; "name": { "alias": "name"; "required": false; }; "novalidate": { "alias": "novalidate"; "required": false; }; "success": { "alias": "success"; "required": false; }; "error": { "alias": "error"; "required": false; }; "warning": { "alias": "warning"; "required": false; }; "target": { "alias": "target"; "required": false; }; "isValid": { "alias": "isValid"; "required": false; }; "autoSubmit": { "alias": "autoSubmit"; "required": false; }; "autoSubmitThrottle": { "alias": "autoSubmitThrottle"; "required": false; }; "inlineValidation": { "alias": "inlineValidation"; "required": false; }; }, { "submit": "submit"; "isValidChange": "isValidChange"; }, ["fieldComponents", "fieldGroupsComponents"], ["*"], true, [{ directive: typeof LoadingDirective; inputs: { "loading": "loading"; }; outputs: {}; }]>;
}

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

declare class FormValidationNotifier {
    private isValidValue;
    private readonly isValidSubject;
    readonly isValid$: rxjs.Observable<boolean>;
    get isValid(): boolean;
    set(value: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormValidationNotifier, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FormValidationNotifier>;
}

declare type FormElements = FormInputElement | FormCheckboxElement | FormFieldGroupElement | FormDropDownElement | FormButtonElement | FormGridElement | FormLabelElement | FormMessage | FormWarning | FormInfo | FormError | FormDivider | FormHeader | FormAreaElement;
interface FormLayout {
    elements: FormElements[];
}
interface FormDataElement {
    field: string;
    defaultValue?: unknown;
    defaultAction?: string;
    fill?: boolean;
}
interface FormDataElementWithChildren extends FormDataElement {
    elements: FormElements[];
}
interface FormInputElement extends FormDataElement {
    elementType: 'input';
    type?: InputType;
    label?: string;
    readonly?: boolean;
    min?: number;
    max?: number;
    zeroText?: string;
}
interface FormCheckboxElement extends FormDataElement {
    elementType: 'checkbox';
    label: string;
    readonly?: boolean;
}
interface FormFieldGroupElement extends FormDataElementWithChildren {
    elementType: 'fields';
}
interface FormAreaElement extends FormDataElement {
    elementType: 'area';
    label?: string;
    readonly?: boolean;
}
interface FormDropDownElement extends FormDataElement {
    elementType: 'dropdown';
    label?: string;
    dataSource: string;
    valueField: string;
    textField: string | string[];
    textFieldFormatter?: string;
    readonly?: boolean;
    allowFreeText?: boolean;
    prefixItems?: DropdownValue[];
    postfixItems?: DropdownValue[];
}
interface FormButtonElement extends FormDataElement {
    elementType: 'button';
    label: string;
    action: string;
    color?: ColorName;
}
interface FormGridElement extends FormDataElement {
    elementType: 'grid';
    width?: 'equal';
    cells?: FormCellElement[];
}
interface FormCellElement extends FormDataElementWithChildren {
    float?: 'left' | 'right' | undefined;
    align?: 'left' | 'right' | undefined;
    size?: number;
}
interface FormLabelElement extends FormDataElement {
    elementType: 'label';
    label: string;
}
interface FormMessageBase extends FormDataElement {
    header: string;
    text: string;
}
interface FormMessage extends FormMessageBase {
    elementType: 'message';
}
interface FormWarning extends FormMessageBase {
    elementType: 'warning';
}
interface FormInfo extends FormMessageBase {
    elementType: 'info';
}
interface FormError extends FormMessageBase {
    elementType: 'error';
}
interface FormDivider extends FormDataElement {
    elementType: 'divider';
}
interface FormHeader extends FormDataElement {
    elementType: 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6';
    text: string;
    dividing?: boolean;
}

declare class FormRendererComponent {
    private readonly dataChangeSubject;
    private readonly executeSubject;
    private layoutValue;
    private dataValue;
    dataSources: DataSourceComponent[];
    get layout(): FormLayout;
    set layout(value: FormLayout | undefined);
    get data(): Record<string, unknown>;
    set data(value: Record<string, unknown> | any);
    readonly dataChange: rxjs.Observable<unknown>;
    readonly execute: rxjs.Observable<string>;
    protected set dataSourceElements(query: QueryList<DataSourceComponent>);
    protected onExecute(action: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormRendererComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormRendererComponent, "m-form-renderer", never, { "layout": { "alias": "layout"; "required": false; }; "data": { "alias": "data"; "required": false; }; }, { "dataChange": "dataChange"; "execute": "execute"; }, ["dataSourceElements"], ["*"], true, never>;
}

declare class FormElementRendererComponent extends BaseComponent implements DoCheck {
    private isFields;
    private readonly elementsDiffer;
    private readonly fieldClasses;
    private readonly dataCache;
    private readonly dropDownCache;
    private readonly executeSubject;
    private elementsValue;
    private dataValue;
    get elements(): FormElements[];
    set elements(value: FormElements[]);
    readonly execute: Observable<string>;
    get fields(): boolean;
    set fields(value: BooleanLike);
    protected get anyData(): any;
    get data(): Record<string, unknown>;
    set data(value: Record<string, unknown>);
    dataSources: DataSourceComponent[];
    constructor(iterableDiffers: IterableDiffers);
    ngDoCheck(): void;
    protected getData(dataSource: string): Observable<Record<string, unknown>[]>;
    protected getItems(dropdown: FormDropDownElement): Observable<DropdownValue[]>;
    protected onExecute(action: string): void;
    private applyDefaults;
    private format;
    private upgradeItems;
    protected $input(element: FormElements): FormInputElement;
    protected $checkbox(element: FormElements): FormCheckboxElement;
    protected $area(element: FormElements): FormAreaElement;
    protected $dropdown(element: FormElements): FormDropDownElement;
    protected $button(element: FormElements): FormButtonElement;
    protected $label(element: FormElements): FormLabelElement;
    protected $fields(element: FormElements): FormFieldGroupElement;
    protected $grid(element: FormElements): FormGridElement;
    protected $message(element: FormElements): FormMessage | FormWarning | FormInfo | FormError;
    protected $header(element: FormElements): FormHeader;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormElementRendererComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormElementRendererComponent, "m-form-element-renderer", never, { "elements": { "alias": "elements"; "required": false; }; "fields": { "alias": "fields"; "required": false; }; "data": { "alias": "data"; "required": false; }; "dataSources": { "alias": "dataSources"; "required": false; }; }, { "execute": "execute"; }, never, never, true, never>;
}

declare function FormElement(name: string): (constructor: Type<unknown>) => void;

interface FormElementBase {
    element: FormDataElement | undefined;
    data: unknown | undefined;
}

declare class FormElementRenderer2Component implements OnDestroy {
    private readonly formRendererService;
    private readonly viewContainerRef;
    private elementType;
    private elementValue;
    private dataValue;
    componentRef: ComponentRef<FormElementBase> | undefined;
    invalidType: string | undefined;
    get element(): FormElements | undefined;
    set element(value: FormElements | undefined);
    get data(): unknown;
    set data(value: unknown);
    createComponent(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormElementRenderer2Component, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormElementRenderer2Component, "m-form-renderer2", never, { "element": { "alias": "element"; "required": false; }; "data": { "alias": "data"; "required": false; }; }, {}, never, never, true, never>;
}

declare class FormRendererService {
    static readonly formElements: {
        [key: string]: Type<FormElementBase>;
    };
    register(type: Type<FormElementBase>, name: string): void;
    get(name: string | undefined): Type<FormElementBase> | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormRendererService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FormRendererService>;
}

declare function provideFormElement(type: Type<FormElementBase>, name: string): EnvironmentProviders;

declare type GridWidth = 'equal';
declare class GridComponent extends BaseComponent {
    private columnsValue?;
    private isVertically;
    private isDivided;
    private isCelled;
    private isInternally;
    private widthValue?;
    private noMarginValue;
    get vertically(): boolean;
    set vertically(value: BooleanLike);
    get divided(): boolean;
    set divided(value: BooleanLike);
    get columns(): FieldSize | undefined;
    set columns(value: ParsableFieldSize | undefined);
    get internally(): boolean;
    set internally(value: BooleanLike);
    get celled(): boolean;
    set celled(value: BooleanLike);
    get width(): GridWidth | undefined;
    set width(value: GridWidth | undefined);
    get noMargin(): boolean;
    set noMargin(value: BooleanLike);
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<GridComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GridComponent, "m-grid", never, { "vertically": { "alias": "vertically"; "required": false; }; "divided": { "alias": "divided"; "required": false; }; "columns": { "alias": "columns"; "required": false; }; "internally": { "alias": "internally"; "required": false; }; "celled": { "alias": "celled"; "required": false; }; "width": { "alias": "width"; "required": false; }; "noMargin": { "alias": "noMargin"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare type HeaderSize = 'huge' | 'large' | 'medium' | 'small' | 'tiny';
declare class HeaderComponent extends InvertibleComponent implements OnInit {
    static readonly defaults: {
        inverted: boolean;
        invertedChange: ReplaySubject<boolean>;
    };
    private sizeValue;
    icon: IconType | undefined;
    iconSize: IconSize;
    get size(): HeaderSize | undefined;
    set size(value: HeaderSize | undefined);
    constructor();
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HeaderComponent, "m-header", never, { "icon": { "alias": "icon"; "required": false; }; "iconSize": { "alias": "iconSize"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, {}, never, ["*"], true, never>;
}

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

declare class IconComponent {
    protected mIcon?: string;
    protected mSize?: IconSize;
    protected faIcon?: IconProp;
    protected faSize?: SizeProp;
    get icon(): IconType | undefined;
    set icon(value: IconType | undefined);
    get size(): IconSize;
    set size(value: IconSize);
    iconClass?: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<IconComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IconComponent, "m-icon", never, { "icon": { "alias": "icon"; "required": false; }; "size": { "alias": "size"; "required": false; }; "iconClass": { "alias": "iconClass"; "required": false; }; }, {}, never, never, true, never>;
}

declare class InfoComponent extends InvertibleComponent implements OnInit {
    constructor();
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InfoComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InfoComponent, "m-info", never, {}, {}, never, ["*"], true, [{ directive: typeof IgnoredDirective; inputs: { "ignored": "ignored"; }; outputs: {}; }]>;
}

declare class ImageUploadComponent extends ButtonBaseComponent {
    private readonly previewImageChangeSubject;
    private readonly uploadSubject;
    isPreviewVisible: boolean;
    private isPreviewImageChangeForced;
    previewImage?: string;
    radius?: number;
    previewWidth?: number;
    previewHeight?: number;
    width?: number;
    height?: number;
    set hidePreview(value: BooleanLike);
    set forcePreviewImageChange(value: BooleanLike);
    readonly previewImageChange: rxjs.Observable<string>;
    readonly upload: rxjs.Observable<FileList>;
    protected onUpload(fileList: FileList | null): void;
    private showPreview;
    static ɵfac: i0.ɵɵFactoryDeclaration<ImageUploadComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ImageUploadComponent, "m-image-upload", never, { "previewImage": { "alias": "previewImage"; "required": false; }; "radius": { "alias": "radius"; "required": false; }; "previewWidth": { "alias": "previewWidth"; "required": false; }; "previewHeight": { "alias": "previewHeight"; "required": false; }; "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "hidePreview": { "alias": "hidePreview"; "required": false; }; "forcePreviewImageChange": { "alias": "forcePreviewImageChange"; "required": false; }; }, { "previewImageChange": "previewImageChange"; "upload": "upload"; }, never, ["*"], true, never>;
}

declare class FileInputComponent {
    readonly id: string;
    input: ElementRef<HTMLInputElement> | undefined;
    get files(): FileList | undefined;
    accept: string | undefined;
    readonly change: EventEmitter<Event>;
    static ɵfac: i0.ɵɵFactoryDeclaration<FileInputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FileInputComponent, "m-file-input", never, { "accept": { "alias": "accept"; "required": false; }; }, { "change": "change"; }, never, ["*"], true, never>;
}

declare class TimeInputComponent extends InputBaseComponent implements OnInit {
    private valueField;
    protected internalValue: string | null;
    get value(): Date | undefined;
    set value(value: Date | number | string | undefined);
    get time(): Date;
    set time(value: Date | number | string | undefined);
    default: Date;
    min: Date | undefined;
    max: Date | undefined;
    readonly valueChange: EventEmitter<Date | undefined>;
    readonly timeChange: EventEmitter<Date>;
    protected set contentInputElement(input: ElementRef<HTMLInputElement>);
    protected set viewInputElement(input: ElementRef<HTMLInputElement>);
    constructor();
    ngOnInit(): void;
    protected onInternalChange(rawValue: string): void;
    private setInternalValue;
    static ɵfac: i0.ɵɵFactoryDeclaration<TimeInputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TimeInputComponent, "m-time-input", never, { "value": { "alias": "value"; "required": false; }; "time": { "alias": "time"; "required": false; }; "default": { "alias": "default"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; }, { "valueChange": "valueChange"; "timeChange": "timeChange"; }, ["contentInputElement"], ["*", "m-label", "m-label-dropdown", "m-button", "m-icon-button"], true, never>;
}

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

declare class LabelDropdownDefaultsComponent implements OnDestroy {
    private readonly previousDropdownIcon;
    private readonly previousDropdownIconSize;
    private currentDropdownIcon?;
    private currentDropdownIconSize?;
    set dropdownIcon(value: IconType);
    set dropdownIconSize(value: IconSize);
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LabelDropdownDefaultsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LabelDropdownDefaultsComponent, "m-label-dropdown-defaults", never, { "dropdownIcon": { "alias": "dropdownIcon"; "required": false; }; "dropdownIconSize": { "alias": "dropdownIconSize"; "required": false; }; }, {}, never, never, true, never>;
}

declare class LayoutService {
    readonly menuTemplates: TemplateRef<unknown>[];
    readonly footerTemplates: TemplateRef<unknown>[];
    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LayoutService>;
}

declare class LayoutComponent {
    private readonly layoutService;
    static readonly defaults: {
        menuIcon: IconType;
        menuIconSize: IconSize;
    };
    protected readonly defaults: {
        menuIcon: IconType;
        menuIconSize: IconSize;
    };
    showHamburger: boolean;
    menuIcon: IconType | undefined;
    menuIconSize: IconSize;
    get menuTemplates(): TemplateRef<unknown>[];
    get footerTemplates(): TemplateRef<unknown>[];
    constructor(layoutService: LayoutService);
    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LayoutComponent, "m-layout", never, { "showHamburger": { "alias": "showHamburger"; "required": false; }; "menuIcon": { "alias": "menuIcon"; "required": false; }; "menuIconSize": { "alias": "menuIconSize"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class LayoutDefaultsComponent implements OnDestroy {
    private readonly previousMenuIcon;
    private readonly previousMenuIconSize;
    private currentMenuIcon?;
    private currentMenuIconSize?;
    set menuIcon(value: IconType);
    set menuIconSize(value: IconSize);
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutDefaultsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LayoutDefaultsComponent, "m-layout-defaults", never, { "menuIcon": { "alias": "menuIcon"; "required": false; }; "menuIconSize": { "alias": "menuIconSize"; "required": false; }; }, {}, never, never, true, never>;
}

declare type LoaderSize = 'mini' | 'tiny' | 'small' | 'large' | 'big' | 'huge' | 'massive';
declare class LoaderComponent extends BaseComponent {
    private readonly activeDirective;
    private textValue;
    private sizeValue;
    private isInline;
    get text(): string | undefined;
    set text(value: string | undefined);
    get size(): LoaderSize | undefined;
    set size(value: LoaderSize | undefined);
    get inline(): boolean;
    set inline(value: BooleanLike);
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<LoaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LoaderComponent, "m-loader", never, { "text": { "alias": "text"; "required": false; }; "size": { "alias": "size"; "required": false; }; "inline": { "alias": "inline"; "required": false; }; }, {}, never, ["*"], true, [{ directive: typeof InvertedDirective; inputs: { "inverted": "inverted"; }; outputs: {}; }, { directive: typeof ActiveDirective; inputs: { "active": "active"; }; outputs: {}; }, { directive: typeof InlineDirective; inputs: { "inline": "inline"; }; outputs: {}; }]>;
}

declare const localizeDictionary: Map<string, string>;
declare function localize(key: string, fallback?: string): string;

declare class LocalizeComponent implements AfterViewInit, OnInit {
    private readonly elementRef;
    readonly key: i0.InputSignal<string>;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LocalizeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LocalizeComponent, "m-localize", never, { "key": { "alias": "key"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

interface MarkdownElement {
    type: string;
    breakLine?: true;
    isBlock?: true;
}

interface MarkdownBold extends MarkdownElement {
    type: 'bold';
    elements: MarkdownElement[];
}

interface MarkdownCode extends MarkdownElement {
    type: 'code';
    code: string | undefined;
}

interface MarkdownCodeBlock extends MarkdownElement {
    type: 'code-block';
    language: string | undefined;
    code: string | undefined;
    isBlock: true;
}

interface MarkdownCustomElement extends MarkdownElement {
    type: 'custom-element';
    isBlock: true;
    code: string | undefined;
    data: Record<string, unknown> | undefined;
}

interface MarkdownHeader1 extends MarkdownElement {
    type: 'header1';
    elements: MarkdownElement[];
    isBlock: true;
}
interface MarkdownHeader2 extends MarkdownElement {
    type: 'header2';
    elements: MarkdownElement[];
    isBlock: true;
}
interface MarkdownHeader3 extends MarkdownElement {
    type: 'header3';
    elements: MarkdownElement[];
    isBlock: true;
}
interface MarkdownHeader4 extends MarkdownElement {
    type: 'header4';
    elements: MarkdownElement[];
    isBlock: true;
}
interface MarkdownHeader5 extends MarkdownElement {
    type: 'header5';
    elements: MarkdownElement[];
    isBlock: true;
}
interface MarkdownHeader6 extends MarkdownElement {
    type: 'header6';
    elements: MarkdownElement[];
    isBlock: true;
}

interface MarkdownImage extends MarkdownElement {
    type: 'image';
    alt: string;
    url: string;
}

interface MarkdownItalic extends MarkdownElement {
    type: 'italic';
    elements: MarkdownElement[];
}

interface MarkdownLink extends MarkdownElement {
    type: 'link';
    elements: MarkdownElement[];
    url: string;
}

interface MarkdownList extends MarkdownElement {
    type: 'list';
    style: 'unordered';
    level: number;
    items: MarkdownListItem[];
}
interface MarkdownListItem extends MarkdownElement {
    type: 'list-item';
    elements: MarkdownElement[];
}

interface MarkdownParagraph extends MarkdownElement {
    type: 'paragraph';
    elements: MarkdownElement[];
    isBlock: true;
}

interface MarkdownStrikethrough extends MarkdownElement {
    type: 'strikethrough';
    elements: MarkdownElement[];
}

interface MarkdownText extends MarkdownElement {
    type: 'text';
    text: string;
}

declare class MarkdownRendererComponent {
    private readonly parser;
    private rawValue;
    protected elements: MarkdownElement[];
    protected readonly markdownParagraphType = "paragraph";
    protected readonly markdownHeader1Type = "header1";
    protected readonly markdownHeader2Type = "header2";
    protected readonly markdownHeader3Type = "header3";
    protected readonly markdownHeader4Type = "header4";
    protected readonly markdownHeader5Type = "header5";
    protected readonly markdownHeader6Type = "header6";
    protected readonly markdownCodeBlockType = "code-block";
    protected readonly markdownSeparatorType = "separator";
    protected readonly markdownCustomElementType = "custom-element";
    protected readonly markdownCodeType = "code";
    protected readonly markdownImageType = "image";
    protected readonly markdownLinkType = "link";
    protected readonly markdownItalicType = "italic";
    protected readonly markdownBoldType = "bold";
    protected readonly markdownStrikethroughType = "strikethrough";
    protected readonly markdownTextType = "text";
    protected readonly markdownEmptyType = "empty";
    protected readonly markdownListType = "list";
    get value(): string;
    set value(value: string | undefined);
    protected $elements(elements: []): MarkdownElement[];
    protected $paragraph(element: MarkdownElement): MarkdownParagraph | undefined;
    protected $header1(element: MarkdownElement): MarkdownHeader1 | undefined;
    protected $header2(element: MarkdownElement): MarkdownHeader2 | undefined;
    protected $header3(element: MarkdownElement): MarkdownHeader3 | undefined;
    protected $header4(element: MarkdownElement): MarkdownHeader4 | undefined;
    protected $header5(element: MarkdownElement): MarkdownHeader5 | undefined;
    protected $header6(element: MarkdownElement): MarkdownHeader6 | undefined;
    protected $codeBlock(element: MarkdownElement): MarkdownCodeBlock | undefined;
    protected $customElement(element: MarkdownElement): MarkdownCustomElement | undefined;
    protected $code(element: MarkdownElement): MarkdownCode | undefined;
    protected $list(element: MarkdownElement): MarkdownList | undefined;
    protected $image(element: MarkdownElement): MarkdownImage | undefined;
    protected $link(element: MarkdownElement): MarkdownLink | undefined;
    protected $italic(element: MarkdownElement): MarkdownItalic | undefined;
    protected $bold(element: MarkdownElement): MarkdownBold | undefined;
    protected $strikethrough(element: MarkdownElement): MarkdownStrikethrough | undefined;
    protected $text(element: MarkdownElement): MarkdownText | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<MarkdownRendererComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MarkdownRendererComponent, "m-markdown-renderer", never, { "value": { "alias": "value"; "required": false; }; }, {}, never, never, true, never>;
}

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

declare class MenuLinkComponent {
    readonly target: TemplateTarget;
    static ɵfac: i0.ɵɵFactoryDeclaration<MenuLinkComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MenuLinkComponent, "m-menu-link", never, {}, {}, never, ["*"], true, never>;
}

declare type MessageAttached = 'bottom' | 'top' | undefined;
declare class MessageComponent extends InvertibleComponent implements OnInit {
    static readonly defaults: {
        closeIcon: IconType;
        closeIconSize: IconSize;
        inverted: boolean;
        invertedChange: ReplaySubject<boolean>;
    };
    private isPositive;
    private isSuccess;
    private isWarning;
    private isError;
    private isInfo;
    private isClosable;
    private isCloseVisible;
    private isLoading;
    private attachedValue;
    private iconValue;
    protected readonly defaults: {
        closeIcon: IconType;
        closeIconSize: IconSize;
        inverted: boolean;
        invertedChange: ReplaySubject<boolean>;
    };
    get positive(): boolean;
    set positive(value: BooleanLike);
    get info(): boolean;
    set info(value: BooleanLike);
    get success(): boolean;
    set success(value: BooleanLike);
    get warning(): boolean;
    set warning(value: BooleanLike);
    get error(): boolean;
    set error(value: BooleanLike);
    get closable(): boolean;
    set closable(value: BooleanLike);
    get showClose(): boolean;
    set showClose(value: BooleanLike);
    get loading(): boolean;
    set loading(value: BooleanLike);
    get attached(): MessageAttached;
    set attached(value: MessageAttached);
    header: string | undefined;
    get icon(): IconType | undefined;
    set icon(value: IconType | undefined);
    iconSize: IconSize;
    closeIcon: IconType | undefined;
    closeIconSize: IconSize;
    readonly close: EventEmitter<MouseEvent>;
    constructor();
    ngOnInit(): void;
    private onClick;
    static ɵfac: i0.ɵɵFactoryDeclaration<MessageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MessageComponent, "m-message", never, { "positive": { "alias": "positive"; "required": false; }; "info": { "alias": "info"; "required": false; }; "success": { "alias": "success"; "required": false; }; "warning": { "alias": "warning"; "required": false; }; "error": { "alias": "error"; "required": false; }; "closable": { "alias": "closable"; "required": false; }; "showClose": { "alias": "showClose"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "attached": { "alias": "attached"; "required": false; }; "header": { "alias": "header"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "iconSize": { "alias": "iconSize"; "required": false; }; "closeIcon": { "alias": "closeIcon"; "required": false; }; "closeIconSize": { "alias": "closeIconSize"; "required": false; }; }, { "close": "close"; }, never, ["*"], true, [{ directive: typeof IgnoredDirective; inputs: { "ignored": "ignored"; }; outputs: {}; }]>;
}

declare class MessageDefaultsComponent implements OnDestroy {
    private readonly previousCloseIcon;
    private readonly previousCloseIconSize;
    private currentCloseIcon?;
    private currentCloseIconSize?;
    set closeIcon(value: IconType);
    set closeIconSize(value: IconSize);
    set inverted(value: boolean);
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MessageDefaultsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MessageDefaultsComponent, "m-message-defaults", never, { "closeIcon": { "alias": "closeIcon"; "required": false; }; "closeIconSize": { "alias": "closeIconSize"; "required": false; }; "inverted": { "alias": "inverted"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ModalDefaultsComponent implements OnDestroy {
    private readonly previousCloseIcon;
    private currentCloseIcon?;
    set closeIcon(value: IconType);
    set inverted(value: boolean);
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ModalDefaultsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ModalDefaultsComponent, "m-modal-defaults", never, { "closeIcon": { "alias": "closeIcon"; "required": false; }; "inverted": { "alias": "inverted"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ModalFooterComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<ModalFooterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ModalFooterComponent, "m-modal-footer", never, {}, {}, never, ["*"], true, never>;
}

declare class ModalHeaderComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<ModalHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ModalHeaderComponent, "m-modal-header", never, {}, {}, never, ["*"], true, never>;
}

type ModalSize = 'mini' | 'tiny' | 'small' | 'large';
declare class ModalComponent extends InvertibleComponent {
    static readonly defaults: {
        closeIcon: IconType;
        inverted: boolean;
        invertedChange: ReplaySubject<boolean>;
    };
    private isShowClose;
    private isShowHeader;
    private isShowFooter;
    private isHideDimmer;
    private isVisible;
    private isImageContent;
    private isFullscreen;
    private isScrolling;
    private isNoPadding;
    private isLoading;
    private readonly resizeObserver;
    protected minGrowOnlyContentHeight: number;
    private readonly basicDirective;
    protected readonly defaults: {
        closeIcon: IconType;
        inverted: boolean;
        invertedChange: ReplaySubject<boolean>;
    };
    readonly growOnly: i0.InputSignalWithTransform<boolean, BooleanLike>;
    readonly contentElementRef: i0.Signal<ElementRef<HTMLElement> | undefined>;
    protected get basic(): boolean;
    header: string | undefined;
    get showClose(): boolean;
    set showClose(value: BooleanLike);
    get showHeader(): boolean;
    set showHeader(value: BooleanLike);
    get hideHeader(): boolean;
    set hideHeader(value: BooleanLike);
    get showFooter(): boolean;
    set showFooter(value: BooleanLike);
    get hideFooter(): boolean;
    set hideFooter(value: BooleanLike);
    get hideDimmer(): boolean;
    set hideDimmer(value: BooleanLike);
    get visible(): boolean;
    set visible(value: BooleanLike);
    get imageContent(): boolean;
    set imageContent(value: BooleanLike);
    get fullscreen(): boolean;
    set fullscreen(value: BooleanLike);
    size: ModalSize | undefined;
    get scrolling(): boolean;
    set scrolling(value: BooleanLike);
    get noPadding(): boolean;
    set noPadding(value: BooleanLike);
    get loading(): boolean;
    set loading(value: BooleanLike);
    minContentHeight: string | undefined;
    maxContentHeight: string | undefined;
    closeIcon: IconType | undefined;
    readonly close: EventEmitter<void>;
    constructor();
    protected onClose(): void;
    protected onDimmerClick(event: MouseEvent): void;
    private onResize;
    static ɵfac: i0.ɵɵFactoryDeclaration<ModalComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ModalComponent, "m-modal", never, { "growOnly": { "alias": "growOnly"; "required": false; "isSignal": true; }; "header": { "alias": "header"; "required": false; }; "showClose": { "alias": "showClose"; "required": false; }; "showHeader": { "alias": "showHeader"; "required": false; }; "hideHeader": { "alias": "hideHeader"; "required": false; }; "showFooter": { "alias": "showFooter"; "required": false; }; "hideFooter": { "alias": "hideFooter"; "required": false; }; "hideDimmer": { "alias": "hideDimmer"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "imageContent": { "alias": "imageContent"; "required": false; }; "fullscreen": { "alias": "fullscreen"; "required": false; }; "size": { "alias": "size"; "required": false; }; "scrolling": { "alias": "scrolling"; "required": false; }; "noPadding": { "alias": "noPadding"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "minContentHeight": { "alias": "minContentHeight"; "required": false; }; "maxContentHeight": { "alias": "maxContentHeight"; "required": false; }; "closeIcon": { "alias": "closeIcon"; "required": false; }; }, { "close": "close"; }, never, ["m-modal-header", "*", "m-modal-footer"], true, [{ directive: typeof BasicDirective; inputs: { "basic": "basic"; }; outputs: {}; }]>;
}

declare class AsyncAction implements InteropObservable<void> {
    private readonly subject;
    readonly event: rxjs.Observable<void>;
    /**
     * Alias for done to support rxjs.Observer<void>
     * @deprecated
     */
    readonly next: () => void;
    done(): void;
    error(message?: string): void;
    [Symbol.observable](): Subscribable<void>;
}

type NotificationType = 'positive' | 'success' | 'warning' | 'error' | 'info' | 'none';

interface Notification<T = unknown> {
    type: NotificationType;
    title?: string;
    text?: string;
    timeout?: number;
    closeable?: boolean;
    group?: string;
    icon?: IconType;
    loading?: boolean;
    component?: Type<unknown>;
    details?: T;
}

interface NotificationHandler {
    remove(message: Notification): void;
}

declare class NotificationRef<T = unknown> {
    readonly notification: Notification<T>;
    private readonly handler;
    constructor(notification: Notification<T>, handler: NotificationHandler);
    close(): void;
}

declare class NotificationDefaultsComponent implements OnDestroy {
    private readonly previousSuccessIcon;
    private currentSuccessIcon?;
    set successIcon(value: IconType);
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationDefaultsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NotificationDefaultsComponent, "m-notification-defaults", never, { "successIcon": { "alias": "successIcon"; "required": false; }; }, {}, never, never, true, never>;
}

declare const notificationToken: InjectionToken<Notification<unknown>>;

declare class NotificationService implements NotificationHandler {
    static readonly defaults: {
        successIcon: IconType;
    };
    private readonly addedSubject;
    private readonly removedSubject;
    private readonly erroredSubject;
    private readonly warnedSubject;
    private readonly succeededSubject;
    private readonly positivedSubject;
    private readonly informedSubject;
    private readonly messages;
    readonly added: rxjs.Observable<Notification<unknown>>;
    readonly removed: rxjs.Observable<Notification<unknown>>;
    readonly errored: rxjs.Observable<Notification<unknown>>;
    readonly warned: rxjs.Observable<Notification<unknown>>;
    readonly succeeded: rxjs.Observable<Notification<unknown>>;
    readonly positived: rxjs.Observable<Notification<unknown>>;
    readonly informed: rxjs.Observable<Notification<unknown>>;
    get(group?: 'all' | 'empty' | string): Notification[];
    add(notification: Notification): NotificationRef;
    remove(notification: Notification): void;
    async(processingText: string, doneText: string, errorText?: string): AsyncAction;
    error(message: {
        timeout: 0;
    } | Partial<Notification>): NotificationRef;
    error(text: string, options?: {
        timeout: 0;
    } | Partial<Notification>): NotificationRef;
    warning(message: {
        timeout: 2000;
    } | Partial<Notification>): NotificationRef;
    warning(text: string, options?: {
        timeout: 2000;
    } | Partial<Notification>): NotificationRef;
    success(message: {
        timeout: 2000;
    } | Partial<Notification>): NotificationRef;
    success(text: string, options?: {
        timeout: 2000;
    } | Partial<Notification>): NotificationRef;
    positive(message: {
        timeout: 2000;
    } | Partial<Notification>): NotificationRef;
    positive(text: string, options?: {
        timeout: 2000;
    } | Partial<Notification>): NotificationRef;
    info(message: {
        timeout: 2000;
    } | Partial<Notification>): NotificationRef;
    info(text: string, options?: {
        timeout: 2000;
    } | Partial<Notification>): NotificationRef;
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<NotificationService>;
}

declare class NotificationComponent extends BaseComponent {
    private readonly notificationService;
    set fromService(value: string);
    messages: Notification[];
    mode: 'overlap' | 'stack';
    attached: MessageAttached;
    constructor(notificationService: NotificationService);
    close(message: Notification, event: MouseEvent): void;
    protected $message(message: unknown): Notification;
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NotificationComponent, "m-notification", never, { "fromService": { "alias": "fromService"; "required": false; }; "messages": { "alias": "messages"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "attached": { "alias": "attached"; "required": false; }; }, {}, never, never, true, never>;
}

declare class OrComponent {
    readonly ui = true;
    static ɵfac: i0.ɵɵFactoryDeclaration<OrComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<OrComponent, "m-or", never, {}, {}, never, never, true, never>;
}

declare class RowComponent extends BaseComponent {
    private columnsValue;
    private isStretched;
    get columns(): FieldSize | undefined;
    set columns(value: ParsableFieldSize);
    get stretched(): boolean;
    set stretched(value: BooleanLike);
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<RowComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RowComponent, "m-row", never, { "columns": { "alias": "columns"; "required": false; }; "stretched": { "alias": "stretched"; "required": false; }; }, {}, never, ["*"], true, never>;
}

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

declare type SegmentAttached = 'top' | 'bottom';
declare class SegmentComponent extends InvertibleComponent implements OnInit {
    static readonly defaults: {
        inverted: boolean;
        invertedChange: ReplaySubject<boolean>;
        raised: boolean;
        raisedChange: ReplaySubject<boolean>;
    };
    protected static readonly providers: typeof SortedClassesService[];
    private isVertical;
    private isRaised;
    private isRaisedChanged;
    private isPlaceholder;
    private isSecondary;
    private isTertiary;
    private attachedValue;
    private isNoPadding;
    private isNoMargin;
    get raised(): boolean;
    set raised(value: BooleanLike);
    get vertical(): boolean;
    set vertical(value: BooleanLike);
    get placeholder(): boolean;
    set placeholder(value: BooleanLike);
    get secondary(): boolean;
    set secondary(value: BooleanLike);
    get tertiary(): boolean;
    set tertiary(value: BooleanLike);
    get attached(): SegmentAttached | undefined;
    set attached(value: SegmentAttached | undefined);
    get noPadding(): boolean;
    set noPadding(value: BooleanLike);
    get noMargin(): boolean;
    set noMargin(value: BooleanLike);
    constructor();
    ngOnInit(): void;
    private refreshRaised;
    static ɵfac: i0.ɵɵFactoryDeclaration<SegmentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SegmentComponent, "m-segment", never, { "raised": { "alias": "raised"; "required": false; }; "vertical": { "alias": "vertical"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "secondary": { "alias": "secondary"; "required": false; }; "tertiary": { "alias": "tertiary"; "required": false; }; "attached": { "alias": "attached"; "required": false; }; "noPadding": { "alias": "noPadding"; "required": false; }; "noMargin": { "alias": "noMargin"; "required": false; }; }, {}, never, ["*"], true, [{ directive: typeof BasicDirective; inputs: { "basic": "basic"; }; outputs: {}; }, { directive: typeof ColorDirective; inputs: { "color": "color"; }; outputs: {}; }, { directive: typeof LoadingDirective; inputs: { "loading": "loading"; }; outputs: {}; }]>;
}

declare class SegmentGroupComponent extends BaseComponent {
    private isHorizontal;
    get horizontal(): boolean;
    set horizontal(value: BooleanLike);
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<SegmentGroupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SegmentGroupComponent, "m-segment-group", never, { "horizontal": { "alias": "horizontal"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare type SidebarWidth = 'thin' | 'very thin' | 'wide' | 'very wide' | undefined;
declare type SidebarPosition = 'left' | 'right' | 'top' | 'bottom';
declare class SidebarComponent extends BaseComponent {
    private widthValue;
    private isVisible;
    private positionValue;
    private noScrollingValue;
    get visible(): boolean;
    set visible(value: BooleanLike);
    get width(): SidebarWidth;
    set width(value: SidebarWidth);
    get position(): SidebarPosition | undefined;
    set position(value: SidebarPosition | undefined);
    get noScrolling(): boolean;
    set noScrolling(value: BooleanLike);
    constructor();
    show(): void;
    hide(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SidebarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SidebarComponent, "m-sidebar", never, { "visible": { "alias": "visible"; "required": false; }; "width": { "alias": "width"; "required": false; }; "position": { "alias": "position"; "required": false; }; "noScrolling": { "alias": "noScrolling"; "required": false; }; }, {}, never, ["*"], true, [{ directive: typeof InvertedDirective; inputs: { "inverted": "inverted"; }; outputs: {}; }, { directive: typeof FluidDirective; inputs: { "fluid": "fluid"; }; outputs: {}; }]>;
}

declare class SubmitComponent extends ButtonBaseComponent {
    private readonly form;
    constructor(form: FormComponent);
    private onClick;
    private onKeyDown;
    protected submit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SubmitComponent, [{ optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SubmitComponent, "m-submit", never, {}, {}, never, ["*"], true, never>;
}

declare type Align = 'top' | 'bottom' | 'middle';
declare class TableComponent extends InvertibleComponent implements OnInit {
    static readonly defaults: {
        inverted: boolean;
        invertedChange: ReplaySubject<boolean>;
    };
    private isCelled;
    private isUnstackable;
    private isVery;
    private alignedValue;
    private isDefinition;
    private isCollapsing;
    get celled(): boolean;
    set celled(value: BooleanLike);
    get notCelled(): boolean;
    set notCelled(value: BooleanLike);
    get very(): boolean;
    set very(value: BooleanLike);
    get unstackable(): boolean;
    set unstackable(value: BooleanLike);
    get aligned(): Align | undefined;
    set aligned(value: Align | undefined);
    get definition(): boolean;
    set definition(value: BooleanLike);
    get collapsing(): boolean;
    set collapsing(value: BooleanLike);
    constructor();
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableComponent, "m-table", never, { "celled": { "alias": "celled"; "required": false; }; "notCelled": { "alias": "notCelled"; "required": false; }; "very": { "alias": "very"; "required": false; }; "unstackable": { "alias": "unstackable"; "required": false; }; "aligned": { "alias": "aligned"; "required": false; }; "definition": { "alias": "definition"; "required": false; }; "collapsing": { "alias": "collapsing"; "required": false; }; }, {}, never, ["*"], true, [{ directive: typeof BasicDirective; inputs: { "basic": "basic"; }; outputs: {}; }]>;
}

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

declare class TabComponent extends MenuItemComponent {
    name: string | undefined;
    label: string | undefined;
    icon: IconType | undefined;
    iconSize: IconSize;
    template: TemplateRef<NgIfContext<boolean>> | null;
    readonly activate: EventEmitter<void>;
    readonly deactivate: EventEmitter<void>;
    constructor();
    changeState(value: boolean | undefined): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TabComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TabComponent, "m-tab", never, { "name": { "alias": "name"; "required": false; }; "label": { "alias": "label"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "iconSize": { "alias": "iconSize"; "required": false; }; "template": { "alias": "template"; "required": false; }; }, { "activate": "activate"; "deactivate": "deactivate"; }, never, ["*"], true, never>;
}

declare class TabGroupComponent extends InvertibleComponent implements OnInit, AfterViewInit {
    private readonly route;
    private readonly router;
    static readonly defaults: {
        inverted: boolean;
        invertedChange: ReplaySubject<boolean>;
    };
    private selectedIndexField;
    private isSelectByRoute;
    private routeParameterName;
    private isNoPadding;
    private tabsValue;
    private isScrollable;
    private isPointing;
    private isSecondary;
    private isLoading;
    private routes;
    menu: MenuPosition;
    readonly selectedIndexChange: EventEmitter<number>;
    get pointing(): boolean;
    set pointing(value: BooleanLike);
    get secondary(): boolean;
    set secondary(value: BooleanLike);
    get loading(): boolean;
    set loading(value: BooleanLike);
    protected get menuPosition(): string;
    protected get horizontal(): boolean;
    get selectByRoute(): string;
    set selectByRoute(value: string);
    get selectedIndex(): number | undefined;
    set selectedIndex(value: number | undefined);
    get noPadding(): boolean;
    set noPadding(value: BooleanLike);
    get scrollable(): boolean;
    set scrollable(value: BooleanLike);
    protected get tabs(): QueryList<TabComponent> | undefined;
    protected set tabs(value: QueryList<TabComponent> | undefined);
    constructor(route: ActivatedRoute, router: Router);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    private refreshTab;
    protected activate(tab: TabComponent): void;
    private toName;
    private getActiveRouteSegments;
    private parseRoutes;
    static ɵfac: i0.ɵɵFactoryDeclaration<TabGroupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TabGroupComponent, "m-tab-group", never, { "menu": { "alias": "menu"; "required": false; }; "pointing": { "alias": "pointing"; "required": false; }; "secondary": { "alias": "secondary"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "selectByRoute": { "alias": "selectByRoute"; "required": false; }; "selectedIndex": { "alias": "selectedIndex"; "required": false; }; "noPadding": { "alias": "noPadding"; "required": false; }; "scrollable": { "alias": "scrollable"; "required": false; }; }, { "selectedIndexChange": "selectedIndexChange"; }, ["tabs"], ["*"], true, never>;
}

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

declare class TemplateComponent implements OnDestroy {
    private readonly templateService;
    private template;
    protected readonly contentTemplate: i0.Signal<TemplateRef<unknown> | undefined>;
    readonly name: i0.InputSignal<string | string[]>;
    readonly class: i0.InputSignal<string | undefined>;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TemplateComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TemplateComponent, "m-template", never, { "name": { "alias": "name"; "required": true; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

interface Template<T = unknown> {
    ref: TemplateRef<T>;
    class?: string;
}

declare class TemplateOutletComponent extends Destroyable {
    private readonly templateService;
    private readonly nextNameSubject;
    protected template: Template | undefined;
    readonly name: i0.InputSignal<string | string[]>;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<TemplateOutletComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TemplateOutletComponent, "m-template-outlet", never, { "name": { "alias": "name"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class TextContainerComponent extends BaseComponent {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<TextContainerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TextContainerComponent, "m-text-container", never, {}, {}, never, ["*"], true, [{ directive: typeof FluidDirective; inputs: { "fluid": "fluid"; }; outputs: {}; }]>;
}

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

interface ManticTitleStrategyCondition {
    condition: string | RegExp;
    postfix?: string;
    prefix?: string;
    fallback?: string;
    showPrefixOnFallback?: boolean;
    showPostfixOnFallback?: boolean;
}

interface ManticTitleStrategyConfiguration {
    prefix?: string;
    postfix?: string;
    fallback?: string;
    showPrefixOnFallback?: boolean;
    showPostfixOnFallback?: boolean;
    conditions?: ManticTitleStrategyCondition[];
}

declare const manticTitleStrategyConfigurationToken: InjectionToken<string>;
declare class ManticTitleStrategy extends TitleStrategy {
    readonly configuration: ManticTitleStrategyConfiguration;
    constructor(configuration?: ManticTitleStrategyConfiguration);
    updateTitle(snapshot: RouterStateSnapshot): void;
    addCondition(condition: ManticTitleStrategyCondition): void;
    private matches;
    static ɵfac: i0.ɵɵFactoryDeclaration<ManticTitleStrategy, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ManticTitleStrategy>;
}

declare class ManticTitleStrategyModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ManticTitleStrategyModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ManticTitleStrategyModule, never, never, never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ManticTitleStrategyModule>;
}

declare function provideManticTitleStrategy(configuration: ManticTitleStrategyConfiguration): EnvironmentProviders;

declare class WarningComponent extends InvertibleComponent {
    protected readonly defaults: {
        closeIcon: _mantic_ui_angular.IconType;
        closeIconSize: _mantic_ui_angular.IconSize;
        inverted: boolean;
        invertedChange: rxjs.ReplaySubject<boolean>;
    };
    showClose: boolean;
    closed: boolean;
    get visible(): boolean;
    readonly close: EventEmitter<void>;
    constructor();
    ngOnInit(): void;
    onClose(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WarningComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<WarningComponent, "m-warning", never, { "showClose": { "alias": "showClose"; "required": false; }; "closed": { "alias": "closed"; "required": false; }; }, { "close": "close"; }, never, ["*"], true, never>;
}

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

declare class FallbackForDirective {
    private readonly elementRef;
    private readonly templateRef;
    private readonly viewContainer;
    set fallback(selector: string);
    constructor(elementRef: ElementRef<HTMLElement>, templateRef: TemplateRef<unknown>, viewContainer: ViewContainerRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<FallbackForDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FallbackForDirective, "[m-fallback-for]", never, { "fallback": { "alias": "m-fallback-for"; "required": false; }; }, {}, never, never, true, never>;
}

declare class FooterLinkTemplateDirective {
    private readonly menuService;
    private readonly template;
    constructor(menuService: LayoutService, template: TemplateRef<unknown>);
    static ɵfac: i0.ɵɵFactoryDeclaration<FooterLinkTemplateDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FooterLinkTemplateDirective, "[m-footer-link-template]", never, {}, {}, never, never, true, never>;
}

declare class HideOnEmptyTemplateDirective extends Destroyable {
    private readonly templateService;
    private readonly template;
    private readonly viewContainerRef;
    private readonly nextNameSubject;
    private hasTemplate;
    readonly name: i0.InputSignal<string | string[]>;
    constructor();
    private refreshView;
    static ɵfac: i0.ɵɵFactoryDeclaration<HideOnEmptyTemplateDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<HideOnEmptyTemplateDirective, "[mHideOnEmptyTemplate]", never, { "name": { "alias": "mHideOnEmptyTemplate"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class HideOnExistingTemplateDirective extends Destroyable {
    private readonly templateService;
    private readonly template;
    private readonly viewContainerRef;
    private readonly nextNameSubject;
    private hasTemplate;
    readonly name: i0.InputSignal<string | string[]>;
    constructor();
    private refreshView;
    static ɵfac: i0.ɵɵFactoryDeclaration<HideOnExistingTemplateDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<HideOnExistingTemplateDirective, "[mHideOnExistingTemplate]", never, { "name": { "alias": "mHideOnExistingTemplate"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class HeaderDirective extends BaseDirective implements OnInit {
    private readonly invertedDirective;
    private isDividing;
    private isIcon;
    get inverted(): boolean;
    set inverted(value: BooleanLike);
    get dividing(): boolean;
    set dividing(value: BooleanLike);
    get icon(): boolean;
    set icon(value: BooleanLike);
    sub: boolean;
    constructor();
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<HeaderDirective, "[m-header]", never, { "dividing": { "alias": "dividing"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "sub": { "alias": "sub"; "required": false; }; }, {}, never, never, true, [{ directive: typeof InvertedDirective; inputs: { "inverted": "inverted"; }; outputs: {}; }]>;
}

declare class MenuLinkTemplateDirective {
    private readonly menuService;
    private readonly template;
    constructor(menuService: LayoutService, template: TemplateRef<unknown>);
    static ɵfac: i0.ɵɵFactoryDeclaration<MenuLinkTemplateDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<MenuLinkTemplateDirective, "[m-menu-link-template]", never, {}, {}, never, never, true, never>;
}

declare class MenuItemDirective/*extends MenuItemComponent*/  extends BaseDirective {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<MenuItemDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<MenuItemDirective, "[m-menu-item]", never, {}, {}, never, never, true, [{ directive: typeof ActiveDirective; inputs: { "active": "active"; }; outputs: {}; }]>;
}

declare class ReadonlyDirective {
    static readonly 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-readonly]", never, { "readonly": { "alias": "readonly"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ToBodyDirective implements AfterViewInit, OnDestroy {
    private readonly template;
    private readonly viewContainerRef;
    private embeddedViewRef;
    constructor(template: TemplateRef<unknown>, viewContainerRef: ViewContainerRef);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToBodyDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ToBodyDirective, "[m-to-body]", never, {}, {}, never, never, true, never>;
}

declare class ToTemplateDirective {
    private readonly template;
    set toTemplate(target: TemplateTarget);
    constructor(template: TemplateRef<unknown>);
    static ɵfac: i0.ɵɵFactoryDeclaration<ToTemplateDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ToTemplateDirective, "[m-to-template]", never, { "toTemplate": { "alias": "m-to-template"; "required": false; }; }, {}, never, never, true, never>;
}

declare class PositionAbsoluteDirective implements AfterViewInit, OnDestroy {
    private readonly elementRef;
    private readonly observer;
    private parent;
    position: 'top-left' | 'top-center' | 'top-right' | 'middle-left' | 'middle-center' | 'middle-right' | 'bottom-left' | 'bottom-center' | 'bottom-right' | undefined;
    attach: 'left' | 'middle' | 'right';
    parentWidth: 'none' | 'exact' | 'min' | 'max';
    minLeft: number | 'parent-left' | 'parent-center' | 'parent-right' | undefined;
    constructor(elementRef: ElementRef<HTMLElement>);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    private refresh;
    private setTop;
    private setLeft;
    private setWidth;
    private setMinWidth;
    private setMaxWidth;
    static ɵfac: i0.ɵɵFactoryDeclaration<PositionAbsoluteDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PositionAbsoluteDirective, "[m-position-absolute]", never, { "position": { "alias": "m-position-absolute"; "required": false; }; "attach": { "alias": "attach"; "required": false; }; "parentWidth": { "alias": "parentWidth"; "required": false; }; "minLeft": { "alias": "minLeft"; "required": false; }; }, {}, never, never, true, never>;
}

interface ExternalRouteData {
    path: string;
    redirectTo: string;
}

declare abstract class ExternalRouteComponent implements OnInit {
    private readonly route;
    protected constructor(route: ActivatedRoute);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ExternalRouteComponent, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ExternalRouteComponent, never, never, {}, {}, never, never, true, never>;
}

declare const cast: <T>(value: T) => T;

/**
 * A type that represents changes of a component. A typed version of SimpleChange.
 * @template T - The type of the component.
 * @example
 * ```typescript
 * ngOnChanges(changes: Changes<MyComponent>) {
 *   if (changes.myInput) {
 *      //...
 *    }
 *  }
 *  ```
 */
declare type Changes<T> = {
    [P in keyof T]?: SimpleChange;
};

declare class LowerCaseUrlSerializer extends DefaultUrlSerializer {
    parse(url: string): UrlTree;
    static ɵfac: i0.ɵɵFactoryDeclaration<LowerCaseUrlSerializer, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LowerCaseUrlSerializer>;
}

declare class LowerCaseUrlSerializerModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<LowerCaseUrlSerializerModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LowerCaseUrlSerializerModule, never, never, never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LowerCaseUrlSerializerModule>;
}

declare const toBoolean: (value: BooleanLike) => boolean;

declare class Timespan {
    static readonly hoursInDay = 24;
    static readonly minutesInHour = 60;
    static readonly minutesInDay: number;
    static readonly secondsInMinute = 60;
    static readonly secondsInHour: number;
    static readonly secondsInDay: number;
    static readonly millisecondsInSecond = 1000;
    static readonly millisecondsInMinute: number;
    static readonly millisecondsInHour: number;
    static readonly millisecondsInDay: number;
}

declare class ObjectHelper {
    private constructor();
    static clone<T>(value: T): T;
    static get<T = unknown>(object: Record<string, unknown> | undefined, path: string | string[]): T | undefined;
    static has<T>(value: unknown, ...keys: (keyof T)[]): value is T;
    static hasSome<T>(value: unknown, ...keys: (keyof T)[]): value is T;
}

declare const mantic: Readonly<{
    pipes: {
        isEmail: {
            message: string;
        };
        isFilled: {
            message: string;
        };
        allowedChars: {
            message: string;
        };
    };
}>;

declare class Math2 {
    private constructor();
    static keepInRange(min: number, value: number | undefined, max?: number | undefined): number;
    static keepInRange(min: number | undefined, value: number, max?: number | undefined): number;
    static keepInRange(min: number | undefined, value: number | undefined, max: number): number;
    static sum(values: (number | undefined)[] | undefined): number;
    static round(value: number, decimals: number): number;
}

declare const mapVoid: () => rxjs.OperatorFunction<unknown, undefined>;

declare const enum Mouse {
    left = 0,
    middle = 1,
    right = 2,
    back = 3,
    forward = 4
}

declare abstract class DateHelper {
    static keepInRange(min: Date, value: Date | undefined, max?: Date | undefined): Date;
    static keepInRange(min: Date | undefined, value: Date, max?: Date | undefined): Date;
    static keepInRange(min: Date | undefined, value: Date | undefined, max?: Date): Date;
    static sameDay(left: Date | undefined, right: Date | undefined): boolean;
    static sameWeek(left: Date | undefined, right: Date | undefined): boolean;
    static sameMonth(left: Date | undefined, right: Date | undefined): boolean;
    static sameYear(left: Date | undefined, right: Date | undefined): boolean;
    static today(): Date;
}

/**
 * Register global data to be used internally by Angular. See the
 * ["I18n guide"](guide/i18n-common-format-data-locale) to know how to import additional locale
 * data.
 */
declare function provideLocale(locale: any, localeId: string, localeExtra: any): EnvironmentProviders;

interface ValidationPipe {
    transform(value: unknown | FormValidation, message?: string): FormValidation;
}

declare class AllowedCharsPipe implements ValidationPipe, PipeTransform {
    transform(value: unknown | FormValidation, allowedChars: string, message?: string): FormValidation;
    private isValid;
    static ɵfac: i0.ɵɵFactoryDeclaration<AllowedCharsPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<AllowedCharsPipe, "mAllowedChars", true>;
}

declare class ArrayPipe implements PipeTransform {
    transform(length: number): number[];
    static ɵfac: i0.ɵɵFactoryDeclaration<ArrayPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ArrayPipe, "mArray", true>;
}

declare class CeilPipe implements PipeTransform {
    transform(value: number, decimals?: number): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<CeilPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<CeilPipe, "mCeil", true>;
}

declare class DebuggerPipe implements PipeTransform {
    transform(value: unknown, ...args: unknown[]): unknown;
    static ɵfac: i0.ɵɵFactoryDeclaration<DebuggerPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<DebuggerPipe, "debugger", true>;
}

declare class DebugPipe implements PipeTransform {
    transform(value: unknown, ...args: unknown[]): unknown;
    static ɵfac: i0.ɵɵFactoryDeclaration<DebugPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<DebugPipe, "debug", true>;
}

declare class FloorPipe implements PipeTransform {
    transform(value: number, decimals?: number): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<FloorPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<FloorPipe, "mFloor", true>;
}

declare class IsFilledPipe implements ValidationPipe, PipeTransform {
    transform(value: unknown | FormValidation, message?: string): FormValidation;
    static ɵfac: i0.ɵɵFactoryDeclaration<IsFilledPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<IsFilledPipe, "mIsFilled", true>;
}

declare class IsEmailPipe implements ValidationPipe, PipeTransform {
    transform(value: unknown | FormValidation, message?: string): FormValidation;
    private isEmail;
    static ɵfac: i0.ɵɵFactoryDeclaration<IsEmailPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<IsEmailPipe, "mIsEmail", true>;
}

declare class LogPipe implements PipeTransform {
    transform<T>(value: T, ...args: unknown[]): T;
    static ɵfac: i0.ɵɵFactoryDeclaration<LogPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<LogPipe, "log", true>;
}

declare class PadEndPipe implements PipeTransform {
    transform(value: unknown, maxLength: number, fillString?: string): string | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<PadEndPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<PadEndPipe, "mPadEnd", true>;
}

declare class PadStartPipe implements PipeTransform {
    transform(value: unknown, maxLength: number, fillString?: string): string | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<PadStartPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<PadStartPipe, "mPadStart", true>;
}

declare class RoundPipe implements PipeTransform {
    transform(value: number, decimals?: number): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<RoundPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<RoundPipe, "mRound", true>;
}

declare class SafePipe implements PipeTransform {
    private readonly sanitizer;
    constructor(sanitizer: DomSanitizer);
    transform(url: string): SafeResourceUrl;
    static ɵfac: i0.ɵɵFactoryDeclaration<SafePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SafePipe, "mSafe", true>;
}

declare class TitlePipe implements ValidationPipe, PipeTransform {
    transform(value: unknown | FormValidation, label?: string): FormValidation;
    static ɵfac: i0.ɵɵFactoryDeclaration<TitlePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<TitlePipe, "mTitle", true>;
}

declare class ManticUiModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ManticUiModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ManticUiModule, never, [typeof AllowedCharsPipe, typeof AnimationComponent, typeof AutoComponent, typeof AutoDirective, typeof ArrayPipe, typeof BasicDirective, typeof BreadcrumbComponent, typeof ButtonComponent, typeof ButtonDefaultsComponent, typeof ButtonDirective, typeof ButtonGroupComponent, typeof CardComponent, typeof CardGroupComponent, typeof CeilPipe, typeof CellComponent, typeof ChatComponent, typeof ChatDefaultsComponent, typeof ChatMessageComponent, typeof CheckboxComponent, typeof CheckboxDefaultsComponent, typeof CircularProgressComponent, typeof ColorDirective, typeof ContextMenuComponent, typeof ContextMenuItemComponent, typeof DataSourceComponent, typeof DateInputComponent, typeof DebuggerPipe, typeof DebugPipe, typeof DimmerComponent, typeof DimmerDefaultsComponent, typeof DisabledDirective, typeof DividerComponent, typeof DocumentNoIndexComponent, typeof DocumentTitleComponent, typeof DropdownComponent, typeof DropdownDefaultsComponent, typeof DropdownGroupComponent, typeof DropdownItemComponent, typeof ErrorComponent, typeof ExpanderComponent, typeof ExpanderDefaultsComponent, typeof ExpanderHeaderComponent, typeof ExpanderIconComponent, typeof ExpanderPartComponent, typeof FallbackForDirective, typeof FieldComponent, typeof FieldDefaultsComponent, typeof FieldGroupComponent, typeof FileInputComponent, typeof FillComponent, typeof FillDirective, typeof FlagComponent, typeof FlexComponent, typeof FlexDirective, typeof FloorPipe, typeof FluidDirective, typeof FooterComponent, typeof FooterLinkComponent, typeof FooterLinkTemplateDirective, typeof FormComponent, typeof FormDefaultsComponent, typeof FormElementRendererComponent, typeof FormElementRenderer2Component, typeof FormRendererComponent, typeof GridComponent, typeof GrowComponent, typeof GrowDirective, typeof HeaderComponent, typeof HeaderDefaultsComponent, typeof HeaderDirective, typeof HideOnEmptyTemplateDirective, typeof HideOnExistingTemplateDirective, typeof IconButtonComponent, typeof IconComponent, typeof InfoComponent, typeof InputComponent, typeof InputDefaultsComponent, typeof InvertedDirective, typeof ImageUploadComponent, typeof IsFilledPipe, typeof IsEmailPipe, typeof LabelComponent, typeof LabelDropdownComponent, typeof LabelDropdownDefaultsComponent, typeof LayoutComponent, typeof LayoutDefaultsComponent, typeof LoaderComponent, typeof LoadingDirective, typeof LogPipe, typeof MarkdownRendererComponent, typeof MenuComponent, typeof MenuHeaderComponent, typeof MenuItemComponent, typeof MenuItemDirective, typeof MenuLinkComponent, typeof MenuLinkTemplateDirective, typeof MessageComponent, typeof MessageDefaultsComponent, typeof ModalComponent, typeof ModalDefaultsComponent, typeof ModalFooterComponent, typeof ModalHeaderComponent, typeof NotificationComponent, typeof NumericInputComponent, typeof OrComponent, typeof PadEndPipe, typeof PadStartPipe, typeof PositionAbsoluteDirective, typeof RadioComponent, typeof ReadonlyDirective, typeof ReadOnlyDirective, typeof RoundPipe, typeof RowComponent, typeof SafePipe, typeof SegmentComponent, typeof SegmentDefaultsComponent, typeof SegmentGroupComponent, typeof ShrinkComponent, typeof ShrinkDirective, typeof SidebarComponent, typeof SliderComponent, typeof SubmitComponent, typeof TabComponent, typeof TabGroupDefaultsComponent, typeof TableComponent, typeof TableDefaultsComponent, typeof TabGroupComponent, typeof TemplateComponent, typeof TemplateOutletComponent, typeof TextareaComponent, typeof TextareaDefaultsComponent, typeof TextContainerComponent, typeof TimeInputComponent, typeof TitlePipe, typeof ToBodyDirective, typeof ToggleButtonComponent, typeof ToggleComponent, typeof ToTemplateDirective, typeof WarningComponent], [typeof AllowedCharsPipe, typeof AnimationComponent, typeof AutoComponent, typeof AutoDirective, typeof ArrayPipe, typeof BasicDirective, typeof BreadcrumbComponent, typeof ButtonComponent, typeof ButtonDefaultsComponent, typeof ButtonDirective, typeof ButtonGroupComponent, typeof CardComponent, typeof CardGroupComponent, typeof CeilPipe, typeof CellComponent, typeof ChatComponent, typeof ChatDefaultsComponent, typeof ChatMessageComponent, typeof CheckboxComponent, typeof CheckboxDefaultsComponent, typeof CircularProgressComponent, typeof ColorDirective, typeof ContextMenuComponent, typeof ContextMenuItemComponent, typeof DataSourceComponent, typeof DateInputComponent, typeof DebuggerPipe, typeof DebugPipe, typeof DimmerComponent, typeof DimmerDefaultsComponent, typeof DisabledDirective, typeof DividerComponent, typeof DocumentNoIndexComponent, typeof DocumentTitleComponent, typeof DropdownComponent, typeof DropdownDefaultsComponent, typeof DropdownGroupComponent, typeof DropdownItemComponent, typeof ErrorComponent, typeof ExpanderComponent, typeof ExpanderDefaultsComponent, typeof ExpanderHeaderComponent, typeof ExpanderIconComponent, typeof ExpanderPartComponent, typeof FallbackForDirective, typeof FieldComponent, typeof FieldDefaultsComponent, typeof FieldGroupComponent, typeof FileInputComponent, typeof FillComponent, typeof FillDirective, typeof FlagComponent, typeof FlexComponent, typeof FlexDirective, typeof FloorPipe, typeof FluidDirective, typeof FooterComponent, typeof FooterLinkComponent, typeof FooterLinkTemplateDirective, typeof FormComponent, typeof FormDefaultsComponent, typeof FormElementRendererComponent, typeof FormElementRenderer2Component, typeof FormRendererComponent, typeof GridComponent, typeof GrowComponent, typeof GrowDirective, typeof HeaderComponent, typeof HeaderDefaultsComponent, typeof HeaderDirective, typeof HideOnEmptyTemplateDirective, typeof HideOnExistingTemplateDirective, typeof IconButtonComponent, typeof IconComponent, typeof InfoComponent, typeof InputComponent, typeof InputDefaultsComponent, typeof InvertedDirective, typeof ImageUploadComponent, typeof IsFilledPipe, typeof IsEmailPipe, typeof LabelComponent, typeof LabelDropdownComponent, typeof LabelDropdownDefaultsComponent, typeof LayoutComponent, typeof LayoutDefaultsComponent, typeof LoaderComponent, typeof LoadingDirective, typeof LogPipe, typeof MarkdownRendererComponent, typeof MenuComponent, typeof MenuHeaderComponent, typeof MenuItemComponent, typeof MenuItemDirective, typeof MenuLinkComponent, typeof MenuLinkTemplateDirective, typeof MessageComponent, typeof MessageDefaultsComponent, typeof ModalComponent, typeof ModalDefaultsComponent, typeof ModalFooterComponent, typeof ModalHeaderComponent, typeof NotificationComponent, typeof NumericInputComponent, typeof OrComponent, typeof PadEndPipe, typeof PadStartPipe, typeof PositionAbsoluteDirective, typeof RadioComponent, typeof ReadonlyDirective, typeof ReadOnlyDirective, typeof RoundPipe, typeof RowComponent, typeof SafePipe, typeof SegmentComponent, typeof SegmentDefaultsComponent, typeof SegmentGroupComponent, typeof ShrinkComponent, typeof ShrinkDirective, typeof SidebarComponent, typeof SliderComponent, typeof SubmitComponent, typeof TabComponent, typeof TabGroupDefaultsComponent, typeof TableComponent, typeof TableDefaultsComponent, typeof TabGroupComponent, typeof TemplateComponent, typeof TemplateOutletComponent, typeof TextareaComponent, typeof TextareaDefaultsComponent, typeof TextContainerComponent, typeof TimeInputComponent, typeof TitlePipe, typeof ToBodyDirective, typeof ToggleButtonComponent, typeof ToggleComponent, typeof ToTemplateDirective, typeof WarningComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ManticUiModule>;
}

declare type KeyCode = 'Space' | 'Enter' | 'Escape';
declare class Key {
    readonly code: string;
    static readonly space: Key;
    static readonly enter: Key;
    static readonly escape: Key;
    constructor(code: string);
    is(event: KeyboardEvent): boolean;
    static is(event: KeyboardEvent, ...keys: (KeyCode | Key)[]): boolean;
}

/**
 * Returns a copy of a section of an array.
 * For both start and end, a negative index can be used to indicate an offset from the end of the array.
 * For example, -2 refers to the second to last element of the array.
 * @param start The beginning index of the specified portion of the array.
 * If start is undefined, then the slice begins at index 0.
 * @param end The end index of the specified portion of the array. This is exclusive of the element at the index 'end'.
 * If end is undefined, then the slice extends to the end of the array.
 */
declare class SlicePipe implements PipeTransform {
    transform<T>(array: T[], from?: number, to?: number): T[];
    static ɵfac: i0.ɵɵFactoryDeclaration<SlicePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SlicePipe, "mSlice", true>;
}

declare class BaseHrefService {
    get(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseHrefService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<BaseHrefService>;
}

declare class EnvironmentService {
    private baseUrl?;
    getBaseUrl(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EnvironmentService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<EnvironmentService>;
}

declare class FaviconService {
    private canvasElement;
    private faviconElement;
    getContext(): CanvasRenderingContext2D | undefined;
    private getCanvas;
    update(): void;
    private getFaviconElement;
    static ɵfac: i0.ɵɵFactoryDeclaration<FaviconService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FaviconService>;
}

declare class TemplateService {
    private readonly subscriptions;
    private readonly templates;
    show(names: string | string[], template: Template): void;
    hide(names: string | string[], template: Template): void;
    get(names: string | string[]): Observable<Template | undefined>;
    private notify;
    static ɵfac: i0.ɵɵFactoryDeclaration<TemplateService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TemplateService>;
}

declare class ThemeService {
    private readonly versionSubject;
    version: rxjs.Observable<string>;
    setVersion(version: string): void;
    prefersDark(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThemeService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ThemeService>;
}

export { ActiveDirective, AllowedCharsPipe, AnimationComponent, ArrayPipe, AsyncAction, AutoComponent, AutoDirective, BaseComponent, BaseDirective, BaseHrefService, BasicDirective, BreadcrumbComponent, ButtonBaseComponent, ButtonComponent, ButtonDefaultsComponent, ButtonDirective, ButtonGroupComponent, CardComponent, CardGroupComponent, CeilPipe, CellComponent, ChatComponent, ChatDefaultsComponent, ChatMessageComponent, CheckboxComponent, CheckboxDefaultsComponent, CircularProgressComponent, ColorDirective, ComponentParser, ContextMenuComponent, ContextMenuItemComponent, DataSourceComponent, DataSourceRequest, DateHelper, DateInputComponent, DebugPipe, DebuggerPipe, Destroyable, DestroyableComponent, DestroyableDirective, DimmerComponent, DimmerDefaultsComponent, DisabledDirective, DividerComponent, DocumentNoIndexComponent, DocumentTitleComponent, DropdownComponent, DropdownDefaultsComponent, DropdownGroupComponent, DropdownItemComponent, DropdownValue, DynamicComponentComponent, EnvironmentService, ErrorComponent, ExpanderComponent, ExpanderDefaultsComponent, ExpanderHeaderComponent, ExpanderIconComponent, ExpanderPartComponent, ExternalRouteComponent, FallbackForDirective, FaviconService, FieldComponent, FieldDefaultsComponent, FieldGroupComponent, FileInputComponent, FillComponent, FillDirective, FlagComponent, FlexComponent, FlexDirective, FloorPipe, FluidDirective, FooterComponent, FooterLinkComponent, FooterLinkTemplateDirective, FormComponent, FormDefaultsComponent, FormElement, FormElementRenderer2Component, FormElementRendererComponent, FormRendererComponent, FormRendererService, FormValidationNotifier, GridComponent, GrowComponent, GrowDirective, HeaderComponent, HeaderDefaultsComponent, HeaderDirective, HideOnEmptyTemplateDirective, HideOnExistingTemplateDirective, IconButtonComponent, IconComponent, IgnoredDirective, ImageUploadComponent, InfoComponent, InlineDirective, InputComponent, InputDefaultsComponent, InvertedDirective, InvertibleComponent, IsEmailPipe, IsFilledPipe, Key, LabelComponent, LabelDropdownComponent, LabelDropdownDefaultsComponent, LayoutComponent, LayoutDefaultsComponent, LoaderComponent, LoadingDirective, LocalizeComponent, LogPipe, LowerCaseUrlSerializer, LowerCaseUrlSerializerModule, ManticTitleStrategy, ManticTitleStrategyModule, ManticUiModule, MarkdownRendererComponent, Math2, MenuComponent, MenuHeaderComponent, MenuItemComponent, MenuItemDirective, MenuLinkComponent, MenuLinkTemplateDirective, MessageComponent, MessageDefaultsComponent, ModalComponent, ModalDefaultsComponent, ModalFooterComponent, ModalHeaderComponent, Mouse, NotificationComponent, NotificationDefaultsComponent, NotificationRef, NotificationService, NumericInputComponent, ObjectHelper, OrComponent, PadEndPipe, PadStartPipe, PointingDirective, PositionAbsoluteDirective, RadioComponent, ReadOnlyDirective, ReadonlyDirective, RoundPipe, RowComponent, SafePipe, SegmentComponent, SegmentDefaultsComponent, SegmentGroupComponent, ShrinkComponent, ShrinkDirective, SidebarComponent, SlicePipe, SliderComponent, SubmitComponent, TabComponent, TabGroupComponent, TabGroupDefaultsComponent, TableComponent, TableDefaultsComponent, TemplateComponent, TemplateOutletComponent, TemplateService, TextContainerComponent, TextareaComponent, TextareaDefaultsComponent, ThemeService, TimeInputComponent, Timespan, TitlePipe, ToBodyDirective, ToTemplateDirective, ToggleButtonComponent, ToggleComponent, WarningComponent, cast, isFormValidation, localize, localizeDictionary, mantic, manticTitleStrategyConfigurationToken, mapVoid, notificationToken, provideDynamicComponent, provideFormElement, provideLocale, provideManticTitleStrategy, toBoolean };
export type { Align, BooleanLike, CellAlign, CellFloat, Changes, ChatMessage, ChatOption, ColorName, ExternalRouteData, FieldsType, FlexAlignItems, FlexDirection, FlexJustifyContent, FormAreaElement, FormButtonElement, FormCellElement, FormCheckboxElement, FormDataElement, FormDataElementWithChildren, FormDivider, FormDropDownElement, FormElementBase, FormElements, FormError, FormFieldGroupElement, FormGridElement, FormHeader, FormInfo, FormInputElement, FormLabelElement, FormLayout, FormMessage, FormMessageBase, FormValidation, FormWarning, GridWidth, HeaderSize, IconSize, IconType, InputIconPosition, InputType, KeyCode, LabelPointing, LoaderSize, ManticIconSize, ManticTitleStrategyCondition, ManticTitleStrategyConfiguration, MenuPosition, MessageAttached, ModalSize, Notification, NotificationType, Pointing, SegmentAttached, SidebarPosition, SidebarWidth, ValidationPipe };