@yuuvis/client-components 3.0.0-beta.21.1

package/types/yuuvis-client-components-common.d.ts

@@ -0,0 +1,536 @@
+import * as i0 from '@angular/core';
+import { OnInit, OnDestroy, ElementRef, AfterViewInit, InjectionToken, EnvironmentProviders } from '@angular/core';
+import { ControlValueAccessor, NgControl } from '@angular/forms';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { MatFormFieldControl } from '@angular/material/form-field';
+import { Subject, Observable } from 'rxjs';
+import { DmsObject, RetentionState } from '@yuuvis/client-core';
+
+interface BusyOverlayConfig {
+    backdropColor?: string;
+    blur?: boolean;
+}
+
+/**
+ * A directive that will overlay its host component with a translucent background
+ * and a loading spinner once the condition resolves with true. This is useful for example to
+ * prevent user interaction while component data is loading or some processing is done.
+ *
+ * It'll also prevent the overlaid element from being interacted with.
+ *
+ * ```html
+ * <div class="data-panel" [yuvBusyOverlay]="isLoadingData">...</div>
+ * ```
+ * Setting a `yuvBusyError` will replace the loading spinner by the provided error message.
+ * You need to keep the `yuvBusyOverlay` condition true to show the error.
+ * The error element rendered has a dismiss/close action that trigger the `yuvBusyErrorDismiss`
+ * output event, that you then can use to set the busy condition to false.
+ *
+ * ```html
+ * <div class="result-list"
+ * [yuvBusyOverlay]="waitingForServerResponse"
+ * (yuvBusyErrorDismiss)="waitingForServerResponse = false"
+ * [yuvBusyError]="errorMessage">
+ *  ...
+ * </div>
+ * ```
+ *
+ * ```ts
+ * // in your component code
+ * this.waitingForServerResponse = true;
+ * fetchData().subscribe({
+ *   next: (data) => {
+ *    ...
+ *   this.waitingForServerResponse = false;
+ *  }
+ *  error: (err) => {
+ *    this.errorMessage = 'Failed to load data from server: ' + err.message;
+ *  }
+ * });
+ * ```
+ *
+ */
+declare class BusyOverlayDirective implements OnInit, OnDestroy {
+    #private;
+    stylePosition: i0.WritableSignal<string>;
+    /**
+     * The Boolean expression to evaluate as the condition for showing the busy overlay
+     */
+    yuvBusyOverlay: i0.InputSignal<boolean>;
+    /**
+     * Configuration options for the busy overlay. These include
+     * e.g. backdrops background color and whether to blur the
+     * overlaid content.
+     */
+    yuvBusyOverlayConfig: i0.InputSignal<BusyOverlayConfig | undefined>;
+    /**
+     * Error message to display in the overlay. If set, the loading spinner is replaced by the error message.
+     */
+    yuvBusyError: i0.InputSignal<string | undefined>;
+    /**
+     * Event emitted when the error message's dismiss action is triggered.
+     */
+    yuvBusyErrorDismiss: i0.OutputEmitterRef<void>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BusyOverlayDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BusyOverlayDirective, "[yuvBusyOverlay]", never, { "yuvBusyOverlay": { "alias": "yuvBusyOverlay"; "required": false; "isSignal": true; }; "yuvBusyOverlayConfig": { "alias": "yuvBusyOverlayConfig"; "required": false; "isSignal": true; }; "yuvBusyError": { "alias": "yuvBusyError"; "required": false; "isSignal": true; }; }, { "yuvBusyErrorDismiss": "yuvBusyErrorDismiss"; }, never, never, true, never>;
+}
+
+/**
+ * Directive keeping track of the focus beeing within a component. Once the component or
+ * any of its child components gain focus, a class of `focusWithin` will be set on the
+ * host component in order to allow styling it while beeing focused. Furthermore you can
+ * register callbacks once the component gets or looses focus.
+ *
+ * @example
+ * // just set the css class
+ * <some-component yuvFocusWithin></some-component>
+ * // set the css class and listen to focus changes
+ * <some-component (yuvFocusWithin)="onFocusEnter()" (yuvFocusWithinBlur)="onFocusLeave()"></some-component>
+ */
+declare class FocusWithinDirective {
+    private elRef;
+    private eventCount;
+    hasFocusWithin: boolean;
+    onFocusIn(evt: FocusEvent): void;
+    onFocusOut(evt: FocusEvent): void;
+    /**
+     * Emitted once the component or any of its child components gains focus.
+     */
+    readonly yuvFocusWithin: i0.OutputEmitterRef<void>;
+    /**
+     * Emitted once the component (incl. any of its child components) looses focus.
+     */
+    readonly yuvFocusWithinBlur: i0.OutputEmitterRef<void>;
+    /**
+     * @ignore
+     */
+    constructor(elRef: ElementRef);
+    private matchesFocusWithin;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FocusWithinDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FocusWithinDirective, "[yuvFocusWithin]", never, {}, { "yuvFocusWithin": "yuvFocusWithin"; "yuvFocusWithinBlur": "yuvFocusWithinBlur"; }, never, never, true, never>;
+}
+
+interface FileDropZoneOptions {
+    label?: string;
+    coverStyles?: Record<string, string>;
+    coverLabelStyles?: Record<string, string>;
+}
+
+declare class FileDropZoneDirective {
+    #private;
+    active: i0.Signal<boolean>;
+    yuvFileDropZone: i0.InputSignal<FileDropZoneOptions | undefined>;
+    fileDropDisabled: i0.InputSignal<boolean>;
+    fileDrop: i0.OutputEmitterRef<File[]>;
+    fileDropOver: i0.OutputEmitterRef<boolean>;
+    onDrop(event: DragEvent): void;
+    onDragOver(event: DragEvent): void;
+    onDragLeave(event: DragEvent): void;
+    onBodyDragOver(event: DragEvent): void;
+    onBodyDrop(event: DragEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileDropZoneDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FileDropZoneDirective, "[yuvFileDropZone]", never, { "yuvFileDropZone": { "alias": "yuvFileDropZone"; "required": false; "isSignal": true; }; "fileDropDisabled": { "alias": "fileDropDisabled"; "required": false; "isSignal": true; }; }, { "fileDrop": "fileDrop"; "fileDropOver": "fileDropOver"; }, never, never, true, never>;
+}
+
+/**
+ * Fixes the issue of 'click' event beeing triggered on 'doubleclick' by defining new outputs that
+ * distinguish between single and double click.
+ */
+declare class ClickDoubleDirective {
+    readonly debounceTime: i0.InputSignal<number>;
+    readonly doubleClick: i0.OutputEmitterRef<MouseEvent>;
+    readonly singleClick: i0.OutputEmitterRef<MouseEvent>;
+    private clicksSubject;
+    constructor();
+    clickEvent(event: MouseEvent): void;
+    doubleClickEvent(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClickDoubleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClickDoubleDirective, "[click.single],[click.double]", never, { "debounceTime": { "alias": "debounceTime"; "required": false; "isSignal": true; }; }, { "doubleClick": "click.double"; "singleClick": "click.single"; }, never, never, true, never>;
+}
+
+/**
+ * Directive for applying light dismiss actions. Adding this directive will trigger
+ * the given function when the user clicks outside the component or hits escape.
+ *
+ * ```ts
+ * <div class="notifications" (yuvLightDismiss)="close()">
+ *   ...
+ * </div>
+ * ```
+ */
+declare class LightDismissDirective {
+    private elRef;
+    onKeydownHandler(event: KeyboardEvent | Event): void;
+    onMousedown(event: MouseEvent): void;
+    yuvLightDismiss: i0.OutputEmitterRef<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LightDismissDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LightDismissDirective, "[yuvLightDismiss]", never, {}, { "yuvLightDismiss": "yuvLightDismiss"; }, never, never, true, never>;
+}
+
+/**
+ * Directive to watch the size of an element inside the DOM. Usefull for example to provide
+ * a different layout (different components) depending on the available screen estate. You
+ * should first try to use CSS container queries but somtimes you need a different set of
+ * components to be loaded for a certain component size.
+ *
+ * Let's say you have components designed for bigger screens. You do not want to load them
+ * if there is not enough space for them. So you rather load components that are designed to
+ * take less space by providing the best user experience on smaller devices.
+ *
+ * ```html
+ * <div yuvContainerSize (containerHeight)="onContainerResize($event)" (containerWidth)="onContainerResize($event)"></div>
+ * ```
+ *
+ */
+declare class ContainerSizeDirective implements OnDestroy {
+    private elRef;
+    private ngZone;
+    containerHeight: i0.OutputEmitterRef<number>;
+    containerWidth: i0.OutputEmitterRef<number>;
+    private _size?;
+    private _resizeObserver;
+    constructor();
+    private _emit;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContainerSizeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ContainerSizeDirective, "[yuvContainerSize]", never, {}, { "containerHeight": "containerHeight"; "containerWidth": "containerWidth"; }, never, never, true, never>;
+}
+
+declare class LongPressDirective {
+    private elRef;
+    threshold: number;
+    yuvLongPress: i0.InputSignal<LongPressDirectiveOptions>;
+    longpress: i0.OutputEmitterRef<void>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<LongPressDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LongPressDirective, "[yuvLongPress]", never, { "yuvLongPress": { "alias": "yuvLongPress"; "required": false; "isSignal": true; }; }, { "longpress": "longpress"; }, never, never, true, never>;
+}
+interface LongPressDirectiveOptions {
+    enabled: boolean;
+}
+
+interface DragSelectOptions {
+    disabled?: boolean;
+    selectorColor?: string;
+}
+declare class DragSelectDirective {
+    #private;
+    onPointerDown(event: PointerEvent): void;
+    items: i0.Signal<readonly DragSelectItemDirective[]>;
+    yuvDragSelect: i0.InputSignal<DragSelectOptions | undefined>;
+    dragSelectChange: i0.OutputEmitterRef<number[]>;
+    dragSelect: i0.OutputEmitterRef<number[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragSelectDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DragSelectDirective, "[yuvDragSelect]", never, { "yuvDragSelect": { "alias": "yuvDragSelect"; "required": false; "isSignal": true; }; }, { "dragSelectChange": "dragSelectChange"; "dragSelect": "dragSelect"; }, ["items"], never, true, never>;
+}
+declare class DragSelectItemDirective {
+    #private;
+    el: HTMLElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragSelectItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DragSelectItemDirective, "[yuvDragSelectItem]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Directive for adding drag scroll behaviour to a container element. Elements that overlow will then
+ * be 'scrollable' by dragging the list of children.
+ *
+ * @example
+ * <div yuvDragScroll>
+ *   <div class="tile">#1</div>
+ *   <div class="tile">#2</div>
+ *   <div class="tile">#3</div>
+ *   ...
+ * </div>
+ */
+declare class DragScrollDirective implements AfterViewInit {
+    #private;
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragScrollDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DragScrollDirective, "[yuvDragScroll]", never, {}, {}, never, never, true, never>;
+}
+
+declare class NoopValueAccessorDirective implements ControlValueAccessor {
+    writeValue(obj: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NoopValueAccessorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NoopValueAccessorDirective, never, never, {}, {}, never, never, true, never>;
+}
+declare function injectNgControl(cva?: ControlValueAccessor): NgControl | null;
+
+/**
+ * Directive putting focus on a 'focusable' child element.
+ * By default the first focusable child will receive focus.
+ */
+declare class AutofocusChildDirective implements AfterViewInit {
+    #private;
+    set yuvAutofocusChild(s: string);
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AutofocusChildDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AutofocusChildDirective, "[yuvAutofocusChild]", never, { "yuvAutofocusChild": { "alias": "yuvAutofocusChild"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Directive putting delayed focus on an element. If no
+ * delay is set, the focus will be set immediately.
+ *
+ * You have to ensure that the element is focusable when adding this directive to it.
+ */
+declare class AutofocusDelayedDirective implements AfterViewInit {
+    #private;
+    /**
+     * Sets the delay in milliseconds. If no delay is set, the focus will be set immediately.
+     */
+    yuvAutofocusDelayed: i0.InputSignal<string | number>;
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AutofocusDelayedDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AutofocusDelayedDirective, "[yuvAutofocusDelayed]", never, { "yuvAutofocusDelayed": { "alias": "yuvAutofocusDelayed"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Directive that adds left/right scroll buttons around the host element when its content overflows horizontally.
+ * The directive restructures the DOM by wrapping the host inside a scroll container with navigation buttons.
+ *
+ * @example
+ * <mat-chip-grid yuvScrollButtons>...</mat-chip-grid>
+ *
+ * @example
+ * <div yuvScrollButtons [yuvScrollButtonsAmount]="200">...</div>
+ */
+declare class ScrollButtonsDirective {
+    #private;
+    private readonly translate;
+    /** How many pixels to scroll per button click. */
+    yuvScrollButtonsAmount: i0.InputSignal<number>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollButtonsDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ScrollButtonsDirective, "[yuvScrollButtons]", never, { "yuvScrollButtonsAmount": { "alias": "yuvScrollButtonsAmount"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type LevelType = 'success' | 'warning' | 'error' | 'info' | 'default';
+interface ConfirmOverlayData {
+    title?: string;
+    message: string;
+    confirmLabel?: string;
+    cancelLabel?: string;
+    hideCancelButton?: boolean;
+    level?: Extract<LevelType, 'default' | 'info' | 'warning'>;
+}
+
+declare class ConfirmComponent {
+    readonly dialogData: ConfirmOverlayData;
+    buttonType: i0.Signal<"danger" | "primary">;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ConfirmComponent, "yuv-confirm", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Wrapper component that adds left/right scroll buttons when its content overflows horizontally.
+ * Buttons appear only when there is overflow in the respective direction.
+ *
+ * @example
+ * <yuv-scroll-buttons>
+ *   <mat-chip-grid>...</mat-chip-grid>
+ * </yuv-scroll-buttons>
+ */
+declare class ScrollButtonsComponent {
+    #private;
+    scrollContainer: i0.Signal<ElementRef<HTMLElement>>;
+    /** How many pixels to scroll per button click. */
+    scrollAmount: i0.InputSignal<number>;
+    showLeftButton: i0.WritableSignal<boolean>;
+    showRightButton: i0.WritableSignal<boolean>;
+    constructor();
+    onScroll(): void;
+    scrollLeft(): void;
+    scrollRight(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollButtonsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScrollButtonsComponent, "yuv-scroll-buttons", never, { "scrollAmount": { "alias": "scrollAmount"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class YuvCommonModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<YuvCommonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<YuvCommonModule, never, [typeof BusyOverlayDirective, typeof FocusWithinDirective, typeof FileDropZoneDirective, typeof ClickDoubleDirective, typeof LightDismissDirective, typeof ContainerSizeDirective, typeof LongPressDirective, typeof DragSelectDirective, typeof DragScrollDirective, typeof NoopValueAccessorDirective, typeof AutofocusChildDirective, typeof AutofocusDelayedDirective, typeof ScrollButtonsDirective, typeof ConfirmComponent, typeof ScrollButtonsComponent], [typeof BusyOverlayDirective, typeof FocusWithinDirective, typeof FileDropZoneDirective, typeof ClickDoubleDirective, typeof LightDismissDirective, typeof ContainerSizeDirective, typeof LongPressDirective, typeof DragSelectDirective, typeof DragScrollDirective, typeof NoopValueAccessorDirective, typeof AutofocusChildDirective, typeof AutofocusDelayedDirective, typeof ScrollButtonsDirective, typeof ConfirmComponent, typeof ScrollButtonsComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<YuvCommonModule>;
+}
+
+declare function getFocusableChildren(element: HTMLElement): HTMLElement[];
+declare function getFirstFocusableChild(element: HTMLElement): HTMLElement;
+
+type LayoutMode = 'light' | 'dark' | 'system';
+
+/**
+ * Service to store and retrieve layout settings. Those
+ * settings are stored on the users device because in
+ * general layout settings like panel widths are highly
+ * dependent on the current device.
+ */
+declare class LayoutSettingsService {
+    #private;
+    DEFAULT_SPLIT_VIEW_GUTTER_SIZE: number;
+    /**
+     * @deprecated Use `ThemeService.mode` instead.
+     */
+    themeMode: i0.WritableSignal<LayoutMode>;
+    /**
+     * @deprecated Use `ThemeService.mode` instead.
+     */
+    mode: i0.Signal<LayoutMode>;
+    /**
+     * @deprecated Theme initialization is now handled by `ThemeService` internally.
+     */
+    init(): void;
+    /**
+     * @deprecated Use `ThemeService.toggleTheme()` instead.
+     */
+    setMode(mode: LayoutMode): void;
+    saveSettings(key: string, settings: unknown): boolean;
+    getSettings(key: string): unknown | undefined;
+    /**
+     * Clears all layout settings.
+     */
+    clearSettings(): void;
+    /**
+     * @deprecated Use `ThemeService.toggleTheme()` instead.
+     */
+    applyLayoutMode(mode?: LayoutMode): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutSettingsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LayoutSettingsService>;
+}
+
+/**
+ * Providing an error message when a translation string for an object wasn't found
+ */
+declare class FormTranslateService {
+    private translate;
+    /**
+     * Set the error label if a translation for this string wasn't provided
+     * @param error - error message about a missed translation key
+     * @param params
+     */
+    getErrorLabel(error: string, params?: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormTranslateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FormTranslateService>;
+}
+
+type Mode = 'light' | 'dark';
+interface CustomThemeSettings {
+    key: string;
+    label: string;
+    description: string;
+    hasDarkTheme?: boolean;
+    hasLightTheme?: boolean;
+}
+declare enum ThemeStorageKeys {
+    THEME_MODE = "yuv.theme:app.theme.mode",
+    CUSTOM_THEME = "yuv.theme:app.theme.custom"
+}
+declare const DEFAULT_THEME_KEY = "yuv-default";
+declare const DEFAULT_THEME: CustomThemeSettings;
+declare const HIGH_CONTRAST_THEME_KEY = "yuv-high-contrast";
+declare const HIGH_CONTRAST_THEME: CustomThemeSettings;
+
+declare class ThemeService {
+    #private;
+    mode: i0.Signal<Mode>;
+    customTheme: i0.WritableSignal<CustomThemeSettings>;
+    customThemes: i0.Signal<CustomThemeSettings[]>;
+    currentTheme: i0.Signal<string>;
+    disableMode: i0.Signal<boolean>;
+    constructor();
+    setMode(mode: Mode): void;
+    setCustomTheme(key: string): void;
+    toggleTheme(theme: Mode): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThemeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ThemeService>;
+}
+
+declare const YUV_CUSTOM_THEME: InjectionToken<CustomThemeSettings[]>;
+declare const provideYuvCustomTheme: (customTheme: CustomThemeSettings[]) => EnvironmentProviders;
+
+declare abstract class AbstractMatFormField<T> implements MatFormFieldControl<T> {
+    #private;
+    stateChanges: Subject<void>;
+    protected elRef: ElementRef<any>;
+    onFocusIn(): void;
+    onFocusout(): void;
+    set value(v: T | null);
+    get value(): T | null;
+    set id(v: string);
+    get id(): string;
+    set placeholder(v: string);
+    get placeholder(): string;
+    ngControl: NgControl | null;
+    set focused(f: boolean);
+    get focused(): boolean;
+    get shouldLabelFloat(): boolean;
+    set empty(f: boolean);
+    get empty(): boolean;
+    set required(f: BooleanInput);
+    get required(): boolean;
+    set disabled(f: BooleanInput);
+    get disabled(): boolean;
+    protected focusHandled: i0.WritableSignal<boolean>;
+    set errorState(f: BooleanInput);
+    get errorState(): boolean;
+    readonly controlType?: string;
+    readonly autofilled?: boolean;
+    readonly userAriaDescribedBy?: string;
+    readonly disableAutomaticLabeling?: boolean;
+    setDescribedByIds(ids: string[]): void;
+    onContainerClick(event: MouseEvent): void;
+    onNgOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractMatFormField<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AbstractMatFormField<any>, "ng-component", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "required": { "alias": "required"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class DialogComponent {
+    headertitle: i0.InputSignal<string | null>;
+    /**
+     * @deprecated use headertitle instead
+     */
+    headertitel: i0.InputSignal<string | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DialogComponent, "yuv-dialog", never, { "headertitle": { "alias": "headertitle"; "required": false; "isSignal": true; }; "headertitel": { "alias": "headertitel"; "required": false; "isSignal": true; }; }, {}, never, ["main", "footer"], true, never>;
+}
+
+declare enum DialogSize {
+    SMALL = "small",
+    MEDIUM = "medium",
+    LARGE = "large",
+    EXTRA_LARGE = "extra-large",
+    FULL_SCREEN = "full-screen"
+}
+
+declare class RetentionBadgeComponent {
+    #private;
+    dmsObject: i0.InputSignal<DmsObject>;
+    retentionData: i0.Signal<RetentionState>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RetentionBadgeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RetentionBadgeComponent, "yuv-retention-badge", never, { "dmsObject": { "alias": "dmsObject"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ConfirmService {
+    #private;
+    confirm(data: ConfirmOverlayData): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfirmService>;
+}
+
+declare class BusyOverlayComponent {
+    config: i0.InputSignal<BusyOverlayConfig | undefined>;
+    error: i0.InputSignal<string | undefined>;
+    errorDismiss: i0.OutputEmitterRef<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BusyOverlayComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BusyOverlayComponent, "yuv-busy-overlay", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; }, { "errorDismiss": "errorDismiss"; }, never, never, true, never>;
+}
+
+declare class HaloFocusComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HaloFocusComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HaloFocusComponent, "yuv-halo-focus", never, {}, {}, never, never, true, never>;
+}
+
+export { AbstractMatFormField, AutofocusChildDirective, AutofocusDelayedDirective, BusyOverlayComponent, BusyOverlayDirective, ClickDoubleDirective, ConfirmComponent, ConfirmService, ContainerSizeDirective, DEFAULT_THEME, DEFAULT_THEME_KEY, DialogComponent, DialogSize, DragScrollDirective, DragSelectDirective, DragSelectItemDirective, FileDropZoneDirective, FocusWithinDirective, FormTranslateService, HIGH_CONTRAST_THEME, HIGH_CONTRAST_THEME_KEY, HaloFocusComponent, LayoutSettingsService, LightDismissDirective, LongPressDirective, NoopValueAccessorDirective, RetentionBadgeComponent, ScrollButtonsComponent, ScrollButtonsDirective, ThemeService, ThemeStorageKeys, YUV_CUSTOM_THEME, YuvCommonModule, getFirstFocusableChild, getFocusableChildren, injectNgControl, provideYuvCustomTheme };
+export type { ConfirmOverlayData, CustomThemeSettings, DragSelectOptions, LayoutMode, LevelType, LongPressDirectiveOptions, Mode };

package/types/yuuvis-client-components-datepicker.d.ts

@@ -0,0 +1,94 @@
+import * as _angular_core from '@angular/core';
+import { ElementRef } from '@angular/core';
+import * as i1 from '@angular/common';
+import { ControlValueAccessor, Validator, AbstractControl, ValidationErrors } from '@angular/forms';
+
+declare class DatepickerModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DatepickerModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<DatepickerModule, never, [typeof i1.CommonModule], never>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<DatepickerModule>;
+}
+
+interface CalendarDay {
+    date: Date;
+    dayNumber: number;
+    dateIso: string;
+    isToday: boolean;
+    isSelected: boolean;
+    isOutsideMonth: boolean;
+    isDisabled: boolean;
+    isFocusTarget: boolean;
+    fullLabel: string;
+}
+interface WeekdayHeader {
+    narrow: string;
+    long: string;
+}
+
+declare class CalendarComponent {
+    private readonly localeService;
+    private readonly elementRef;
+    private readonly cdr;
+    readonly selectedDate: _angular_core.InputSignal<Date | null>;
+    readonly initialFocusDate: _angular_core.InputSignal<Date>;
+    readonly min: _angular_core.InputSignal<Date | null>;
+    readonly dateSelected: _angular_core.OutputEmitterRef<Date>;
+    readonly closeRequested: _angular_core.OutputEmitterRef<void>;
+    protected readonly gridLabelId: string;
+    protected readonly focusedDate: _angular_core.WritableSignal<Date>;
+    protected readonly weekdayHeaders: WeekdayHeader[];
+    protected readonly monthYearLabel: _angular_core.Signal<string>;
+    protected readonly weeks: _angular_core.Signal<CalendarDay[][]>;
+    constructor();
+    focusActiveCell(): void;
+    protected selectDate(day: CalendarDay): void;
+    protected navigateMonth(delta: number): void;
+    protected navigateYear(delta: number): void;
+    protected onGridKeydown(event: KeyboardEvent): void;
+    private generateWeeks;
+    private isBeforeMin;
+    private moveFocusClamped;
+    private addDays;
+    private startOfWeek;
+    private endOfWeek;
+    private moveFocusMonth;
+    private moveFocusYear;
+    private isSameDay;
+    private toIsoString;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CalendarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CalendarComponent, "yuv-calendar", never, { "selectedDate": { "alias": "selectedDate"; "required": false; "isSignal": true; }; "initialFocusDate": { "alias": "initialFocusDate"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; }, { "dateSelected": "dateSelected"; "closeRequested": "closeRequested"; }, never, never, true, never>;
+}
+
+declare class DatepickerComponent implements ControlValueAccessor, Validator {
+    private readonly localeService;
+    readonly label: _angular_core.InputSignal<string>;
+    readonly min: _angular_core.InputSignal<Date | null>;
+    protected readonly selectedDate: _angular_core.WritableSignal<Date | null>;
+    protected readonly inputValue: _angular_core.WritableSignal<string>;
+    protected readonly disabled: _angular_core.WritableSignal<boolean>;
+    private readonly uid;
+    protected readonly inputId: string;
+    protected readonly descriptionId: string;
+    protected readonly calendarDialog: _angular_core.Signal<ElementRef<HTMLDialogElement>>;
+    protected readonly triggerButton: _angular_core.Signal<ElementRef<HTMLButtonElement>>;
+    protected readonly calendarRef: _angular_core.Signal<CalendarComponent>;
+    protected readonly dateFormatPlaceholder: string;
+    protected readonly chooseButtonAriaLabel: _angular_core.Signal<string>;
+    protected readonly initialFocusDate: _angular_core.Signal<Date>;
+    private onChange;
+    protected onTouched: () => void;
+    writeValue(value: Date | null): void;
+    registerOnChange(fn: (value: Date | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    validate(_control: AbstractControl): ValidationErrors | null;
+    protected onManualInput(event: Event): void;
+    protected toggleDialog(): void;
+    protected onDateSelected(date: Date): void;
+    protected onDialogClose(): void;
+    protected onDialogBackdropClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DatepickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DatepickerComponent, "yuv-datepicker", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { DatepickerComponent, DatepickerModule };