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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type IconType = string | IconProp;

interface LabelOptions {
    position: Signal<LabelPosition>;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

interface ContextMenuEvent extends Event {
    contextMenuTarget?: ContextMenuComponent;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

declare class DropdownDefaultsComponent implements OnDestroy {
    private readonly previousDropdownIcon;
    private readonly previousDropdownIconSize;
    private readonly previousDeleteIcon;
    private readonly previousDeleteIconSize;
    private currentDropdownIcon?;
    private currentDropdownIconSize?;
    private currentDeleteIcon?;
    private currentDeleteIconSize?;
    readonly dropdownIcon: _angular_core.InputSignal<IconType | undefined>;
    readonly dropdownIconSize: _angular_core.InputSignal<IconSize>;
    readonly deleteIcon: _angular_core.InputSignal<IconType | undefined>;
    readonly deleteIconSize: _angular_core.InputSignal<IconSize>;
    readonly inverted: _angular_core.InputSignal<boolean | undefined>;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DropdownDefaultsComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DropdownDefaultsComponent, "m-dropdown-defaults", never, { "dropdownIcon": { "alias": "dropdownIcon"; "required": false; "isSignal": true; }; "dropdownIconSize": { "alias": "dropdownIconSize"; "required": false; "isSignal": true; }; "deleteIcon": { "alias": "deleteIcon"; "required": false; "isSignal": true; }; "deleteIconSize": { "alias": "deleteIconSize"; "required": false; "isSignal": true; }; "inverted": { "alias": "inverted"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class DropdownComponent extends InvertibleComponent implements OnInit {
    static readonly defaults: {
        dropdownIcon: _angular_core.WritableSignal<IconType>;
        dropdownIconSize: _angular_core.WritableSignal<IconSize>;
        deleteIcon: _angular_core.WritableSignal<IconType>;
        deleteIconSize: _angular_core.WritableSignal<IconSize>;
        inverted: _angular_core.WritableSignal<boolean>;
    };
    private static readonly upwardThreshold;
    private static readonly viewportMargin;
    private readonly dropDownSelectionService;
    private readonly zone;
    protected readonly defaults: {
        dropdownIcon: _angular_core.WritableSignal<IconType>;
        dropdownIconSize: _angular_core.WritableSignal<IconSize>;
        deleteIcon: _angular_core.WritableSignal<IconType>;
        deleteIconSize: _angular_core.WritableSignal<IconSize>;
        inverted: _angular_core.WritableSignal<boolean>;
    };
    protected readonly textElement: _angular_core.Signal<ElementRef<HTMLDivElement> | undefined>;
    protected readonly menuElement: _angular_core.Signal<ElementRef<HTMLDivElement> | undefined>;
    protected readonly inputElement: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
    private readonly contentItems;
    private readonly viewItems;
    protected readonly itemComponents: _angular_core.Signal<DropdownItemComponent[]>;
    readonly multiple: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly search: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly attachedLeft: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly attachedTop: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly attachedRight: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly attachedBottom: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly placeholder: _angular_core.InputSignal<string | undefined>;
    readonly fluid: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly animationDuration: _angular_core.InputSignal<number>;
    readonly filter: _angular_core.ModelSignal<string | undefined>;
    readonly name: _angular_core.ModelSignal<string | undefined>;
    readonly filterValue: _angular_core.InputSignal<boolean>;
    readonly filterText: _angular_core.InputSignal<boolean>;
    readonly icon: _angular_core.InputSignal<IconType | undefined>;
    readonly iconSize: _angular_core.InputSignal<IconSize>;
    readonly dropdownIcon: _angular_core.InputSignal<IconType | undefined>;
    readonly dropdownIconSize: _angular_core.InputSignal<IconSize>;
    readonly deleteIcon: _angular_core.InputSignal<IconType | undefined>;
    readonly deleteIconSize: _angular_core.InputSignal<IconSize>;
    readonly filterType: _angular_core.InputSignal<"startsWith" | "contains">;
    readonly selectFirst: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly allowFreeText: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly valueInput: _angular_core.InputSignal<unknown>;
    private readonly valueState;
    readonly value: _angular_core.Signal<unknown>;
    readonly itemsInput: _angular_core.InputSignal<DropdownValue<unknown>[] | null | undefined>;
    private readonly itemsState;
    readonly items: _angular_core.Signal<DropdownValue<unknown>[] | undefined>;
    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly disabledChange: _angular_core.OutputEmitterRef<boolean>;
    readonly disabled: TransformableModel<boolean, BooleanLike>;
    readonly readonlyInput: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly readonlyChange: _angular_core.OutputEmitterRef<boolean>;
    readonly readonly: TransformableModel<boolean, BooleanLike>;
    readonly tabIndex: _angular_core.Signal<0 | undefined>;
    readonly searchClass: _angular_core.Signal<boolean>;
    readonly isActive: _angular_core.WritableSignal<boolean>;
    readonly isDefault: _angular_core.WritableSignal<boolean>;
    readonly isMenuVisible: _angular_core.WritableSignal<boolean>;
    readonly isHidden: _angular_core.WritableSignal<boolean>;
    readonly isSlidingIn: _angular_core.WritableSignal<boolean>;
    readonly isSlidingOut: _angular_core.WritableSignal<boolean>;
    readonly isFiltered: _angular_core.WritableSignal<boolean>;
    readonly isLoading: _angular_core.WritableSignal<boolean>;
    readonly selectedIndex: _angular_core.WritableSignal<number | undefined>;
    readonly selectedItem: _angular_core.WritableSignal<DropdownValue<unknown> | undefined>;
    readonly selectedItems: _angular_core.WritableSignal<DropdownValue<unknown>[]>;
    private readonly isSystemUpward;
    private readonly menuMaxHeight;
    readonly isUpwardClass: _angular_core.Signal<boolean>;
    readonly menuMaxHeightPx: _angular_core.Signal<number | undefined>;
    private readonly isFocused;
    private readonly keepOpen;
    readonly hasItems: _angular_core.Signal<boolean>;
    readonly valueChange: _angular_core.OutputEmitterRef<unknown>;
    constructor();
    private static readItemValue;
    ngOnInit(): void;
    focus(): void;
    blur(): void;
    toggle(): void;
    protected onKeyDown(event: KeyboardEvent): void;
    protected deleteClick(item: DropdownValue, event: MouseEvent): void;
    open(): void;
    close(): void;
    private setValue;
    private setItems;
    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;
    /**
     * Intersects the viewport with every scrolling/clipping ancestor so the dropdown
     * fits inside the visible area even when an outer container clips it.
     */
    private getClippingBounds;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DropdownComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DropdownComponent, "m-dropdown", never, { "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "search": { "alias": "search"; "required": false; "isSignal": true; }; "attachedLeft": { "alias": "attachedLeft"; "required": false; "isSignal": true; }; "attachedTop": { "alias": "attachedTop"; "required": false; "isSignal": true; }; "attachedRight": { "alias": "attachedRight"; "required": false; "isSignal": true; }; "attachedBottom": { "alias": "attachedBottom"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "fluid": { "alias": "fluid"; "required": false; "isSignal": true; }; "animationDuration": { "alias": "animationDuration"; "required": false; "isSignal": true; }; "filter": { "alias": "filter"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "filterValue": { "alias": "filterValue"; "required": false; "isSignal": true; }; "filterText": { "alias": "filterText"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconSize": { "alias": "iconSize"; "required": false; "isSignal": true; }; "dropdownIcon": { "alias": "dropdownIcon"; "required": false; "isSignal": true; }; "dropdownIconSize": { "alias": "dropdownIconSize"; "required": false; "isSignal": true; }; "deleteIcon": { "alias": "deleteIcon"; "required": false; "isSignal": true; }; "deleteIconSize": { "alias": "deleteIconSize"; "required": false; "isSignal": true; }; "filterType": { "alias": "filterType"; "required": false; "isSignal": true; }; "selectFirst": { "alias": "selectFirst"; "required": false; "isSignal": true; }; "allowFreeText": { "alias": "allowFreeText"; "required": false; "isSignal": true; }; "valueInput": { "alias": "value"; "required": false; "isSignal": true; }; "itemsInput": { "alias": "items"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonlyInput": { "alias": "readonly"; "required": false; "isSignal": true; }; }, { "filter": "filterChange"; "name": "nameChange"; "disabledChange": "disabledChange"; "readonlyChange": "readonlyChange"; "valueChange": "valueChange"; }, ["contentItems"], ["*"], true, never>;
}

declare class DropdownGroupComponent implements AfterViewInit {
    private readonly viewContainerRef;
    readonly label: _angular_core.InputSignal<string | undefined>;
    readonly icon: _angular_core.InputSignal<IconType | undefined>;
    readonly iconSize: _angular_core.InputSignal<IconSize>;
    protected readonly contentTemplate: _angular_core.Signal<TemplateRef<unknown> | undefined>;
    ngAfterViewInit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DropdownGroupComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DropdownGroupComponent, "m-dropdown-group", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconSize": { "alias": "iconSize"; "required": false; "isSignal": true; }; }, {}, 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: _angular_core.ɵɵFactoryDeclaration<DocumentTitleComponent, never>;
    static ɵcmp: _angular_core.ɵɵ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: _angular_core.ɵɵFactoryDeclaration<DocumentNoIndexComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DocumentNoIndexComponent, "m-document-no-index", never, {}, {}, never, never, true, never>;
}

declare class ErrorComponent extends InvertibleComponent {
    readonly ignored: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ErrorComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ErrorComponent, "m-error", never, { "ignored": { "alias": "ignored"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class ExpanderHeaderComponent {
    readonly template: _angular_core.Signal<TemplateRef<any> | undefined>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ExpanderHeaderComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ExpanderHeaderComponent, "m-expander-header", never, {}, {}, never, ["*"], true, never>;
}

declare class ExpanderComponent extends BaseComponent {
    static readonly defaults: {
        dropdownIcon: _angular_core.WritableSignal<IconType>;
        dropdownIconSize: _angular_core.WritableSignal<IconSize>;
    };
    protected readonly defaults: {
        dropdownIcon: _angular_core.WritableSignal<IconType>;
        dropdownIconSize: _angular_core.WritableSignal<IconSize>;
    };
    readonly header: _angular_core.InputSignal<string | undefined>;
    readonly expandedInput: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly expandedChange: _angular_core.OutputEmitterRef<boolean>;
    readonly expanded: TransformableModel<boolean, BooleanLike>;
    readonly dropdownIcon: _angular_core.InputSignal<IconType | undefined>;
    readonly dropdownIconSize: _angular_core.InputSignal<IconSize>;
    readonly basic: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly iconPosition: _angular_core.InputSignal<"left" | "right">;
    protected readonly headerTemplate: _angular_core.Signal<ExpanderHeaderComponent | undefined>;
    constructor();
    toggle(): void;
    collapse(): void;
    expand(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ExpanderComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ExpanderComponent, "m-expander", never, { "header": { "alias": "header"; "required": false; "isSignal": true; }; "expandedInput": { "alias": "expanded"; "required": false; "isSignal": true; }; "dropdownIcon": { "alias": "dropdownIcon"; "required": false; "isSignal": true; }; "dropdownIconSize": { "alias": "dropdownIconSize"; "required": false; "isSignal": true; }; "basic": { "alias": "basic"; "required": false; "isSignal": true; }; "iconPosition": { "alias": "iconPosition"; "required": false; "isSignal": true; }; }, { "expandedChange": "expandedChange"; }, ["headerTemplate"], ["*"], true, never>;
}

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

declare class ExpanderIconComponent extends BaseComponent {
    protected readonly defaults: {
        dropdownIcon: _angular_core.WritableSignal<IconType>;
        dropdownIconSize: _angular_core.WritableSignal<IconSize>;
    };
    readonly expandedInput: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly expandedChange: _angular_core.OutputEmitterRef<boolean>;
    readonly expanded: TransformableModel<boolean, BooleanLike>;
    readonly dropdownIcon: _angular_core.InputSignal<IconType | undefined>;
    readonly dropdownIconSize: _angular_core.InputSignal<IconSize>;
    constructor();
    toggle(): void;
    collapse(): void;
    expand(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ExpanderIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ExpanderIconComponent, "m-expander-icon", never, { "expandedInput": { "alias": "expanded"; "required": false; "isSignal": true; }; "dropdownIcon": { "alias": "dropdownIcon"; "required": false; "isSignal": true; }; "dropdownIconSize": { "alias": "dropdownIconSize"; "required": false; "isSignal": true; }; }, { "expandedChange": "expandedChange"; }, never, never, true, never>;
}

declare class ExpanderPartComponent extends BaseComponent {
    readonly expandable: _angular_core.InputSignal<boolean | undefined>;
    readonly expandedInput: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly expandedChange: _angular_core.OutputEmitterRef<boolean>;
    readonly expanded: TransformableModel<boolean, BooleanLike>;
    readonly dropdownIcon: _angular_core.InputSignal<IconType | undefined>;
    readonly dropdownIconSize: _angular_core.InputSignal<IconSize>;
    protected readonly icon: _angular_core.Signal<ExpanderIconComponent | undefined>;
    constructor();
    protected onClick(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ExpanderPartComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ExpanderPartComponent, "m-expander-part", never, { "expandable": { "alias": "expandable"; "required": false; "isSignal": true; }; "expandedInput": { "alias": "expanded"; "required": false; "isSignal": true; }; "dropdownIcon": { "alias": "dropdownIcon"; "required": false; "isSignal": true; }; "dropdownIconSize": { "alias": "dropdownIconSize"; "required": false; "isSignal": true; }; }, { "expandedChange": "expandedChange"; }, never, ["*"], true, never>;
}

declare class FlagComponent {
    readonly flag: _angular_core.InputSignal<string | undefined>;
    readonly size: _angular_core.InputSignal<IconSize>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FlagComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FlagComponent, "m-flag", never, { "flag": { "alias": "flag"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, 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 {
    protected readonly internalValue: _angular_core.WritableSignal<string | null>;
    protected readonly valueState: _angular_core.WritableSignal<Date | undefined>;
    readonly valueInput: _angular_core.InputSignalWithTransform<Date | undefined, string | number | Date | undefined>;
    readonly dateInput: _angular_core.InputSignalWithTransform<Date | undefined, string | number | Date | undefined>;
    readonly default: _angular_core.InputSignal<Date>;
    readonly min: _angular_core.InputSignal<Date | undefined>;
    readonly max: _angular_core.InputSignal<Date | undefined>;
    readonly showDay: _angular_core.InputSignalWithTransform<boolean, _mantic_ui_angular.BooleanLike>;
    readonly weekendColor: _angular_core.InputSignal<ColorName | undefined>;
    readonly value: _angular_core.Signal<Date | undefined>;
    readonly date: _angular_core.Signal<Date>;
    readonly valueChange: _angular_core.OutputEmitterRef<Date | undefined>;
    readonly dateChange: _angular_core.OutputEmitterRef<Date>;
    protected set contentInputElement(input: ElementRef<HTMLInputElement>);
    protected set viewInputElement(input: ElementRef<HTMLInputElement>);
    constructor();
    ngOnInit(): void;
    protected onInternalChange(rawValue: string): void;
    private applyValue;
    private static coerceDate;
    private setInternalValue;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DateInputComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DateInputComponent, "m-date-input", never, { "valueInput": { "alias": "value"; "required": false; "isSignal": true; }; "dateInput": { "alias": "date"; "required": false; "isSignal": true; }; "default": { "alias": "default"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "showDay": { "alias": "showDay"; "required": false; "isSignal": true; }; "weekendColor": { "alias": "weekendColor"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "dateChange": "dateChange"; }, ["contentInputElement"], ["*", "m-label", "m-label-dropdown", "m-button", "m-icon-button"], true, never>;
}

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

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

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

declare class TextareaComponent extends InvertibleComponent {
    static readonly defaults: {
        inverted: _angular_core.WritableSignal<boolean>;
    };
    protected readonly valueState: _angular_core.WritableSignal<string | undefined>;
    textareaElement?: ElementRef<HTMLTextAreaElement>;
    readonly name: _angular_core.ModelSignal<string | undefined>;
    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly disabledChange: _angular_core.OutputEmitterRef<boolean>;
    readonly disabled: TransformableModel<boolean, BooleanLike>;
    readonly readonlyInput: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly readonlyChange: _angular_core.OutputEmitterRef<boolean>;
    readonly readonly: TransformableModel<boolean, BooleanLike>;
    readonly hasError: _angular_core.InputSignal<boolean>;
    readonly placeholder: _angular_core.InputSignal<string | undefined>;
    readonly valueInput: _angular_core.InputSignal<string | undefined>;
    readonly textInput: _angular_core.InputSignal<string | undefined>;
    readonly default: _angular_core.InputSignal<string>;
    readonly inputId: _angular_core.InputSignal<string | undefined>;
    readonly value: _angular_core.Signal<string | undefined>;
    readonly text: _angular_core.Signal<string>;
    readonly valueChange: _angular_core.OutputEmitterRef<string | undefined>;
    readonly textChange: _angular_core.OutputEmitterRef<string>;
    readonly keyDown: _angular_core.OutputEmitterRef<KeyboardEvent>;
    readonly keyUp: _angular_core.OutputEmitterRef<KeyboardEvent>;
    readonly keyPress: _angular_core.OutputEmitterRef<Event>;
    readonly blur: _angular_core.OutputEmitterRef<FocusEvent>;
    readonly focus: _angular_core.OutputEmitterRef<FocusEvent>;
    readonly focusin: _angular_core.OutputEmitterRef<FocusEvent>;
    readonly focusout: _angular_core.OutputEmitterRef<FocusEvent>;
    protected set contentTextareaElement(textarea: ElementRef<HTMLTextAreaElement>);
    protected set viewInputElement(textarea: ElementRef<HTMLTextAreaElement>);
    constructor();
    protected setValue(value: string | undefined): void;
    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: _angular_core.ɵɵFactoryDeclaration<TextareaComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TextareaComponent, "m-textarea", never, { "name": { "alias": "name"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonlyInput": { "alias": "readonly"; "required": false; "isSignal": true; }; "hasError": { "alias": "hasError"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "valueInput": { "alias": "value"; "required": false; "isSignal": true; }; "textInput": { "alias": "text"; "required": false; "isSignal": true; }; "default": { "alias": "default"; "required": false; "isSignal": true; }; "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; }, { "name": "nameChange"; "disabledChange": "disabledChange"; "readonlyChange": "readonlyChange"; "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();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToggleComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ToggleComponent, "m-toggle", never, {}, {}, never, ["*"], true, never>;
}

declare class FieldComponent extends BaseComponent {
    static readonly defaults: {
        hintIcon: _angular_core.WritableSignal<IconType>;
        hintIconSize: _angular_core.WritableSignal<IconSize>;
        errorIcon: _angular_core.WritableSignal<IconType>;
        errorIconSize: _angular_core.WritableSignal<IconSize>;
    };
    protected readonly defaults: {
        hintIcon: _angular_core.WritableSignal<IconType>;
        hintIconSize: _angular_core.WritableSignal<IconSize>;
        errorIcon: _angular_core.WritableSignal<IconType>;
        errorIconSize: _angular_core.WritableSignal<IconSize>;
    };
    private originalLabel?;
    private labelSaved;
    protected readonly wasAnytimeValid: _angular_core.WritableSignal<boolean>;
    protected readonly labelElement: _angular_core.Signal<ElementRef<HTMLLabelElement> | undefined>;
    protected readonly inputComponent: _angular_core.Signal<InputComponent | undefined>;
    protected readonly numericInputComponent: _angular_core.Signal<NumericInputComponent | undefined>;
    protected readonly dateInputComponent: _angular_core.Signal<DateInputComponent | undefined>;
    protected readonly checkboxComponent: _angular_core.Signal<CheckboxComponent | undefined>;
    protected readonly sliderComponent: _angular_core.Signal<SliderComponent | undefined>;
    protected readonly toggleComponent: _angular_core.Signal<ToggleComponent | undefined>;
    protected readonly radioComponent: _angular_core.Signal<RadioComponent | undefined>;
    protected readonly textareaComponent: _angular_core.Signal<TextareaComponent | undefined>;
    protected readonly dropDownComponent: _angular_core.Signal<DropdownComponent | undefined>;
    readonly name: _angular_core.InputSignal<string | undefined>;
    readonly label: _angular_core.InputSignal<string | undefined>;
    readonly hint: _angular_core.InputSignal<string | undefined>;
    readonly size: _angular_core.InputSignalWithTransform<FieldSize, ParsableFieldSize>;
    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly readonly: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly inline: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly hideInitialError: _angular_core.InputSignal<boolean>;
    readonly fill: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly ownLabel: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly forceLabel: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly valid: _angular_core.InputSignal<boolean | FormValidation | undefined>;
    readonly errorInput: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    private readonly errorState;
    readonly error: _angular_core.Signal<boolean>;
    protected readonly visibleError: _angular_core.WritableSignal<boolean>;
    readonly inlineValidationInput: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly inlineValidationChange: OutputEmitterRef<boolean>;
    readonly inlineValidation: TransformableModel<boolean, BooleanLike>;
    readonly errors: _angular_core.WritableSignal<FormError$1[]>;
    readonly errorChange: OutputEmitterRef<boolean>;
    readonly change: OutputEmitterRef<void>;
    constructor();
    forceValidation(): void;
    private propagateLabel;
    private setError;
    private applyValidation;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FieldComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FieldComponent, "m-field", never, { "name": { "alias": "name"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "inline": { "alias": "inline"; "required": false; "isSignal": true; }; "hideInitialError": { "alias": "hideInitialError"; "required": false; "isSignal": true; }; "fill": { "alias": "fill"; "required": false; "isSignal": true; }; "ownLabel": { "alias": "ownLabel"; "required": false; "isSignal": true; }; "forceLabel": { "alias": "forceLabel"; "required": false; "isSignal": true; }; "valid": { "alias": "valid"; "required": false; "isSignal": true; }; "errorInput": { "alias": "error"; "required": false; "isSignal": true; }; "inlineValidationInput": { "alias": "inlineValidation"; "required": false; "isSignal": true; }; }, { "inlineValidationChange": "inlineValidationChange"; "errorChange": "errorChange"; "change": "change"; }, ["labelElement", "inputComponent", "numericInputComponent", "dateInputComponent", "checkboxComponent", "sliderComponent", "toggleComponent", "radioComponent", "textareaComponent", "dropDownComponent"], ["*"], true, never>;
}

declare type FieldsType = '' | 'two' | 'three' | 'four' | 'five' | 'six' | 'seven' | 'eight' | 'nine' | 'ten' | number;

declare class FieldGroupComponent extends BaseComponent implements OnDestroy {
    private static readonly fieldClasses;
    private readonly changeSubscriptions;
    readonly fieldComponents: _angular_core.Signal<readonly FieldComponent[]>;
    readonly fieldsInput: _angular_core.InputSignalWithTransform<FieldsType | undefined, FieldsType>;
    private readonly fieldsAutoValue;
    readonly fields: _angular_core.Signal<FieldsType | undefined>;
    readonly grouped: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly inline: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly inlineValidationInput: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly inlineValidationChange: _angular_core.OutputEmitterRef<boolean>;
    readonly inlineValidation: TransformableModel<boolean, BooleanLike>;
    readonly errorInput: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    private readonly errorState;
    readonly error: _angular_core.Signal<boolean>;
    readonly errorChange: _angular_core.OutputEmitterRef<boolean>;
    readonly change: _angular_core.OutputEmitterRef<void>;
    constructor();
    ngOnDestroy(): void;
    private refreshChangeSubscriptions;
    private unsubscribeAllChanges;
    private refreshIsValid;
    private setError;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FieldGroupComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FieldGroupComponent, "m-field-group", never, { "fieldsInput": { "alias": "fields"; "required": false; "isSignal": true; }; "grouped": { "alias": "grouped"; "required": false; "isSignal": true; }; "inline": { "alias": "inline"; "required": false; "isSignal": true; }; "inlineValidationInput": { "alias": "inlineValidation"; "required": false; "isSignal": true; }; "errorInput": { "alias": "error"; "required": false; "isSignal": true; }; }, { "inlineValidationChange": "inlineValidationChange"; "errorChange": "errorChange"; "change": "change"; }, ["fieldComponents"], ["*"], true, never>;
}

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?;
    readonly hintIcon: _angular_core.InputSignal<IconType | undefined>;
    readonly hintIconSize: _angular_core.InputSignal<IconSize>;
    readonly errorIcon: _angular_core.InputSignal<IconType | undefined>;
    readonly errorIconSize: _angular_core.InputSignal<IconSize>;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FieldDefaultsComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FieldDefaultsComponent, "m-field-defaults", never, { "hintIcon": { "alias": "hintIcon"; "required": false; "isSignal": true; }; "hintIconSize": { "alias": "hintIconSize"; "required": false; "isSignal": true; }; "errorIcon": { "alias": "errorIcon"; "required": false; "isSignal": true; }; "errorIconSize": { "alias": "errorIconSize"; "required": false; "isSignal": true; }; }, {}, 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 readonly display = "flex";
    readonly column: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly reverse: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly alignItems: _angular_core.InputSignal<FlexAlignItems | undefined>;
    readonly justifyContent: _angular_core.InputSignal<FlexJustifyContent | undefined>;
    readonly gap: _angular_core.InputSignal<string | undefined>;
    readonly wrap: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly wrapReverse: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    protected readonly wrapStyle: _angular_core.Signal<"" | "wrap" | "wrap-reverse">;
    readonly direction: _angular_core.Signal<FlexDirection>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FlexDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FlexDirective, "[m-flex]", never, { "column": { "alias": "column"; "required": false; "isSignal": true; }; "reverse": { "alias": "reverse"; "required": false; "isSignal": true; }; "alignItems": { "alias": "alignItems"; "required": false; "isSignal": true; }; "justifyContent": { "alias": "justifyContent"; "required": false; "isSignal": true; }; "gap": { "alias": "gap"; "required": false; "isSignal": true; }; "wrap": { "alias": "wrap"; "required": false; "isSignal": true; }; "wrapReverse": { "alias": "wrapReverse"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

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

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

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

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

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

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

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

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

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

type OverflowValue = 'visible' | 'hidden' | 'clip' | 'scroll' | 'auto';

declare class OverflowDirective {
    static readonly default: {
        directive: typeof OverflowDirective;
        inputs: string[];
    };
    readonly overflow: _angular_core.InputSignal<"" | OverflowValue | undefined>;
    readonly overflowX: _angular_core.InputSignal<OverflowValue | undefined>;
    readonly overflowY: _angular_core.InputSignal<OverflowValue | undefined>;
    protected readonly effectiveOverflowX: _angular_core.Signal<OverflowValue | undefined>;
    protected readonly effectiveOverflowY: _angular_core.Signal<OverflowValue | undefined>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverflowDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OverflowDirective, "[m-overflow]", never, { "overflow": { "alias": "m-overflow"; "required": false; "isSignal": true; }; "overflowX": { "alias": "m-overflow-x"; "required": false; "isSignal": true; }; "overflowY": { "alias": "m-overflow-y"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

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

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

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

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

declare class FormComponent extends InvertibleComponent {
    static readonly defaults: {
        inverted: _angular_core.WritableSignal<boolean>;
    };
    protected readonly flexDirective: FlexDirective | null;
    private readonly formValidationNotifier;
    private readonly fieldSubscriptions;
    private readonly groupSubscriptions;
    private readonly autoSubmitSubject;
    private autoSubmitSubscription;
    readonly fieldComponents: _angular_core.Signal<readonly FieldComponent[]>;
    readonly fieldGroupsComponents: _angular_core.Signal<readonly FieldGroupComponent[]>;
    readonly loading: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly action: _angular_core.InputSignal<string | undefined>;
    readonly autocomplete: _angular_core.InputSignal<"on" | "off" | undefined>;
    readonly enctype: _angular_core.InputSignal<"application/x-www-form-urlencoded" | "multipart/form-data" | "text/plain" | undefined>;
    readonly method: _angular_core.InputSignal<"get" | "post" | undefined>;
    readonly name: _angular_core.InputSignal<string | undefined>;
    readonly novalidate: _angular_core.InputSignal<boolean>;
    readonly success: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly warning: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly target: _angular_core.InputSignal<"_blank" | "_self" | "_parent" | "_top" | undefined>;
    readonly autoSubmit: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly autoSubmitThrottle: _angular_core.InputSignal<number>;
    readonly inlineValidation: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    private readonly errorState;
    readonly error: _angular_core.Signal<boolean>;
    private readonly isValidState;
    readonly isValid: _angular_core.Signal<boolean>;
    readonly submit: _angular_core.OutputEmitterRef<void>;
    readonly isValidChange: _angular_core.OutputEmitterRef<boolean>;
    constructor();
    changed(): void;
    validateAndSubmit(): void;
    protected onSubmit(event: SubmitEvent): void;
    private releaseFields;
    private subscribeFields;
    private releaseGroups;
    private subscribeGroups;
    private refreshAutoSubmitSubscription;
    private refreshIsValid;
    private refreshInlineValidation;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormComponent, "m-form", never, { "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "action": { "alias": "action"; "required": false; "isSignal": true; }; "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; "enctype": { "alias": "enctype"; "required": false; "isSignal": true; }; "method": { "alias": "method"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "novalidate": { "alias": "novalidate"; "required": false; "isSignal": true; }; "success": { "alias": "success"; "required": false; "isSignal": true; }; "warning": { "alias": "warning"; "required": false; "isSignal": true; }; "target": { "alias": "target"; "required": false; "isSignal": true; }; "autoSubmit": { "alias": "autoSubmit"; "required": false; "isSignal": true; }; "autoSubmitThrottle": { "alias": "autoSubmitThrottle"; "required": false; "isSignal": true; }; "inlineValidation": { "alias": "inlineValidation"; "required": false; "isSignal": true; }; }, { "submit": "submit"; "isValidChange": "isValidChange"; }, ["fieldComponents", "fieldGroupsComponents"], ["*"], true, never>;
}

declare class FormDefaultsComponent {
    readonly inverted: _angular_core.InputSignal<boolean | undefined>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormDefaultsComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormDefaultsComponent, "m-form-defaults", never, { "inverted": { "alias": "inverted"; "required": false; "isSignal": true; }; }, {}, 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: _angular_core.ɵɵFactoryDeclaration<FormValidationNotifier, never>;
    static ɵprov: _angular_core.ɵɵ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[];
    filter?: FormDropDownFilter | FormDropDownFilter[];
}
interface FormDropDownFilter {
    formField: string;
    dataField: string;
}
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 {
    readonly layout: _angular_core.InputSignal<FormLayout>;
    private readonly dataSourceElements;
    readonly dataSources: _angular_core.Signal<DataSourceComponent[]>;
    readonly dataInput: _angular_core.InputSignal<Record<string, unknown>>;
    private readonly dataState;
    readonly data: _angular_core.Signal<Record<string, unknown>>;
    readonly dataChange: _angular_core.OutputEmitterRef<unknown>;
    readonly execute: _angular_core.OutputEmitterRef<string>;
    constructor();
    protected onExecute(action: string): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormRendererComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormRendererComponent, "m-form-renderer", never, { "layout": { "alias": "layout"; "required": false; "isSignal": true; }; "dataInput": { "alias": "data"; "required": false; "isSignal": true; }; }, { "dataChange": "dataChange"; "execute": "execute"; }, ["dataSourceElements"], ["*"], true, never>;
}

declare class FormElementRendererComponent extends BaseComponent implements DoCheck {
    private readonly elementsDiffer;
    private readonly fieldClasses;
    private readonly dataCache;
    private readonly dropDownCache;
    private readonly filterTick;
    private readonly filterFields;
    private readonly lastFilterValues;
    readonly elements: _angular_core.InputSignal<FormElements[]>;
    readonly data: _angular_core.InputSignal<Record<string, unknown>>;
    readonly execute: _angular_core.OutputEmitterRef<string>;
    readonly fields: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    protected readonly anyData: _angular_core.Signal<any>;
    readonly dataSources: _angular_core.InputSignal<DataSourceComponent[]>;
    constructor();
    ngDoCheck(): void;
    protected getData(dataSource: string): Observable<Record<string, unknown>[]>;
    protected getItems(dropdown: FormDropDownElement): Observable<DropdownValue[]>;
    protected onExecute(action: string): void;
    private normalizeFilters;
    private collectFilterFields;
    private checkFilterValues;
    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: _angular_core.ɵɵFactoryDeclaration<FormElementRendererComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormElementRendererComponent, "m-form-element-renderer", never, { "elements": { "alias": "elements"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; "fields": { "alias": "fields"; "required": false; "isSignal": true; }; "dataSources": { "alias": "dataSources"; "required": false; "isSignal": true; }; }, { "execute": "execute"; }, never, never, true, never>;
}

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

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

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

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

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

declare class GridComponent extends BaseComponent {
    readonly vertically: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly divided: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly columns: _angular_core.InputSignalWithTransform<FieldSize | undefined, ParsableFieldSize>;
    readonly internally: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly celled: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly width: _angular_core.InputSignal<"equal" | undefined>;
    readonly noMargin: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GridComponent, "m-grid", never, { "vertically": { "alias": "vertically"; "required": false; "isSignal": true; }; "divided": { "alias": "divided"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "internally": { "alias": "internally"; "required": false; "isSignal": true; }; "celled": { "alias": "celled"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "noMargin": { "alias": "noMargin"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare type HeaderSize = 'huge' | 'large' | 'medium' | 'small' | 'tiny';

declare class HeaderComponent extends InvertibleComponent {
    static readonly defaults: {
        inverted: _angular_core.WritableSignal<boolean>;
    };
    readonly icon: _angular_core.InputSignal<IconType | undefined>;
    readonly iconSize: _angular_core.InputSignal<IconSize>;
    readonly size: _angular_core.InputSignal<HeaderSize | undefined>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HeaderComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HeaderComponent, "m-header", never, { "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconSize": { "alias": "iconSize"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class HeaderDefaultsComponent implements OnDestroy {
    private readonly previousInverted;
    private currentInverted?;
    readonly inverted: _angular_core.InputSignal<boolean | undefined>;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HeaderDefaultsComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HeaderDefaultsComponent, "m-header-defaults", never, { "inverted": { "alias": "inverted"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class IconComponent {
    readonly icon: _angular_core.InputSignal<IconType | undefined>;
    readonly size: _angular_core.InputSignal<IconSize>;
    readonly iconClass: _angular_core.InputSignal<string | undefined>;
    protected readonly mIcon: _angular_core.Signal<string | undefined>;
    protected readonly faIcon: _angular_core.Signal<[_fortawesome_fontawesome_common_types.IconPrefix, _fortawesome_fontawesome_common_types.IconName] | _fortawesome_fontawesome_common_types.IconLookup | undefined>;
    private readonly mappedSize;
    protected readonly mSize: _angular_core.Signal<ManticIconSize>;
    protected readonly faSize: _angular_core.Signal<SizeProp | undefined>;
    private static mapSize;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IconComponent, "m-icon", never, { "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "iconClass": { "alias": "iconClass"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class InfoComponent extends InvertibleComponent {
    readonly ignored: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InfoComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InfoComponent, "m-info", never, { "ignored": { "alias": "ignored"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class ImageUploadComponent extends ButtonBaseComponent {
    readonly previewImage: _angular_core.ModelSignal<string | undefined>;
    readonly radius: _angular_core.InputSignal<number | undefined>;
    readonly previewWidth: _angular_core.InputSignal<number | undefined>;
    readonly previewHeight: _angular_core.InputSignal<number | undefined>;
    readonly width: _angular_core.InputSignal<number | undefined>;
    readonly height: _angular_core.InputSignal<number | undefined>;
    readonly hidePreview: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly forcePreviewImageChange: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly upload: _angular_core.OutputEmitterRef<FileList>;
    constructor();
    protected onUpload(fileList: FileList | null): void;
    private showPreview;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ImageUploadComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ImageUploadComponent, "m-image-upload", never, { "previewImage": { "alias": "previewImage"; "required": false; "isSignal": true; }; "radius": { "alias": "radius"; "required": false; "isSignal": true; }; "previewWidth": { "alias": "previewWidth"; "required": false; "isSignal": true; }; "previewHeight": { "alias": "previewHeight"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "hidePreview": { "alias": "hidePreview"; "required": false; "isSignal": true; }; "forcePreviewImageChange": { "alias": "forcePreviewImageChange"; "required": false; "isSignal": true; }; }, { "previewImage": "previewImageChange"; "upload": "upload"; }, never, ["*"], true, never>;
}

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

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

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

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

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

declare class LayoutComponent {
    static readonly defaults: {
        menuIcon: _angular_core.WritableSignal<IconType>;
        menuIconSize: _angular_core.WritableSignal<IconSize>;
    };
    protected readonly defaults: {
        menuIcon: _angular_core.WritableSignal<IconType>;
        menuIconSize: _angular_core.WritableSignal<IconSize>;
    };
    protected readonly layoutService: LayoutService;
    readonly showHamburger: _angular_core.InputSignal<boolean>;
    readonly menuIcon: _angular_core.InputSignal<IconType | undefined>;
    readonly menuIconSize: _angular_core.InputSignal<IconSize>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LayoutComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LayoutComponent, "m-layout", never, { "showHamburger": { "alias": "showHamburger"; "required": false; "isSignal": true; }; "menuIcon": { "alias": "menuIcon"; "required": false; "isSignal": true; }; "menuIconSize": { "alias": "menuIconSize"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

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

declare type LoaderSize = 'mini' | 'tiny' | 'small' | 'large' | 'big' | 'huge' | 'massive';

declare class LoaderComponent extends BaseComponent {
    readonly text: _angular_core.InputSignal<string | undefined>;
    readonly size: _angular_core.InputSignal<LoaderSize | undefined>;
    readonly inline: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly inverted: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly activeInput: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly activeChange: _angular_core.OutputEmitterRef<boolean>;
    readonly active: TransformableModel<boolean, BooleanLike>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LoaderComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LoaderComponent, "m-loader", never, { "text": { "alias": "text"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "inline": { "alias": "inline"; "required": false; "isSignal": true; }; "inverted": { "alias": "inverted"; "required": false; "isSignal": true; }; "activeInput": { "alias": "active"; "required": false; "isSignal": true; }; }, { "activeChange": "activeChange"; }, never, ["*"], true, never>;
}

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: _angular_core.InputSignal<string>;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LocalizeComponent, never>;
    static ɵcmp: _angular_core.ɵɵ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;
    readonly value: _angular_core.InputSignalWithTransform<string, string | undefined>;
    protected readonly elements: _angular_core.Signal<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";
    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: _angular_core.ɵɵFactoryDeclaration<MarkdownRendererComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MarkdownRendererComponent, "m-markdown-renderer", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

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

declare class MenuItemDirective/*extends MenuItemComponent*/  extends BaseDirective {
    readonly active: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuItemDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MenuItemDirective, "[m-menu-item]", never, { "active": { "alias": "active"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

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

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

declare type MessageAttached = 'bottom' | 'top' | undefined;

declare class MessageComponent extends InvertibleComponent {
    static readonly defaults: {
        closeIcon: _angular_core.WritableSignal<IconType>;
        closeIconSize: _angular_core.WritableSignal<IconSize>;
        inverted: _angular_core.WritableSignal<boolean>;
    };
    protected readonly defaults: {
        closeIcon: _angular_core.WritableSignal<IconType>;
        closeIconSize: _angular_core.WritableSignal<IconSize>;
        inverted: _angular_core.WritableSignal<boolean>;
    };
    readonly positive: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly info: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly success: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly warning: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly error: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly closable: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly showClose: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly loading: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly attached: _angular_core.InputSignal<MessageAttached>;
    readonly header: _angular_core.InputSignal<string | undefined>;
    readonly icon: _angular_core.InputSignal<IconType | undefined>;
    readonly iconSize: _angular_core.InputSignal<IconSize>;
    readonly closeIcon: _angular_core.InputSignal<IconType | undefined>;
    readonly closeIconSize: _angular_core.InputSignal<IconSize>;
    readonly ignored: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly close: _angular_core.OutputEmitterRef<MouseEvent>;
    constructor();
    protected onClick(event: MouseEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MessageComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MessageComponent, "m-message", never, { "positive": { "alias": "positive"; "required": false; "isSignal": true; }; "info": { "alias": "info"; "required": false; "isSignal": true; }; "success": { "alias": "success"; "required": false; "isSignal": true; }; "warning": { "alias": "warning"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "closable": { "alias": "closable"; "required": false; "isSignal": true; }; "showClose": { "alias": "showClose"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "attached": { "alias": "attached"; "required": false; "isSignal": true; }; "header": { "alias": "header"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconSize": { "alias": "iconSize"; "required": false; "isSignal": true; }; "closeIcon": { "alias": "closeIcon"; "required": false; "isSignal": true; }; "closeIconSize": { "alias": "closeIconSize"; "required": false; "isSignal": true; }; "ignored": { "alias": "ignored"; "required": false; "isSignal": true; }; }, { "close": "close"; }, never, ["*"], true, never>;
}

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

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

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

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

type ModalSize = 'mini' | 'tiny' | 'small' | 'large';

declare class ModalComponent extends InvertibleComponent {
    static readonly defaults: {
        closeIcon: _angular_core.WritableSignal<IconType>;
        inverted: _angular_core.WritableSignal<boolean>;
    };
    private readonly resizeObserver;
    protected minGrowOnlyContentHeight: number;
    protected readonly defaults: {
        closeIcon: _angular_core.WritableSignal<IconType>;
        inverted: _angular_core.WritableSignal<boolean>;
    };
    readonly growOnly: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly contentElementRef: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
    readonly basic: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly header: _angular_core.InputSignal<string | undefined>;
    readonly showClose: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly showHeaderInput: _angular_core.InputSignalWithTransform<boolean | undefined, BooleanLike>;
    readonly hideHeaderInput: _angular_core.InputSignalWithTransform<boolean | undefined, BooleanLike>;
    readonly showHeader: _angular_core.Signal<boolean>;
    readonly hideHeader: _angular_core.Signal<boolean>;
    readonly showFooterInput: _angular_core.InputSignalWithTransform<boolean | undefined, BooleanLike>;
    readonly hideFooterInput: _angular_core.InputSignalWithTransform<boolean | undefined, BooleanLike>;
    readonly showFooter: _angular_core.Signal<boolean>;
    readonly hideFooter: _angular_core.Signal<boolean>;
    readonly hideDimmer: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly visible: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly imageContent: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly fullscreen: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly size: _angular_core.InputSignal<ModalSize | undefined>;
    readonly scrolling: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly noPadding: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly loading: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly minContentHeight: _angular_core.InputSignal<string | undefined>;
    readonly maxContentHeight: _angular_core.InputSignal<string | undefined>;
    readonly closeIcon: _angular_core.InputSignal<IconType | undefined>;
    readonly close: _angular_core.OutputEmitterRef<void>;
    constructor();
    protected onClose(): void;
    protected onDimmerClick(event: MouseEvent): void;
    private onResize;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ModalComponent, "m-modal", never, { "growOnly": { "alias": "growOnly"; "required": false; "isSignal": true; }; "basic": { "alias": "basic"; "required": false; "isSignal": true; }; "header": { "alias": "header"; "required": false; "isSignal": true; }; "showClose": { "alias": "showClose"; "required": false; "isSignal": true; }; "showHeaderInput": { "alias": "showHeader"; "required": false; "isSignal": true; }; "hideHeaderInput": { "alias": "hideHeader"; "required": false; "isSignal": true; }; "showFooterInput": { "alias": "showFooter"; "required": false; "isSignal": true; }; "hideFooterInput": { "alias": "hideFooter"; "required": false; "isSignal": true; }; "hideDimmer": { "alias": "hideDimmer"; "required": false; "isSignal": true; }; "visible": { "alias": "visible"; "required": false; "isSignal": true; }; "imageContent": { "alias": "imageContent"; "required": false; "isSignal": true; }; "fullscreen": { "alias": "fullscreen"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "scrolling": { "alias": "scrolling"; "required": false; "isSignal": true; }; "noPadding": { "alias": "noPadding"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "minContentHeight": { "alias": "minContentHeight"; "required": false; "isSignal": true; }; "maxContentHeight": { "alias": "maxContentHeight"; "required": false; "isSignal": true; }; "closeIcon": { "alias": "closeIcon"; "required": false; "isSignal": true; }; }, { "close": "close"; }, never, ["m-modal-header", "*", "m-modal-footer"], true, never>;
}

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

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

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

declare class AsyncAction implements InteropObservable<void> {
    private readonly subject;
    readonly event: rxjs.Observable<void>;
    done(): void;
    error(message?: string): void;
    [Symbol.observable](): Subscribable<void>;
}

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 const notificationToken: InjectionToken<Notification<unknown>>;

declare class NotificationService implements NotificationHandler {
    static readonly defaults: {
        successIcon: _angular_core.WritableSignal<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: _angular_core.ɵɵFactoryDeclaration<NotificationService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NotificationService>;
}

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

declare class RowComponent extends BaseComponent {
    readonly columns: _angular_core.InputSignalWithTransform<FieldSize | undefined, ParsableFieldSize>;
    readonly stretched: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RowComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RowComponent, "m-row", never, { "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "stretched": { "alias": "stretched"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class SegmentDefaultsComponent implements OnDestroy {
    private readonly previousInverted;
    private readonly previousRaised;
    private currentInverted?;
    private currentRaised?;
    readonly inverted: _angular_core.InputSignal<boolean | undefined>;
    readonly raised: _angular_core.InputSignal<boolean | undefined>;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SegmentDefaultsComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SegmentDefaultsComponent, "m-segment-defaults", never, { "inverted": { "alias": "inverted"; "required": false; "isSignal": true; }; "raised": { "alias": "raised"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare type SegmentAttached = 'top' | 'bottom';

declare class SegmentComponent extends InvertibleComponent {
    static readonly defaults: {
        inverted: _angular_core.WritableSignal<boolean>;
        raised: _angular_core.WritableSignal<boolean>;
    };
    protected static readonly providers: typeof SortedClassesService[];
    private readonly raisedDefault;
    readonly raisedInput: _angular_core.InputSignalWithTransform<boolean | undefined, BooleanLike>;
    readonly raised: _angular_core.Signal<boolean>;
    readonly vertical: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly placeholder: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly secondary: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly tertiary: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly attached: _angular_core.InputSignal<SegmentAttached | undefined>;
    readonly noPadding: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly noMargin: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly basic: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly color: _angular_core.InputSignal<ColorName | undefined>;
    readonly loading: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    constructor();
    private refreshRaised;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SegmentComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SegmentComponent, "m-segment", never, { "raisedInput": { "alias": "raised"; "required": false; "isSignal": true; }; "vertical": { "alias": "vertical"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "secondary": { "alias": "secondary"; "required": false; "isSignal": true; }; "tertiary": { "alias": "tertiary"; "required": false; "isSignal": true; }; "attached": { "alias": "attached"; "required": false; "isSignal": true; }; "noPadding": { "alias": "noPadding"; "required": false; "isSignal": true; }; "noMargin": { "alias": "noMargin"; "required": false; "isSignal": true; }; "basic": { "alias": "basic"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class SegmentGroupComponent extends BaseComponent {
    readonly horizontal: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SegmentGroupComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SegmentGroupComponent, "m-segment-group", never, { "horizontal": { "alias": "horizontal"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

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

declare type SidebarWidth = 'thin' | 'very thin' | 'wide' | 'very wide';

declare class SidebarComponent extends BaseComponent {
    readonly visible: _angular_core.ModelSignal<boolean>;
    readonly width: _angular_core.InputSignal<SidebarWidth | undefined>;
    readonly position: _angular_core.InputSignal<SidebarPosition>;
    readonly noScrolling: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly inverted: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly fluid: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    constructor();
    show(): void;
    hide(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SidebarComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SidebarComponent, "m-sidebar", never, { "visible": { "alias": "visible"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "noScrolling": { "alias": "noScrolling"; "required": false; "isSignal": true; }; "inverted": { "alias": "inverted"; "required": false; "isSignal": true; }; "fluid": { "alias": "fluid"; "required": false; "isSignal": true; }; }, { "visible": "visibleChange"; }, never, ["*"], true, never>;
}

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

declare type Align = 'top' | 'bottom' | 'middle';

declare class TableComponent extends InvertibleComponent {
    static readonly defaults: {
        inverted: _angular_core.WritableSignal<boolean>;
    };
    readonly notCelled: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly very: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly unstackable: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly aligned: _angular_core.InputSignal<Align>;
    readonly definition: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly collapsing: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly basic: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TableComponent, "m-table", never, { "notCelled": { "alias": "notCelled"; "required": false; "isSignal": true; }; "very": { "alias": "very"; "required": false; "isSignal": true; }; "unstackable": { "alias": "unstackable"; "required": false; "isSignal": true; }; "aligned": { "alias": "aligned"; "required": false; "isSignal": true; }; "definition": { "alias": "definition"; "required": false; "isSignal": true; }; "collapsing": { "alias": "collapsing"; "required": false; "isSignal": true; }; "basic": { "alias": "basic"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class TableDefaultsComponent implements OnDestroy {
    private readonly previousInverted;
    private currentInverted?;
    readonly inverted: _angular_core.InputSignal<boolean | undefined>;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableDefaultsComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TableDefaultsComponent, "m-table-defaults", never, { "inverted": { "alias": "inverted"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

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

declare class TabGroupComponent extends InvertibleComponent implements OnInit, AfterViewInit {
    static readonly defaults: {
        inverted: _angular_core.WritableSignal<boolean>;
    };
    private readonly route;
    private readonly router;
    private routes;
    readonly menu: _angular_core.InputSignal<MenuPosition>;
    readonly pointing: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly secondary: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly loading: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly noPadding: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly scrollable: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly selectByRoute: _angular_core.InputSignal<string | undefined>;
    readonly selectedIndex: _angular_core.ModelSignal<number | undefined>;
    protected readonly tabs: _angular_core.Signal<readonly TabComponent[]>;
    private readonly isSelectByRoute;
    private readonly routeParameterName;
    protected readonly menuPosition: _angular_core.Signal<string>;
    protected readonly horizontal: _angular_core.Signal<boolean>;
    constructor();
    ngOnInit(): void;
    ngAfterViewInit(): void;
    private refreshTab;
    protected activate(tab: TabComponent): void;
    private toName;
    private getActiveRouteSegments;
    private parseRoutes;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabGroupComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TabGroupComponent, "m-tab-group", never, { "menu": { "alias": "menu"; "required": false; "isSignal": true; }; "pointing": { "alias": "pointing"; "required": false; "isSignal": true; }; "secondary": { "alias": "secondary"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "noPadding": { "alias": "noPadding"; "required": false; "isSignal": true; }; "scrollable": { "alias": "scrollable"; "required": false; "isSignal": true; }; "selectByRoute": { "alias": "selectByRoute"; "required": false; "isSignal": true; }; "selectedIndex": { "alias": "selectedIndex"; "required": false; "isSignal": true; }; }, { "selectedIndex": "selectedIndexChange"; }, ["tabs"], ["*"], true, never>;
}

declare class TabGroupDefaultsComponent implements OnDestroy {
    private readonly previousInverted;
    private currentInverted?;
    readonly inverted: _angular_core.InputSignal<boolean | undefined>;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabGroupDefaultsComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TabGroupDefaultsComponent, "m-tab-group-defaults", never, { "inverted": { "alias": "inverted"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class TemplateComponent implements OnDestroy {
    private readonly templateService;
    private template;
    protected readonly contentTemplate: _angular_core.Signal<TemplateRef<unknown> | undefined>;
    readonly name: _angular_core.InputSignal<string | string[]>;
    readonly class: _angular_core.InputSignal<string | undefined>;
    readonly visible: _angular_core.ModelSignal<boolean>;
    /**
     * When used, it sets the default visibility of the template to false.
     * @example
     * ```html
     * <m-template hidden />
     * ```
     */
    readonly hidden: _angular_core.InputSignalWithTransform<boolean, "" | undefined>;
    readonly autoHide: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    constructor();
    ngOnDestroy(): void;
    show(): void;
    hide(): void;
    toggle(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TemplateComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TemplateComponent, "m-template", never, { "name": { "alias": "name"; "required": true; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; "visible": { "alias": "visible"; "required": false; "isSignal": true; }; "hidden": { "alias": "hidden"; "required": false; "isSignal": true; }; "autoHide": { "alias": "autoHide"; "required": false; "isSignal": true; }; }, { "visible": "visibleChange"; }, never, ["*"], true, never>;
}

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

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

declare class TextContainerComponent extends BaseComponent {
    readonly fluid: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextContainerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TextContainerComponent, "m-text-container", never, { "fluid": { "alias": "fluid"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class TextareaDefaultsComponent implements OnDestroy {
    private readonly previousInverted;
    private currentInverted?;
    readonly inverted: _angular_core.InputSignal<boolean | undefined>;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextareaDefaultsComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TextareaDefaultsComponent, "m-textarea-defaults", never, { "inverted": { "alias": "inverted"; "required": false; "isSignal": true; }; }, {}, 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: _angular_core.ɵɵFactoryDeclaration<ManticTitleStrategy, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ManticTitleStrategy>;
}

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

declare function provideManticTitleStrategy(configuration: ManticTitleStrategyConfiguration): EnvironmentProviders;

declare class WarningComponent extends InvertibleComponent {
    protected readonly defaults: {
        closeIcon: _angular_core.WritableSignal<_mantic_ui_angular.IconType>;
        closeIconSize: _angular_core.WritableSignal<_mantic_ui_angular.IconSize>;
        inverted: _angular_core.WritableSignal<boolean>;
    };
    readonly showClose: _angular_core.InputSignal<boolean>;
    readonly closed: _angular_core.ModelSignal<boolean>;
    readonly visible: _angular_core.Signal<boolean>;
    readonly close: _angular_core.OutputEmitterRef<void>;
    constructor();
    onClose(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WarningComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WarningComponent, "m-warning", never, { "showClose": { "alias": "showClose"; "required": false; "isSignal": true; }; "closed": { "alias": "closed"; "required": false; "isSignal": true; }; }, { "closed": "closedChange"; "close": "close"; }, never, ["*"], true, never>;
}

declare class FallbackForDirective {
    private readonly elementRef;
    private readonly templateRef;
    private readonly viewContainerRef;
    readonly fallback: _angular_core.InputSignal<string>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FallbackForDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FallbackForDirective, "[m-fallback-for]", never, { "fallback": { "alias": "m-fallback-for"; "required": true; "isSignal": true; }; }, {}, 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: _angular_core.InputSignal<string | string[]>;
    constructor();
    private refreshView;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HideOnEmptyTemplateDirective, never>;
    static ɵdir: _angular_core.ɵɵ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: _angular_core.InputSignal<string | string[]>;
    constructor();
    private refreshView;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HideOnExistingTemplateDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HideOnExistingTemplateDirective, "[mHideOnExistingTemplate]", never, { "name": { "alias": "mHideOnExistingTemplate"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class HeaderDirective extends BaseDirective {
    private isInverted;
    private isInvertedDefault;
    get inverted(): boolean;
    set inverted(value: BooleanLike);
    readonly dividing: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly icon: _angular_core.InputSignalWithTransform<boolean, BooleanLike>;
    readonly sub: _angular_core.InputSignal<boolean>;
    constructor();
    private setInvertedDefault;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HeaderDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HeaderDirective, "[m-header]", never, { "inverted": { "alias": "inverted"; "required": false; }; "dividing": { "alias": "dividing"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "sub": { "alias": "sub"; "required": false; "isSignal": true; }; }, {}, 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: _angular_core.ɵɵFactoryDeclaration<ToBodyDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ToBodyDirective, "[m-to-body]", never, {}, {}, never, never, true, never>;
}

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

declare class PositionAbsoluteDirective implements AfterViewInit, OnDestroy {
    private readonly elementRef;
    private readonly observer;
    private parent;
    readonly position: _angular_core.InputSignal<"top-left" | "top-center" | "top-right" | "middle-left" | "middle-center" | "middle-right" | "bottom-left" | "bottom-center" | "bottom-right" | undefined>;
    readonly attach: _angular_core.InputSignal<"left" | "right" | "middle">;
    readonly parentWidth: _angular_core.InputSignal<"none" | "min" | "max" | "exact">;
    readonly minLeft: _angular_core.InputSignal<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: _angular_core.ɵɵFactoryDeclaration<PositionAbsoluteDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PositionAbsoluteDirective, "[m-position-absolute]", never, { "position": { "alias": "m-position-absolute"; "required": false; "isSignal": true; }; "attach": { "alias": "attach"; "required": false; "isSignal": true; }; "parentWidth": { "alias": "parentWidth"; "required": false; "isSignal": true; }; "minLeft": { "alias": "minLeft"; "required": false; "isSignal": true; }; }, {}, 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: _angular_core.ɵɵFactoryDeclaration<ExternalRouteComponent, never>;
    static ɵdir: _angular_core.ɵɵ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: _angular_core.ɵɵFactoryDeclaration<LowerCaseUrlSerializer, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<LowerCaseUrlSerializer>;
}

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

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

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;

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

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: _angular_core.ɵɵFactoryDeclaration<AllowedCharsPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<AllowedCharsPipe, "mAllowedChars", true>;
}

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

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

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

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

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

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

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

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

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

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

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

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

/**
 * 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: _angular_core.ɵɵFactoryDeclaration<SlicePipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<SlicePipe, "mSlice", true>;
}

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

declare class ToBooleanPipe implements PipeTransform {
    transform(value: BooleanLike): boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToBooleanPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<ToBooleanPipe, "toBoolean", true>;
}

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

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

declare class FaviconService {
    private canvasElement;
    private faviconElement;
    getContext(): CanvasRenderingContext2D | undefined;
    private getCanvas;
    update(): void;
    private getFaviconElement;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FaviconService, never>;
    static ɵprov: _angular_core.ɵɵ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;
    toggle(names: string | string[], template: Template): void;
    get(names: string | string[]): Observable<Template | undefined>;
    private notify;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TemplateService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TemplateService>;
}

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

export { AllowedCharsPipe, AnimationComponent, ArrayPipe, AsyncAction, AutoComponent, AutoDirective, BaseComponent, BaseDirective, BaseHrefService, BreadcrumbComponent, ButtonBaseComponent, ButtonComponent, ButtonDefaultsComponent, ButtonDirective, ButtonGroupComponent, CardComponent, CardGroupComponent, CeilPipe, CellComponent, ChatComponent, ChatDefaultsComponent, ChatMessageComponent, CheckboxComponent, CheckboxDefaultsComponent, CircularProgressComponent, ComponentParser, ContextMenuComponent, ContextMenuItemComponent, DataSourceComponent, DataSourceRequest, DateHelper, DateInputComponent, DebugPipe, DebuggerPipe, Destroyable, DimmerComponent, DimmerDefaultsComponent, 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, FooterComponent, FooterLinkComponent, FooterLinkTemplateDirective, FormComponent, FormDefaultsComponent, FormElement, FormElementRenderer2Component, FormElementRendererComponent, FormRendererComponent, FormRendererService, FormValidationNotifier, GridComponent, GrowComponent, GrowDirective, HeaderComponent, HeaderDefaultsComponent, HeaderDirective, HideOnEmptyTemplateDirective, HideOnExistingTemplateDirective, IconButtonComponent, IconComponent, ImageUploadComponent, InfoComponent, InputComponent, InputDefaultsComponent, InvertibleComponent, IsEmailPipe, IsFilledPipe, Key, LabelComponent, LabelDropdownComponent, LabelDropdownDefaultsComponent, LayoutComponent, LayoutDefaultsComponent, LoaderComponent, LocalizeComponent, LogPipe, LowerCaseUrlSerializer, LowerCaseUrlSerializerModule, ManticTitleStrategy, ManticTitleStrategyModule, MarkdownRendererComponent, Math2, MenuComponent, MenuHeaderComponent, MenuItemComponent, MenuItemDirective, MenuLinkComponent, MenuLinkTemplateDirective, MessageComponent, MessageDefaultsComponent, ModalComponent, ModalDefaultsComponent, ModalFooterComponent, ModalHeaderComponent, Mouse, NotificationComponent, NotificationDefaultsComponent, NotificationRef, NotificationService, NumericInputComponent, ObjectHelper, OrComponent, OverflowDirective, PadEndPipe, PadStartPipe, PositionAbsoluteDirective, RadioComponent, 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, ToBooleanPipe, ToTemplateDirective, ToggleButtonComponent, ToggleComponent, WarningComponent, cast, isFormValidation, localize, localizeDictionary, mantic, manticTitleStrategyConfigurationToken, mapVoid, notificationToken, provideDynamicComponent, provideFormElement, provideLocale, provideManticTitleStrategy, toBoolean, toBooleanWithUndefined };
export type { BooleanLike, Changes, ChatMessage, ChatOption, ColorName, ExternalRouteData, FlexAlignItems, FlexDirection, FlexJustifyContent, FormAreaElement, FormButtonElement, FormCellElement, FormCheckboxElement, FormDataElement, FormDataElementWithChildren, FormDivider, FormDropDownElement, FormDropDownFilter, FormElementBase, FormElements, FormError, FormFieldGroupElement, FormGridElement, FormHeader, FormInfo, FormInputElement, FormLabelElement, FormLayout, FormMessage, FormMessageBase, FormValidation, FormWarning, IconSize, IconType, InputIconPosition, InputType, KeyCode, ManticIconSize, ManticTitleStrategyCondition, ManticTitleStrategyConfiguration, ModalSize, Notification, NotificationType, OverflowValue, ValidationPipe };
