@elementar-rt/components 0.6.55

package/color-scheme/index.d.ts

@@ -0,0 +1,44 @@
+import * as i0 from '@angular/core';
+import { OnInit, TemplateRef } from '@angular/core';
+import { TemplatePortal } from '@angular/cdk/portal';
+import * as _ngrx_signals from '@ngrx/signals';
+
+declare const COLOR_SCHEME_LOCAL_KEY = "elementar-ui-color-scheme";
+type ColorScheme = 'light' | 'dark';
+
+declare class ColorSchemeSwitcherComponent implements OnInit {
+    private store;
+    private viewContainerRef;
+    private lightRef;
+    private darkRef;
+    readonly colorScheme: i0.Signal<ColorScheme>;
+    readonly colorSchemeChanged: i0.OutputEmitterRef<ColorScheme>;
+    protected portal: TemplatePortal<any>;
+    ngOnInit(): void;
+    protected toggleScheme(): void;
+    private setPortal;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColorSchemeSwitcherComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ColorSchemeSwitcherComponent, "emr-color-scheme-switcher", ["emrColorSchemeSwitcher"], {}, { "colorSchemeChanged": "colorSchemeChanged"; }, ["lightRef", "darkRef"], never, true, never>;
+}
+
+declare class ColorSchemeLightDirective {
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColorSchemeLightDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ColorSchemeLightDirective, "[emrColorSchemeLight]", never, {}, {}, never, never, true, never>;
+}
+
+declare class ColorSchemeDarkDirective {
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColorSchemeDarkDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ColorSchemeDarkDirective, "[emrColorSchemeDark]", never, {}, {}, never, never, true, never>;
+}
+
+declare const ColorSchemeStore: i0.Type<{
+    theme: i0.Signal<ColorScheme>;
+    setScheme: (scheme: ColorScheme) => void;
+} & _ngrx_signals.StateSource<{
+    theme: ColorScheme;
+}>>;
+
+export { COLOR_SCHEME_LOCAL_KEY, ColorSchemeDarkDirective, ColorSchemeLightDirective, ColorSchemeStore, ColorSchemeSwitcherComponent };
+export type { ColorScheme };

package/command-bar/index.d.ts

@@ -0,0 +1,28 @@
+import * as i0 from '@angular/core';
+import * as i1 from '@angular/material/core';
+
+type CommandBarPosition = 'top' | 'bottom';
+
+declare class CommandBarComponent {
+    private _elementRef;
+    private _renderer;
+    open: i0.InputSignalWithTransform<boolean, unknown>;
+    position: i0.InputSignal<CommandBarPosition>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommandBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CommandBarComponent, "emr-command-bar", ["emrCommandBar"], { "open": { "alias": "open"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; }, {}, never, ["*", "emr-command-bar-command,[emr-command-bar-command],emr-command-bar-divider"], true, never>;
+}
+
+declare class CommandBarDividerComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommandBarDividerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CommandBarDividerComponent, "emr-command-bar-divider", ["emrCommandBarDivider"], {}, {}, never, never, true, never>;
+}
+
+declare class CommandBarCommandComponent {
+    shortcut: i0.InputSignal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommandBarCommandComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CommandBarCommandComponent, "emr-command-bar-command,[emr-command-bar-command]", ["emrCommandBarCommand"], { "shortcut": { "alias": "shortcut"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.MatRipple; inputs: {}; outputs: {}; }]>;
+}
+
+export { CommandBarCommandComponent, CommandBarComponent, CommandBarDividerComponent };
+export type { CommandBarPosition };

package/comment-editor/index.d.ts

