import * as i0 from '@angular/core';
import { OnDestroy, OnChanges, SimpleChanges, AfterContentInit, InjectionToken, ElementRef, Type, AfterViewInit } from '@angular/core';
import { DefaultValueAccessor, CheckboxControlValueAccessor, RadioControlValueAccessor, ControlValueAccessor, SelectControlValueAccessor, NgSelectOption, Validator, AbstractControl, ValidationErrors, NgControl } from '@angular/forms';
import { RangeDatepicker, ButtonVariant, ButtonColor } from '@universal-material/web';
export { SnackbarDuration } from '@universal-material/web';
import { BehaviorSubject, Observable, Subject } from 'rxjs';
import * as i3 from '@angular/common';

declare class UmDefaultControlValueAccessor extends DefaultValueAccessor {
    /** Inserted by Angular inject() migration for backwards compatibility */
    constructor(...args: unknown[]);
    static ɵfac: i0.ɵɵFactoryDeclaration<UmDefaultControlValueAccessor, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<UmDefaultControlValueAccessor, "u-text-field[ngModel],u-text-field[formControlName],u-text-field[formControl],u-text-area[ngModel],u-text-area[formControlName],u-text-area[formControl],u-search[ngModel],u-search[formControlName],u-search[formControl]", never, {}, {}, never, never, false, never>;
}

declare class UmCheckControlValueAccessor extends CheckboxControlValueAccessor {
    static ɵfac: i0.ɵɵFactoryDeclaration<UmCheckControlValueAccessor, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<UmCheckControlValueAccessor, "u-checkbox[ngModel],u-checkbox[formControlName],u-checkbox[formControl],u-switch[ngModel],u-switch[formControlName],u-switch[formControl],u-checkbox-list-item[ngModel],u-checkbox-list-item[formControlName],u-checkbox-list-item[formControl],u-switch-list-item[ngModel],u-switch-list-item[formControlName],u-switch-list-item[formControl]", never, {}, {}, never, never, false, never>;
}

declare class UmRadioControlValueAccessor extends RadioControlValueAccessor {
    static ɵfac: i0.ɵɵFactoryDeclaration<UmRadioControlValueAccessor, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<UmRadioControlValueAccessor, "u-radio[ngModel],u-radio[formControlName],u-radio[formControl],u-radio-list-item[ngModel],u-radio-list-item[formControlName],u-radio-list-item[formControl]", never, {}, {}, never, never, false, never>;
}

declare class UmChipFieldControlValueAccessor implements ControlValueAccessor {
    private _renderer;
    private _elementRef;
    onChange: (_: any) => void;
    onTouched: () => void;
    /** Inserted by Angular inject() migration for backwards compatibility */
    constructor(...args: unknown[]);
    writeValue(obj: any): void;
    protected setProperty(key: string, value: any): void;
    registerOnTouched(fn: () => void): void;
    registerOnChange(fn: (_: any) => {}): void;
    setDisabledState(isDisabled: boolean): void;
    _handleChange(value: []): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<UmChipFieldControlValueAccessor, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<UmChipFieldControlValueAccessor, "u-chip-field[ngModel],u-chip-field[formControlName],u-chip-field[formControl]", never, {}, {}, never, never, false, never>;
}

declare class UmTypeaheadControlValueAccessor implements ControlValueAccessor {
    private _renderer;
    private _elementRef;
    onChange: (_: any) => void;
    onTouched: () => void;
    /** Inserted by Angular inject() migration for backwards compatibility */
    constructor(...args: unknown[]);
    writeValue(obj: any): void;
    protected setProperty(key: string, value: any): void;
    registerOnTouched(fn: () => void): void;
    registerOnChange(fn: (_: any) => {}): void;
    setDisabledState(isDisabled: boolean): void;
    _handleChange(value: [] | null): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<UmTypeaheadControlValueAccessor, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<UmTypeaheadControlValueAccessor, "u-typeahead[ngModel],u-typeahead[formControlName],u-typeahead[formControl]", never, {}, {}, never, never, false, never>;
}