@@ -0,0 +1,194 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, OnInit, OnDestroy } from '@angular/core';
+import { Editor } from '@tiptap/core';
+import * as i1 from '@elementar-rt/components/upload';
+import { UploadFileSelectedEvent } from '@elementar-rt/components/upload';
+
+interface CommentEditor {
+    api: CommentEditorAPI;
+}
+interface CommentEditorAPI {
+    isCommandDisabled: (command: string) => boolean | null;
+    isActive: (command: string) => boolean | null;
+    runCommand: (command: string) => void;
+    editor: () => Editor;
+    isToolbarActive: () => boolean;
+    toggleToolbar: () => void;
+    isEditorActivated: () => boolean;
+}
+declare const COMMENT_EDITOR: InjectionToken<unknown>;
+declare const COMMENT_EDITOR_BUBBLE_MENU: InjectionToken<unknown>;
+
+declare class CommentEditorComponent implements OnInit, OnDestroy {
+    private _platformId;
+    private _document;
+    private _cdr;
+    private _injector;
+    private _content;
+    private _bubbleMenu;
+    private _imageBubbleMenu;
+    protected _value: string;
+    protected editor: Editor;
+    protected showToolbar: boolean;
+    protected fullView: boolean;
+    contentMaxHeight: i0.InputSignal<number | undefined>;
+    buttonCancelLabel: i0.InputSignal<string>;
+    buttonSendLabel: i0.InputSignal<string>;
+    placeholder: i0.InputSignal<string>;
+    toolbarAlwaysVisible: i0.InputSignalWithTransform<boolean, unknown>;
+    fullViewMode: i0.InputSignalWithTransform<boolean, unknown>;
+    cancelButtonAlwaysVisible: i0.InputSignalWithTransform<boolean, unknown>;
+    imageUploadFn: i0.InputSignal<((file: Blob) => Promise<string>) | undefined>;
+    readonly sent: i0.OutputEmitterRef<string>;
+    readonly canceled: i0.OutputEmitterRef<void>;
+    ngOnInit(): void;
+    get api(): CommentEditorAPI;
+    isCommandDisabled(command: string): boolean | null;
+    ngOnDestroy(): void;
+    send(event: MouseEvent): void;
+    activateFullView(): void;
+    toggleToolbar(): void;
+    cancel(event: MouseEvent): void;
+    private _runCommand;
+    private _init;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CommentEditorComponent, "emr-comment-editor", ["emrCommentEditor"], { "contentMaxHeight": { "alias": "contentMaxHeight"; "required": false; "isSignal": true; }; "buttonCancelLabel": { "alias": "buttonCancelLabel"; "required": false; "isSignal": true; }; "buttonSendLabel": { "alias": "buttonSendLabel"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "toolbarAlwaysVisible": { "alias": "toolbarAlwaysVisible"; "required": false; "isSignal": true; }; "fullViewMode": { "alias": "fullViewMode"; "required": false; "isSignal": true; }; "cancelButtonAlwaysVisible": { "alias": "cancelButtonAlwaysVisible"; "required": false; "isSignal": true; }; "imageUploadFn": { "alias": "imageUploadFn"; "required": false; "isSignal": true; }; }, { "sent": "sent"; "canceled": "canceled"; }, never, ["emr-comment-editor-toolbar", "emr-comment-editor-footer-bar", "emr-comment-editor-bubble-menu"], true, never>;
+}
+
+declare class CommentEditorDividerComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentEditorDividerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CommentEditorDividerComponent, "emr-comment-editor-divider", never, {}, {}, never, never, true, never>;
+}
+
+declare class CommentEditorToolbarComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentEditorToolbarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CommentEditorToolbarComponent, "emr-comment-editor-toolbar", ["emrCommentEditorToolbar"], {}, {}, never, ["[emrCommentEditorCommand],emr-comment-editor-divider"], true, never>;
+}
+
+declare class CommentEditorBubbleMenuComponent {
+    protected commentEditor: CommentEditor;
+    getLinkUrl(): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentEditorBubbleMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CommentEditorBubbleMenuComponent, "emr-comment-editor-bubble-menu", ["emrCommentEditorBubbleMenu"], {}, {}, never, ["[emrCommentEditorCommandEditLink],[emrCommentEditorCommandUnsetLink]", "[emrCommentEditorCommand],emr-comment-editor-divider"], true, never>;
+}
+
+declare class CommentEditorFooterBarComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentEditorFooterBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CommentEditorFooterBarComponent, "emr-comment-editor-footer-bar", ["emrCommentEditorFooterBar"], {}, {}, never, ["[emrCommentEditorCommand],emr-comment-editor-divider"], true, never>;
+}
+
+declare class CommentEditorCommandDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentEditorCommandDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CommentEditorCommandDirective, "[emrCommentEditorCommand]", never, {}, {}, never, never, true, never>;
+}
+
+declare class CommentEditorCommandBoldDirective {
+    protected commentEditor: CommentEditor;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentEditorCommandBoldDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CommentEditorCommandBoldDirective, "[emrCommentEditorCommandBold]", ["emrCommentEditorCommandBold"], {}, {}, never, never, true, never>;
+}
+
+declare class CommentEditorCommandItalicDirective {
+    protected commentEditor: CommentEditor;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentEditorCommandItalicDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CommentEditorCommandItalicDirective, "[emrCommentEditorCommandItalic]", never, {}, {}, never, never, true, never>;
+}
+
+declare class CommentEditorCommandStrikeDirective {
+    protected commentEditor: CommentEditor;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentEditorCommandStrikeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CommentEditorCommandStrikeDirective, "[emrCommentEditorCommandStrike]", never, {}, {}, never, never, true, never>;
+}
+
+declare class CommentEditorCommandBulletListDirective {
+    protected commentEditor: CommentEditor;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentEditorCommandBulletListDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CommentEditorCommandBulletListDirective, "[emrCommentEditorCommandBulletList]", never, {}, {}, never, never, true, never>;
+}
+
+declare class CommentEditorCommandOrderedListDirective {
+    protected commentEditor: CommentEditor;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentEditorCommandOrderedListDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CommentEditorCommandOrderedListDirective, "[emrCommentEditorCommandOrderedList]", never, {}, {}, never, never, true, never>;
+}
+
+declare class CommentEditorCommandBlockquoteDirective {
+    protected commentEditor: CommentEditor;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentEditorCommandBlockquoteDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CommentEditorCommandBlockquoteDirective, "[emrCommentEditorCommandBlockquote]", never, {}, {}, never, never, true, never>;
+}
+
+declare class CommentEditorCommandCodeBlockDirective {
+    protected commentEditor: CommentEditor;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentEditorCommandCodeBlockDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CommentEditorCommandCodeBlockDirective, "[emrCommentEditorCommandCodeBlock]", never, {}, {}, never, never, true, never>;
+}
+
+declare class CommentEditorCommandImageDirective {
+    protected commentEditor: CommentEditor;
+    protected onImageSelected(event: UploadFileSelectedEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentEditorCommandImageDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CommentEditorCommandImageDirective, "[emrCommentEditorCommandImage]", never, {}, {}, never, never, true, [{ directive: typeof i1.UploadTriggerDirective; inputs: {}; outputs: { "fileSelected": "fileSelected"; }; }]>;
+}
+
+declare class CommentEditorCommandYoutubeDirective {
+    protected commentEditor: CommentEditor;
+    private _dialog;
+    private _destroyRef;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentEditorCommandYoutubeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CommentEditorCommandYoutubeDirective, "[emrCommentEditorCommandYoutube]", never, {}, {}, never, never, true, never>;
+}
+
+declare class CommentEditorCommandLinkDirective {
+    private _destroyRef;
+    private _dialog;
+    protected commentEditor: CommentEditor;
+    protected setLinkActive: boolean;
+    protected onClick(): void;
+    private _setLink;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentEditorCommandLinkDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CommentEditorCommandLinkDirective, "[emrCommentEditorCommandLink]", never, {}, {}, never, never, true, never>;
+}
+
+declare class CommentEditorCommandCodeDirective {
+    protected commentEditor: CommentEditor;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentEditorCommandCodeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CommentEditorCommandCodeDirective, "[emrCommentEditorCommandCode]", never, {}, {}, never, never, true, never>;
+}
+
+declare class CommentEditorCommandEditLinkDirective {
+    private _destroyRef;
+    private _dialog;
+    protected commentEditor: CommentEditor;
+    protected setLinkActive: boolean;
+    protected onClick(): void;
+    private _setLink;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentEditorCommandEditLinkDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CommentEditorCommandEditLinkDirective, "[emrCommentEditorCommandEditLink]", never, {}, {}, never, never, true, never>;
+}
+
+declare class CommentEditorCommandUnsetLinkDirective {
+    protected commentEditor: CommentEditor;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentEditorCommandUnsetLinkDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CommentEditorCommandUnsetLinkDirective, "[emrCommentEditorCommandUnsetLink]", never, {}, {}, never, never, true, never>;
+}
+
+declare class CommentEditorCommandToggleToolbarDirective {
+    protected commentEditor: CommentEditor;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentEditorCommandToggleToolbarDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CommentEditorCommandToggleToolbarDirective, "[emrCommentEditorCommandToggleToolbar]", never, {}, {}, never, never, true, never>;
+}
+
+export { COMMENT_EDITOR, COMMENT_EDITOR_BUBBLE_MENU, CommentEditorBubbleMenuComponent, CommentEditorCommandBlockquoteDirective, CommentEditorCommandBoldDirective, CommentEditorCommandBulletListDirective, CommentEditorCommandCodeBlockDirective, CommentEditorCommandCodeDirective, CommentEditorCommandDirective, CommentEditorCommandEditLinkDirective, CommentEditorCommandImageDirective, CommentEditorCommandItalicDirective, CommentEditorCommandLinkDirective, CommentEditorCommandOrderedListDirective, CommentEditorCommandStrikeDirective, CommentEditorCommandToggleToolbarDirective, CommentEditorCommandUnsetLinkDirective, CommentEditorCommandYoutubeDirective, CommentEditorComponent, CommentEditorDividerComponent, CommentEditorFooterBarComponent, CommentEditorToolbarComponent };
+export type { CommentEditor, CommentEditorAPI };

package/comparison-slider/index.d.ts

@@ -0,0 +1,51 @@
+import * as i0 from '@angular/core';
+import { AfterViewInit, OnDestroy, Renderer2 } from '@angular/core';
+
+declare class ComparisonSliderComponent implements AfterViewInit, OnDestroy {
+    private renderer;
+    initialPosition: i0.InputSignal<number>;
+    sliderPosition: i0.WritableSignal<number>;
+    isDragging: i0.WritableSignal<boolean>;
+    private sliderContainerRef;
+    private handleRef;
+    private containerRect;
+    private unlistenMouseMove;
+    private unlistenMouseUp;
+    private unlistenTouchMove;
+    private unlistenTouchEnd;
+    private resizeObserver;
+    private platformId;
+    private isBrowser;
+    constructor(renderer: Renderer2);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private updateContainerRect;
+    handleLeftStyle: i0.Signal<string>;
+    afterImageClipStyle: i0.Signal<string>;
+    onMouseDown(event: MouseEvent): void;
+    onTouchStart(event: TouchEvent): void;
+    private onMouseMove;
+    private onTouchMove;
+    private updateSliderPosition;
+    private onMouseUp;
+    private onTouchEnd;
+    private removeGlobalListeners;
+    onContainerClick(event: MouseEvent): void;
+    onDragStart(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComparisonSliderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ComparisonSliderComponent, "emr-comparison-slider", ["emrComparisonSlider"], { "initialPosition": { "alias": "initialPosition"; "required": false; "isSignal": true; }; }, {}, never, ["[emrComparisonSliderBeforeImage]", "[emrComparisonSliderAfterImage]"], true, never>;
+}
+
+declare class ComparisonSliderAfterImageDirective {
+    protected onDragStart(event: DragEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComparisonSliderAfterImageDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ComparisonSliderAfterImageDirective, "[emrComparisonSliderAfterImage]", never, {}, {}, never, never, true, never>;
+}
+
+declare class ComparisonSliderBeforeImageDirective {
+    protected onDragStart(event: DragEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComparisonSliderBeforeImageDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ComparisonSliderBeforeImageDirective, "[emrComparisonSliderBeforeImage]", never, {}, {}, never, never, true, never>;
+}
+
+export { ComparisonSliderAfterImageDirective, ComparisonSliderBeforeImageDirective, ComparisonSliderComponent };

package/confirm/index.d.ts

@@ -0,0 +1,35 @@
+import * as i0 from '@angular/core';
+import { EventEmitter } from '@angular/core';
+
+interface ConfirmOptions {
+    title: string;
+    description: string;
+}
+
+declare class ConfirmRef {
+    readonly canceled: EventEmitter<any>;
+    readonly confirmed: EventEmitter<any>;
+    readonly closed: EventEmitter<any>;
+    close(): void;
+    cancel(): void;
+    confirm(): void;
+}
+
+declare class ConfirmManager {
+    private _dialog;
+    private _destroyRef;
+    open(options: ConfirmOptions): ConfirmRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmManager, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfirmManager>;
+}
+
+declare class ConfirmComponent {
+    private _data;
+    private _dialogRef;
+    title: any;
+    description: any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ConfirmComponent, "emr-confirm", ["emrConfirm"], {}, {}, never, never, true, never>;
+}
+
+export { ConfirmComponent, ConfirmManager, ConfirmRef };

package/content-fade/index.d.ts

@@ -0,0 +1,17 @@
+import * as _angular_core from '@angular/core';
+import { OnChanges, SimpleChanges } from '@angular/core';
+
+type ContentFadePosition = 'both' | 'start' | 'end';
+
+declare class ContentFadeComponent implements OnChanges {
+    private _elementRef;
+    color: _angular_core.InputSignal<unknown>;
+    width: _angular_core.InputSignal<unknown>;
+    position: _angular_core.InputSignal<ContentFadePosition>;
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ContentFadeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ContentFadeComponent, "emr-content-fade", ["emrContentFade"], { "color": { "alias": "color"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { ContentFadeComponent };
+export type { ContentFadePosition };

package/cookie-popup/index.d.ts

@@ -0,0 +1,41 @@
+import * as i0 from '@angular/core';
+
+type CookiePopupAcceptType = 'all' | 'necessary';
+
+declare class CookiePopupComponent {
+    private _overlay;
+    private _viewContainerRef;
+    private _injector;
+    private _contentRef;
+    cookiePolicyUrl: i0.InputSignal<string>;
+    visible: i0.InputSignalWithTransform<boolean, unknown>;
+    private _overlayRef;
+    readonly cookieAccepted: i0.OutputEmitterRef<CookiePopupAcceptType>;
+    constructor();
+    acceptNecessaryCookiesOnly(): void;
+    acceptAllCookies(): void;
+    private _show;
+    private _hide;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CookiePopupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CookiePopupComponent, "emr-cookie-popup", ["emrCookiePopup"], { "cookiePolicyUrl": { "alias": "cookiePolicyUrl"; "required": false; "isSignal": true; }; "visible": { "alias": "visible"; "required": false; "isSignal": true; }; }, { "cookieAccepted": "cookieAccepted"; }, never, ["[emrCookiePopupTitle]", "*", "[emrCookiePopupAcceptNecessaryOnlyButton]", "[emrCookiePopupAcceptAllButton]"], true, never>;
+}
+
+declare class CookiePopupTitleDirective {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<CookiePopupTitleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CookiePopupTitleDirective, "[emrCookiePopupTitle]", never, {}, {}, never, never, true, never>;
+}
+
+declare class CookiePopupAcceptAllButtonDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CookiePopupAcceptAllButtonDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CookiePopupAcceptAllButtonDirective, "[emrCookiePopupAcceptAllButton]", never, {}, {}, never, never, true, never>;
+}
+
+declare class CookiePopupAcceptNecessaryOnlyButtonDirective {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<CookiePopupAcceptNecessaryOnlyButtonDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CookiePopupAcceptNecessaryOnlyButtonDirective, "[emrCookiePopupAcceptNecessaryOnlyButton]", never, {}, {}, never, never, true, never>;
+}
+
+export { CookiePopupAcceptAllButtonDirective, CookiePopupAcceptNecessaryOnlyButtonDirective, CookiePopupComponent, CookiePopupTitleDirective };
+export type { CookiePopupAcceptType };

package/core/index.d.ts

@@ -0,0 +1,252 @@
+import * as i0 from '@angular/core';
+import { AfterViewInit, OnDestroy, OnChanges, SimpleChanges, OnInit, AfterContentInit, EventEmitter, ElementRef, Renderer2, PipeTransform, InjectionToken } from '@angular/core';
+import { ThemePalette, MatOptionParentComponent, MatOptionSelectionChange } from '@angular/material/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { MatOption } from '@angular/material/select';
+import { SelectionModel } from '@angular/cdk/collections';
+import { Observable } from 'rxjs';
+import { TitleStrategy, RouterStateSnapshot } from '@angular/router';
+import { Meta } from '@angular/platform-browser';
+import * as _ngrx_signals from '@ngrx/signals';
+
+declare class AutoFocusDirective implements AfterViewInit {
+    private _elementRef;
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AutoFocusDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AutoFocusDirective, "[emrAutoFocus]", ["emrAutoFocus"], {}, {}, never, never, true, never>;
+}
+
+declare class FocusElementDirective implements AfterViewInit, OnDestroy {
+    private _elementRef;
+    private _focusMonitor;
+    checkChildren: i0.InputSignalWithTransform<boolean, unknown>;
+    readonly elementFocused: i0.OutputEmitterRef<void>;
+    readonly elementBlurred: i0.OutputEmitterRef<void>;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private _emitFocusEvent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FocusElementDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FocusElementDirective, "[emrFocusElement]", ["emrFocusElement"], { "checkChildren": { "alias": "checkChildren"; "required": false; "isSignal": true; }; }, { "elementFocused": "elementFocused"; "elementBlurred": "elementBlurred"; }, never, never, true, never>;
+}
+
+declare class SoundEffectDirective {
+    soundSrc: i0.InputSignal<string>;
+    private _elementRef;
+    private _destroyRef;
+    constructor();
+    private _init;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SoundEffectDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SoundEffectDirective, "[emrSoundEffect]", never, { "soundSrc": { "alias": "soundSrc"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ButtonDirective implements OnChanges {
+    private _matButton;
+    private _viewContainerRef;
+    private _renderer;
+    private _spinner;
+    private _platformId;
+    loading: i0.InputSignalWithTransform<boolean, unknown>;
+    disabled: i0.InputSignalWithTransform<boolean, unknown>;
+    color: i0.InputSignal<ThemePalette>;
+    ngOnChanges(changes: SimpleChanges): void;
+    private createSpinner;
+    private destroySpinner;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ButtonDirective, "[emrButtonLoading]", ["emrButtonLoading"], { "loading": { "alias": "emrButtonLoading"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MenuOptionGroupDirective implements MatOptionParentComponent, OnInit, ControlValueAccessor, AfterContentInit {
+    private _changeDetectorRef;
+    private _destroyRef;
+    disableRipple: boolean;
+    multiple: boolean;
+    inertGroups: boolean;
+    hideSingleSelectionIndicator: boolean;
+    _selectionModel: SelectionModel<MatOption>;
+    private _value;
+    readonly options: i0.Signal<readonly MatOption<any>[]>;
+    private _initialized;
+    readonly valueChange: EventEmitter<any>;
+    readonly optionSelectionChanges: Observable<MatOptionSelectionChange>;
+    onChange: any;
+    onTouched: any;
+    ngOnInit(): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    ngAfterContentInit(): void;
+    private _selectOptionByValue;
+    writeValue(newValue: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MenuOptionGroupDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MenuOptionGroupDirective, "[emrMenuOptionGroup]", never, {}, { "valueChange": "valueChange"; }, ["options"], never, true, never>;
+}
+
+declare class DebounceTimeDirective implements ControlValueAccessor {
+    private elementRef;
+    private renderer;
+    private debounceTimer?;
+    readonly debounceTime: i0.InputSignalWithTransform<number, unknown>;
+    private onChange;
+    private onTouched;
+    constructor(elementRef: ElementRef<HTMLInputElement>, renderer: Renderer2);
+    writeValue(value: string): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState?(isDisabled: boolean): void;
+    protected handleInput(event: Event): void;
+    protected handleBlur(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DebounceTimeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DebounceTimeDirective, "[emrDebounceTime][ngModel]", never, { "debounceTime": { "alias": "debounceTime"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class InitialsPipe implements PipeTransform {
+    transform(value: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InitialsPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<InitialsPipe, "initials", true>;
+}
+
+declare class FormatFileSizePipe implements PipeTransform {
+    transform(bytes: number, decimalPoint?: number): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormatFileSizePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FormatFileSizePipe, "formatFileSize", true>;
+}
+
+declare class OrderByPipe implements PipeTransform {
+    transform(value: any, property: string, direction?: 'asc' | 'desc'): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OrderByPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<OrderByPipe, "orderBy", true>;
+}
+
+declare class SafeHtmlPipe implements PipeTransform {
+    private _domSanitizer;
+    transform(value: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SafeHtmlPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SafeHtmlPipe, "safeHtml", true>;
+}
+
+declare class SafeResourceUrlPipe implements PipeTransform {
+    private _domSanitizer;
+    transform(value: string): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SafeResourceUrlPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SafeResourceUrlPipe, "safeResourceUrl", true>;
+}
+
+declare class FilterByPropertyPipe implements PipeTransform {
+    private getNestedValue;
+    transform<T>(items: T[], propPath: string, value: any, strict?: boolean): T[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterByPropertyPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FilterByPropertyPipe, "filterByProperty", true>;
+}
+
+declare class SearchByPropertyPipe implements PipeTransform {
+    private getNestedValue;
+    transform<T>(items: T[] | null, propPath: string, searchValue: string): T[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<SearchByPropertyPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SearchByPropertyPipe, "searchByProperty", true>;
+}
+
+declare class AnalyticsService {
+    private _platformId;
+    private _router;
+    private _document;
+    private _environmentService;
+    trackPageViews(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnalyticsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AnalyticsService>;
+}
+
+declare class InactivityTrackerService {
+    private _destroyRef;
+    private _document;
+    private _interval;
+    private _timeout;
+    private _interactionEvents$;
+    private _noInteraction;
+    setupInactivityTimer(interval?: number): Observable<void>;
+    reset(): void;
+    private _setupTimer;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InactivityTrackerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InactivityTrackerService>;
+}
+
+declare class PageTitleStrategyService extends TitleStrategy {
+    private _title;
+    private _globalStore;
+    updateTitle(routerState: RouterStateSnapshot): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PageTitleStrategyService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PageTitleStrategyService>;
+}
+
+declare class ScreenLoaderService {
+    private _globalStore;
+    show(): void;
+    hide(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScreenLoaderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ScreenLoaderService>;
+}
+
+declare class SeoService {
+    private readonly _router;
+    private readonly _destroyRef;
+    private readonly _document;
+    private readonly _platformId;
+    private _linkCanonical;
+    private _title;
+    private _meta;
+    private _globalStore;
+    get meta(): Meta;
+    updateDescription(content?: string): void;
+    updateOgUrl(content?: string): void;
+    updateOgImage(content: string): void;
+    trackCanonicalChanges(siteUrl: string): void;
+    updateTitle(title: string): void;
+    private getCanonicalUrl;
+    private _createCanonicalTag;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SeoService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SeoService>;
+}
+
+declare class ThemeManagerService {
+    private _document;
+    private _window;
+    private _colorScheme;
+    constructor();
+    getColorScheme(): 'dark' | 'light';
+    toggleColorScheme(): void;
+    changeColorScheme(colorScheme: 'dark' | 'light'): void;
+    private _getStoredColorScheme;
+    private _setStoredColorScheme;
+    getPreferredColorScheme(): 'dark' | 'light';
+    setColorScheme(colorScheme: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThemeManagerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ThemeManagerService>;
+}
+
+declare const ENVIRONMENT: InjectionToken<{
+    [key: string]: any;
+}>;
+declare class EnvironmentService {
+    private _environment;
+    getValue(key: string, defaultValue?: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EnvironmentService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EnvironmentService>;
+}
+
+interface GlobalState {
+    screenLoading: boolean;
+    sidebarHidden: boolean;
+    pageTitle: string;
+}
+declare const GlobalStore: i0.Type<{
+    screenLoading: i0.Signal<boolean>;
+    sidebarHidden: i0.Signal<boolean>;
+    pageTitle: i0.Signal<string>;
+    setScreenLoading: (isLoading: boolean) => void;
+    setPageTitle: (pageTitle: string) => void;
+} & _ngrx_signals.StateSource<{
+    screenLoading: boolean;
+    sidebarHidden: boolean;
+    pageTitle: string;
+}>>;
+
+export { AnalyticsService, AutoFocusDirective, ButtonDirective, DebounceTimeDirective, ENVIRONMENT, EnvironmentService, FilterByPropertyPipe, FocusElementDirective, FormatFileSizePipe, GlobalStore, InactivityTrackerService, InitialsPipe, MenuOptionGroupDirective, OrderByPipe, PageTitleStrategyService, SafeHtmlPipe, SafeResourceUrlPipe, ScreenLoaderService, SearchByPropertyPipe, SeoService, SoundEffectDirective, ThemeManagerService };
+export type { GlobalState };