declare class UmSelectControlValueAccessor extends SelectControlValueAccessor {
    /** Inserted by Angular inject() migration for backwards compatibility */
    constructor(...args: unknown[]);
    _writeValueAfterRender(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<UmSelectControlValueAccessor, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<UmSelectControlValueAccessor, "u-select[ngModel],u-select[formControlName],u-select[formControl]", never, {}, {}, never, never, false, never>;
}
declare class UmSelectOption extends NgSelectOption {
    /** Inserted by Angular inject() migration for backwards compatibility */
    constructor(...args: unknown[]);
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<UmSelectOption, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<UmSelectOption, "u-option", never, {}, {}, never, never, false, never>;
}

declare class UmSliderControlValueAccessor implements ControlValueAccessor {
    private _renderer;
    private _elementRef;
    onChange: (_: any) => void;
    onTouched: () => void;
    /** Inserted by Angular inject() migration for backwards compatibility */
    constructor(...args: unknown[]);
    writeValue(value: any): void;
    protected setProperty(key: string, value: any): void;
    registerOnChange(fn: (_: any) => {}): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    _handleChange(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<UmSliderControlValueAccessor, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<UmSliderControlValueAccessor, "u-slider[ngModel],u-slider[formControlName],u-slider[formControl]", never, {}, {}, never, never, false, never>;
}

declare class UmDatepickerControlValueAccessor implements ControlValueAccessor {
    private _renderer;
    private _elementRef;
    onChange: (_: any) => void;
    onTouched: () => void;
    /** Inserted by Angular inject() migration for backwards compatibility */
    constructor(...args: unknown[]);
    writeValue(value: any): void;
    protected setProperty(key: string, value: any): void;
    registerOnChange(fn: (_: any) => {}): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    _handleChange(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<UmDatepickerControlValueAccessor, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<UmDatepickerControlValueAccessor, "u-datepicker[ngModel],u-datepicker[formControlName],u-datepicker[formControl],u-range-datepicker[ngModel],u-range-datepicker[formControlName],u-range-datepicker[formControl]", never, {}, {}, never, never, false, never>;
}

/**
 * Coordinates the `uStartDate`/`uEndDate` value accessors of a
 * `u-range-datepicker`, splitting and combining the element's
 * `YYYY-MM-DD - YYYY-MM-DD` value so each end binds to its own form control,
 * mirroring `mat-date-range-input` with `matStartDate`/`matEndDate`.
 */
declare class UmRangeDatepickerDirective {
    readonly element: RangeDatepicker;
    private readonly _renderer;
    private readonly _disabledParts;
    getPart(index: 0 | 1): string | Date | null;
    setPart(index: 0 | 1, value: string | Date | null): void;
    /** The range datepicker is only disabled when both ends are disabled, like `mat-date-range-input`. */
    setPartDisabled(index: 0 | 1, disabled: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<UmRangeDatepickerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<UmRangeDatepickerDirective, "u-range-datepicker", never, {}, {}, never, never, false, never>;
}
declare abstract class UmRangeDatepickerPartControlValueAccessor implements ControlValueAccessor, OnDestroy {
    protected abstract readonly _index: 0 | 1;
    private readonly _rangeDatepicker;
    onChange: (_: any) => void;
    onTouched: () => void;
    constructor();
    ngOnDestroy(): void;
    writeValue(value: any): void;
    registerOnChange(fn: (_: any) => {}): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    private readonly _handleChange;
    private readonly _handleTouched;
    static ɵfac: i0.ɵɵFactoryDeclaration<UmRangeDatepickerPartControlValueAccessor, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<UmRangeDatepickerPartControlValueAccessor, never, never, {}, {}, never, never, true, never>;
}
/**
 * Binds a form control to the start date of the enclosing `u-range-datepicker`.
 * The input is a hidden value carrier — the range datepicker renders its own
 * field — so it only exists to anchor `formControlName`/`ngModel`.
 */
declare class UmStartDateControlValueAccessor extends UmRangeDatepickerPartControlValueAccessor {
    protected readonly _index = 0;
    static ɵfac: i0.ɵɵFactoryDeclaration<UmStartDateControlValueAccessor, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<UmStartDateControlValueAccessor, "input[uStartDate]", never, {}, {}, never, never, false, never>;
}
/**
 * Binds a form control to the end date of the enclosing `u-range-datepicker`.
 * The input is a hidden value carrier — the range datepicker renders its own
 * field — so it only exists to anchor `formControlName`/`ngModel`.
 */
declare class UmEndDateControlValueAccessor extends UmRangeDatepickerPartControlValueAccessor {
    protected readonly _index = 1;
    static ɵfac: i0.ɵɵFactoryDeclaration<UmEndDateControlValueAccessor, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<UmEndDateControlValueAccessor, "input[uEndDate]", never, {}, {}, never, never, false, never>;
}

/**
 * Validator directive for the `min` bound of `u-datepicker`/`u-range-datepicker`.
 * Declaring `min` as an input keeps the binding from reaching the element, so the
 * directive re-reflects it via `attr.min` to keep the calendar constrained.
 * On a range value, `min` validates the range start.
 */
declare class UmDatepickerMinValidator implements Validator, OnChanges {
    min: string | null;
    private _onChange?;
    ngOnChanges(changes: SimpleChanges): void;
    validate(control: AbstractControl): ValidationErrors | null;
    registerOnValidatorChange(fn: () => void): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<UmDatepickerMinValidator, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<UmDatepickerMinValidator, "u-datepicker[min][formControlName],u-datepicker[min][formControl],u-datepicker[min][ngModel],u-range-datepicker[min][formControlName],u-range-datepicker[min][formControl],u-range-datepicker[min][ngModel]", never, { "min": { "alias": "min"; "required": false; }; }, {}, never, never, false, never>;
}
/**
 * Validator directive for the `max` bound of `u-datepicker`/`u-range-datepicker`.
 * Declaring `max` as an input keeps the binding from reaching the element, so the
 * directive re-reflects it via `attr.max` to keep the calendar constrained.
 * On a range value, `max` validates the range end.
 */
declare class UmDatepickerMaxValidator implements Validator, OnChanges {
    max: string | null;
    private _onChange?;
    ngOnChanges(changes: SimpleChanges): void;
    validate(control: AbstractControl): ValidationErrors | null;
    registerOnValidatorChange(fn: () => void): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<UmDatepickerMaxValidator, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<UmDatepickerMaxValidator, "u-datepicker[max][formControlName],u-datepicker[max][formControl],u-datepicker[max][ngModel],u-range-datepicker[max][formControlName],u-range-datepicker[max][formControl],u-range-datepicker[max][ngModel]", never, { "max": { "alias": "max"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ScrollableContainerWrapper {
    private _container;
    defaultTarget: EventTarget | any;
    _innerScrollTop: BehaviorSubject<number | null>;
    scrollTop: number | null;
    scrollTop$: Observable<number | null>;
    private _emitScroll;
    private _getScrollTop;
    get container(): EventTarget | any;
    set container(value: EventTarget | any);
}

declare abstract class ScrollBehavior implements AfterContentInit, OnChanges {
    readonly scrollContainer: i0.InputSignal<HTMLElement | null>;
    protected _scrollableWrapper: ScrollableContainerWrapper | null;
    protected abstract _processBehavior: (scrollTop: number | null) => void;
    protected defaultTarget: EventTarget | any;
    protected _setScrollWrapper(): void;
    ngAfterContentInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollBehavior, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ScrollBehavior, never, never, { "scrollContainer": { "alias": "scrollContainer"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class DialogBodyDirective extends ScrollBehavior {
    dialog: any;
    /** Inserted by Angular inject() migration for backwards compatibility */
    constructor(...args: unknown[]);
    _processBehavior: () => void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogBodyDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DialogBodyDirective, "[uDialogBody]", never, {}, {}, never, never, false, never>;
}

declare const DIALOG_DEFAULT_OPTIONS: InjectionToken<DialogConfig>;
interface DialogConfig {
    closeOnBackdropClick?: boolean;
    closeOnEsc?: boolean;
}

declare class DialogBaseComponent {
    #private;
    protected readonly _elementRef: ElementRef<any>;
    _dialogConfig: {
        closeOnBackdropClick?: boolean;
        closeOnEsc?: boolean;
    };
    protected readonly _hiding: i0.WritableSignal<boolean>;
    readonly show: i0.ModelSignal<boolean>;
    readonly afterClose: i0.OutputEmitterRef<void>;
    readonly closedFromBackdrop: i0.OutputEmitterRef<void>;
    set _contentChildBody(dialogBody: DialogBodyDirective);
    set _viewChildBody(dialogBody: DialogBodyDirective);
    dialogBody: DialogBodyDirective | null;
    readonly scrollTopDivider: i0.WritableSignal<boolean>;
    readonly scrollBottomDivider: i0.WritableSignal<boolean>;
    constructor();
    protected backdropClick(): void;
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogBaseComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DialogBaseComponent, "u-dialog-base", never, { "show": { "alias": "show"; "required": false; "isSignal": true; }; }, { "show": "showChange"; "afterClose": "afterClose"; "closedFromBackdrop": "closedFromBackdrop"; }, ["_contentChildBody"], never, true, never>;
}

declare class DialogComponent extends DialogBaseComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DialogComponent, "u-legacy-dialog", never, {}, {}, never, ["*"], false, never>;
}

declare const DIALOG_DATA: InjectionToken<any>;
declare class DialogService {
    private readonly _componentFactoryResolver;
    private readonly _appRef;
    private readonly _injector;
    private readonly _dialogStackService;
    /** Inserted by Angular inject() migration for backwards compatibility */
    constructor(...args: unknown[]);
    _internalOpen<T extends DialogComponent>(dialogType: Type<T>, customInjectionTokens: WeakMap<any, any>): T;
    open<T extends DialogComponent>(dialogType: Type<T>, data?: any): T;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DialogService>;
}

declare const CONFIRM_DIALOG_DEFAULT_OPTIONS: InjectionToken<any>;
interface ConfirmDialogButtonConfig {
    text?: string;
    variant?: ButtonVariant;
    color?: ButtonColor;
}
declare class ConfirmDialogConfig implements DialogConfig {
    title?: string;
    confirmButton?: ConfirmDialogButtonConfig;
    cancelButton?: ConfirmDialogButtonConfig;
    closeOnBackdropClick?: boolean;
    closeOnEsc?: boolean;
}

declare abstract class ConfirmDialogComponent extends DialogComponent {
    private readonly sanitizer;
    safeMessage: string | null;
    set message(value: string);
    private _closed;
    readonly _confirmDialogConfig: ConfirmDialogConfig;
    onCancel: Subject<void>;
    onConfirm: Subject<void>;
    confirmed: boolean;
    /** Inserted by Angular inject() migration for backwards compatibility */
    constructor(...args: unknown[]);
    private _assignConfig;
    close(): void;
    _cancelClick(): void;
    _confirmClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ConfirmDialogComponent, "ng-component", never, {}, {}, never, never, true, never>;
}

declare class ProgressDialogComponent extends DialogComponent {
    readonly message: i0.WritableSignal<string | null>;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<ProgressDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ProgressDialogComponent, "u-progress-dialog", never, {}, {}, never, never, true, never>;
}

declare class ProgressDialogService {
    private readonly _dialogService;
    /** Inserted by Angular inject() migration for backwards compatibility */
    constructor(...args: unknown[]);
    open(message?: string | null): ProgressDialogComponent;
    static ɵfac: i0.ɵɵFactoryDeclaration<ProgressDialogService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ProgressDialogService>;
}

declare class DialogModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DialogModule, [typeof DialogComponent, typeof DialogBodyDirective], [typeof i3.CommonModule], [typeof DialogComponent, typeof DialogBodyDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DialogModule>;
}

interface RippleConfig {
    size?: number;
    borderRadius?: string;
    dontChangePositioning?: boolean;
}

declare class RippleDirective implements AfterViewInit {
    protected readonly _elementRef: ElementRef<HTMLElement>;
    private document;
    readonly rippleConfig: i0.InputSignal<RippleConfig>;
    readonly disabled: i0.InputSignal<boolean>;
    isTouching: boolean;
    /** Inserted by Angular inject() migration for backwards compatibility */
    constructor(...args: unknown[]);
    private static _setElementSquareSizeAndCenter;
    _mousedown: (e: MouseEvent) => void;
    _touchstart: (e: TouchEvent) => void;
    ngAfterViewInit(): void;
    createRipple(releaseEventName: string, releaseCallback: Function | null, pageX: number, pageY: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RippleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RippleDirective, "[uRipple]", never, { "rippleConfig": { "alias": "rippleConfig"; "required": false; "isSignal": true; }; "disabled": { "alias": "rippleDisabled"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
}

declare class RippleModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<RippleModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<RippleModule, [typeof RippleDirective], never, [typeof RippleDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<RippleModule>;
}

interface InputBaseComponent {
    disabled: boolean;
    focused: boolean;
    empty: boolean;
    focus(): void;
}

type FormFieldAppearance = 'default' | 'box' | 'outlined' | 'search';

declare const FORM_FIELD_DEFAULT_APPEARANCE: InjectionToken<unknown>;
declare class FormFieldComponent {
    readonly _elementRef: ElementRef<any>;
    _appearanceClass: string;
    _appearance: FormFieldAppearance;
    _defaultAppearance: FormFieldAppearance;
    _input: InputBaseComponent | null;
    _hasLabel: boolean;
    readonly selectionField: i0.InputSignal<boolean>;
    set labelWidth(width: number);
    get removeMarginStyle(): "0" | "";
    readonly invalid: i0.InputSignal<boolean>;
    readonly removeMargin: i0.InputSignal<boolean>;
    readonly supportingText: i0.InputSignal<string | null>;
    readonly errorText: i0.InputSignal<string | null>;
    readonly activated: i0.OutputEmitterRef<void>;
    get appearance(): FormFieldAppearance;
    set appearance(value: FormFieldAppearance);
    /** Inserted by Angular inject() migration for backwards compatibility */
    constructor(...args: unknown[]);
    click(): void;
    mouseDown(e: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormFieldComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormFieldComponent, "u-form-field", never, { "selectionField": { "alias": "selectionField"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "removeMargin": { "alias": "removeMargin"; "required": false; "isSignal": true; }; "supportingText": { "alias": "supportingText"; "required": false; "isSignal": true; }; "errorText": { "alias": "errorText"; "required": false; "isSignal": true; }; "appearance": { "alias": "appearance"; "required": false; }; }, { "activated": "activated"; }, never, ["*", "[uSupportingText]", "[uErrorText]"], false, never>;
}

declare class LabelDirective {
    /** Inserted by Angular inject() migration for backwards compatibility */
    constructor(...args: unknown[]);
    static ɵfac: i0.ɵɵFactoryDeclaration<LabelDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LabelDirective, "[uLabel]", never, {}, {}, never, never, false, never>;
}

declare class FormFieldModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<FormFieldModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<FormFieldModule, [typeof FormFieldComponent, typeof LabelDirective], [typeof i3.CommonModule, typeof RippleModule], [typeof FormFieldComponent, typeof LabelDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<FormFieldModule>;
}

declare abstract class TextInputBase {
    readonly ngControl: NgControl | null;
    protected readonly _elementRef: ElementRef<any>;
    focused: boolean;
    get disabled(): boolean;
    set disabled(value: boolean);
    protected _disabled: boolean;
    static ngAcceptInputType_disabled: boolean | '';
    /** Whether the element is readonly. */
    get readonly(): boolean;
    set readonly(value: boolean);
    private _readonly;
    get empty(): boolean;
    _blur: () => void;
    _focus: () => void;
    get _disabledAttribute(): true | null;
    protected constructor(ngControl: NgControl | null, formField: FormFieldComponent | null);
    focus(): void;
    /** Callback for the cases where the focused state of the input changes. */
    _focusChanged(focused: boolean): void;
    mouseDown(e: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TextInputBase, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TextInputBase, never, never, { "disabled": { "alias": "disabled"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; }, {}, never, never, true, never>;
}

declare class TextInputDirective extends TextInputBase {
    readonly ngControl: NgControl;
    readonly setInputClass: i0.InputSignal<boolean>;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<TextInputDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TextInputDirective, "[uTextInput]", never, { "setInputClass": { "alias": "setInputClass"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
}

declare class TextFieldModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<TextFieldModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<TextFieldModule, [typeof TextInputDirective], [typeof i3.CommonModule], [typeof TextInputDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<TextFieldModule>;
}

declare class TabBarDirective {
    #private;
    readonly activeTabIndex: i0.ModelSignal<number>;
    /** Inserted by Angular inject() migration for backwards compatibility */
    constructor(...args: unknown[]);
    static ɵfac: i0.ɵɵFactoryDeclaration<TabBarDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TabBarDirective, "u-tab-bar", never, { "activeTabIndex": { "alias": "activeTabIndex"; "required": false; "isSignal": true; }; }, { "activeTabIndex": "activeTabIndexChange"; }, never, never, true, never>;
}

declare class FloatingActionBehaviorDirective extends ScrollBehavior {
    private readonly elementRef;
    private _lastScrollY;
    defaultTarget: Window & typeof globalThis;
    /** Inserted by Angular inject() migration for backwards compatibility */
    constructor(...args: unknown[]);
    protected _processBehavior: (scrollTop: number | null) => void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FloatingActionBehaviorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FloatingActionBehaviorDirective, "[uFloatingActionBehavior]", never, {}, {}, never, never, true, never>;
}

interface ConfirmDialogRef {
    onCancel: Observable<void>;
    onConfirm: Observable<void>;
}

declare class ConfirmDialogService {
    #private;
    open(message: string, config?: ConfirmDialogConfig): ConfirmDialogRef;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmDialogService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ConfirmDialogService>;
}

declare const SNACKBAR_DEFAULT_OPTIONS: InjectionToken<unknown>;
interface SnackbarConfig {
    actionLabel?: string | null;
    duration?: number;
}

interface SnackbarRef {
    message: string;
    action?: string;
    onAction: Observable<Event>;
    dismiss(): void;
}

declare class SnackbarService {
    private readonly _defaultConfig;
    /** Inserted by Angular inject() migration for backwards compatibility */
    constructor(...args: unknown[]);
    open(message: string, config?: SnackbarConfig): SnackbarRef;
    static ɵfac: i0.ɵɵFactoryDeclaration<SnackbarService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SnackbarService>;
}

declare class UniversalMaterialModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<UniversalMaterialModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<UniversalMaterialModule, [typeof UmDefaultControlValueAccessor, typeof UmCheckControlValueAccessor, typeof UmRadioControlValueAccessor, typeof UmChipFieldControlValueAccessor, typeof UmTypeaheadControlValueAccessor, typeof UmSelectControlValueAccessor, typeof UmSelectOption, typeof UmSliderControlValueAccessor, typeof UmDatepickerControlValueAccessor, typeof UmRangeDatepickerDirective, typeof UmStartDateControlValueAccessor, typeof UmEndDateControlValueAccessor, typeof UmDatepickerMinValidator, typeof UmDatepickerMaxValidator], [typeof DialogModule, typeof RippleModule, typeof FormFieldModule, typeof TextFieldModule, typeof TabBarDirective, typeof FloatingActionBehaviorDirective], [typeof DialogModule, typeof RippleModule, typeof FormFieldModule, typeof TextFieldModule, typeof TabBarDirective, typeof FloatingActionBehaviorDirective, typeof UmDefaultControlValueAccessor, typeof UmCheckControlValueAccessor, typeof UmRadioControlValueAccessor, typeof UmChipFieldControlValueAccessor, typeof UmTypeaheadControlValueAccessor, typeof UmSelectControlValueAccessor, typeof UmSelectOption, typeof UmSliderControlValueAccessor, typeof UmDatepickerControlValueAccessor, typeof UmRangeDatepickerDirective, typeof UmStartDateControlValueAccessor, typeof UmEndDateControlValueAccessor, typeof UmDatepickerMinValidator, typeof UmDatepickerMaxValidator]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<UniversalMaterialModule>;
}

export { CONFIRM_DIALOG_DEFAULT_OPTIONS, ConfirmDialogComponent, ConfirmDialogConfig, ConfirmDialogService, DIALOG_DATA, DIALOG_DEFAULT_OPTIONS, DialogBaseComponent, DialogBodyDirective, DialogComponent, DialogModule, DialogService, FORM_FIELD_DEFAULT_APPEARANCE, FloatingActionBehaviorDirective, FormFieldComponent, FormFieldModule, LabelDirective, ProgressDialogComponent, ProgressDialogService, RippleDirective, RippleModule, SNACKBAR_DEFAULT_OPTIONS, SnackbarService, TabBarDirective, TextFieldModule, TextInputBase, TextInputDirective, UmCheckControlValueAccessor, UmChipFieldControlValueAccessor, UmDatepickerControlValueAccessor, UmDatepickerMaxValidator, UmDatepickerMinValidator, UmDefaultControlValueAccessor, UmEndDateControlValueAccessor, UmRadioControlValueAccessor, UmRangeDatepickerDirective, UmRangeDatepickerPartControlValueAccessor, UmSelectControlValueAccessor, UmSelectOption, UmSliderControlValueAccessor, UmStartDateControlValueAccessor, UmTypeaheadControlValueAccessor, UniversalMaterialModule };
export type { ConfirmDialogRef, DialogConfig, FormFieldAppearance, InputBaseComponent, SnackbarConfig };