@elementar-rt/components 0.6.55

package/form-renderer/index.d.ts

@@ -0,0 +1,121 @@
+import * as i0 from '@angular/core';
+import { Type, InjectionToken, OnInit, OnDestroy, Signal } from '@angular/core';
+import { FormGroup, ValidationErrors, ValidatorFn, FormBuilder, FormControl } from '@angular/forms';
+
+type ComponentImporter = () => Promise<Type<any>>;
+declare class ComponentRegistryService {
+    private globalRegistry;
+    private componentMap;
+    constructor();
+    private registerDefaultComponents;
+    getImporter(typeName: string): ComponentImporter | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComponentRegistryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ComponentRegistryService>;
+}
+
+declare const FORM_RENDERER_FIELD_REGISTRY: InjectionToken<{
+    [fieldName: string]: ComponentImporter;
+}>;
+interface ValidatorConfig {
+    type: string;
+    value?: any;
+    message: string;
+}
+interface BaseComponentConfig {
+    name: string;
+    type: string;
+}
+interface FormFieldConfig extends BaseComponentConfig {
+    kind: 'field';
+    value?: any;
+    validators?: ValidatorConfig[];
+    label?: string;
+    placeholder?: string;
+    inputType?: 'text' | 'number' | 'email' | 'password';
+    readonly?: boolean;
+    disabled?: boolean;
+    inline?: boolean;
+    visibleWhen?: (formGroup: FormGroup) => boolean;
+    payload?: {
+        [key: string]: any;
+    };
+    hint?: string;
+}
+interface ContentConfig extends BaseComponentConfig {
+    kind: 'content';
+    content?: {
+        [key: string]: any;
+    };
+}
+type ComponentConfig = FormFieldConfig | ContentConfig | any;
+interface ComponentNode {
+    name: string;
+    colspan?: number;
+}
+interface GridNode {
+    columns: number;
+    gap?: string;
+    children: LayoutNode[];
+}
+type LayoutNode = ComponentNode | GridNode;
+type CrossValidatorFn = (formGroup: FormGroup) => ValidationErrors | null;
+interface FormConfig {
+    elements: ComponentConfig[];
+    layout: LayoutNode;
+    crossValidators?: CrossValidatorFn[];
+}
+
+type ValidatorFactory = (config: ValidatorConfig) => ValidatorFn;
+declare class ValidatorRegistryService {
+    private validatorMap;
+    constructor();
+    private registerDefaultValidators;
+    registerValidator(name: string, factory: ValidatorFactory): void;
+    getValidator(config: ValidatorConfig): ValidatorFn;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ValidatorRegistryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ValidatorRegistryService>;
+}
+
+declare class FormGeneratorService {
+    private fb;
+    private validatorRegistry;
+    constructor(fb: FormBuilder, validatorRegistry: ValidatorRegistryService);
+    createFormGroup(config: FormConfig, initialValue?: Record<string, any>): FormGroup;
+    private mapValidators;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormGeneratorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FormGeneratorService>;
+}
+
+declare class FormRendererComponent implements OnInit, OnDestroy {
+    #private;
+    private formGenerator;
+    private validatorRegistry;
+    private destroyRef;
+    readonly config: i0.InputSignal<FormConfig>;
+    readonly initialValue: i0.InputSignal<Record<string, any> | undefined>;
+    readonly formSubmit: i0.OutputEmitterRef<any>;
+    readonly valueChanges: i0.OutputEmitterRef<any>;
+    readonly initialized: i0.OutputEmitterRef<void>;
+    private elementsMap;
+    protected formGroup: Signal<FormGroup>;
+    private valueChangesSub?;
+    constructor(formGenerator: FormGeneratorService, validatorRegistry: ValidatorRegistryService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    submit(): void;
+    get form(): FormGroup<any>;
+    get value(): any;
+    get isValid(): boolean;
+    get isInvalid(): boolean;
+    protected isFieldVisible(name: string): boolean;
+    protected getComponentConfig(name: string): ComponentConfig | undefined;
+    protected getControl(name: string): FormControl | null;
+    protected isGridNode(node: LayoutNode): node is GridNode;
+    protected onSubmit(): void;
+    private mapValidators;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormRendererComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormRendererComponent, "emr-form-renderer", ["emrFormRenderer"], { "config": { "alias": "config"; "required": true; "isSignal": true; }; "initialValue": { "alias": "initialValue"; "required": false; "isSignal": true; }; }, { "formSubmit": "formSubmit"; "valueChanges": "valueChanges"; "initialized": "initialized"; }, never, ["*"], true, never>;
+}
+
+export { ComponentRegistryService, FORM_RENDERER_FIELD_REGISTRY, FormRendererComponent, ValidatorRegistryService };
+export type { ComponentConfig, ComponentImporter, ComponentNode, ContentConfig, CrossValidatorFn, FormConfig, FormFieldConfig, GridNode, LayoutNode, ValidatorConfig };

package/gauge/index.d.ts

@@ -0,0 +1,21 @@
+import * as i0 from '@angular/core';
+import { OnInit } from '@angular/core';
+
+declare class GaugeComponent implements OnInit {
+    value: i0.InputSignalWithTransform<number, unknown>;
+    strokeWidth: i0.InputSignalWithTransform<number, unknown>;
+    radius: i0.InputSignalWithTransform<number, unknown>;
+    protected strokeDasharray: string;
+    protected initialOffset: number;
+    protected strokeDashoffset: number;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GaugeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GaugeComponent, "emr-gauge", ["emrGauge"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; "isSignal": true; }; "radius": { "alias": "radius"; "required": false; "isSignal": true; }; }, {}, never, ["emr-gauge-value"], true, never>;
+}
+
+declare class GaugeValueComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<GaugeValueComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GaugeValueComponent, "emr-gauge-value", ["emrGaugeValue"], {}, {}, never, ["*"], true, never>;
+}
+
+export { GaugeComponent, GaugeValueComponent };

package/icon/index.d.ts

@@ -0,0 +1,17 @@
+import * as _angular_core from '@angular/core';
+import { OnInit, OnChanges, SimpleChanges } from '@angular/core';
+import { SafeHtml } from '@angular/platform-browser';
+
+declare class IconComponent implements OnInit, OnChanges {
+    private _sanitizer;
+    protected _iconHtml: _angular_core.WritableSignal<SafeHtml | null>;
+    name: _angular_core.InputSignal<string>;
+    private loaded;
+    ngOnInit(): Promise<void>;
+    ngOnChanges(changes: SimpleChanges): Promise<void>;
+    private _loadIcon;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IconComponent, "emr-icon", ["emrIcon"], { "name": { "alias": "name"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { IconComponent };

package/image-resizer/index.d.ts

@@ -0,0 +1,35 @@
+import * as _angular_core from '@angular/core';
+import { ElementRef, AfterContentInit, Renderer2 } from '@angular/core';
+
+interface ImageResizedEvent {
+    width: number;
+    height: number;
+    naturalWidth: number;
+    naturalHeight: number;
+}
+
+declare class ImageResizerImageDirective {
+    readonly elementRef: ElementRef<HTMLImageElement>;
+    protected _onDragStart(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ImageResizerImageDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ImageResizerImageDirective, "[emrImageResizerImage]", ["emrImageResizerImage"], {}, {}, never, never, true, never>;
+}
+
+declare class ImageResizerComponent implements AfterContentInit {
+    protected _platformId: Object;
+    protected _elementRef: ElementRef<any>;
+    protected _renderer: Renderer2;
+    readonly imageRef: _angular_core.Signal<ImageResizerImageDirective>;
+    imageMaxWidth: _angular_core.InputSignalWithTransform<number | null, unknown>;
+    imageMinWidth: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly imageResized: _angular_core.OutputEmitterRef<ImageResizedEvent>;
+    protected _maxWidth: _angular_core.WritableSignal<number | null>;
+    constructor();
+    ngAfterContentInit(): void;
+    onDimensionsChanged(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ImageResizerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ImageResizerComponent, "emr-image-resizer", ["emrImageResizer"], { "imageMaxWidth": { "alias": "imageMaxWidth"; "required": false; "isSignal": true; }; "imageMinWidth": { "alias": "imageMinWidth"; "required": false; "isSignal": true; }; }, { "imageResized": "imageResized"; }, ["imageRef"], ["[emrImageResizerImage]"], true, never>;
+}
+
+export { ImageResizerComponent, ImageResizerImageDirective };
+export type { ImageResizedEvent };

package/image-viewer/index.d.ts

@@ -0,0 +1,63 @@
+import * as i0 from '@angular/core';
+import { EventEmitter, TemplateRef } from '@angular/core';
+
+declare class PictureRef {
+    readonly closed: EventEmitter<any>;
+    close(): void;
+}
+
+interface PictureOptions {
+    sourceUrl: string;
+    title?: string | undefined;
+    caption?: string | undefined;
+    description?: string | undefined;
+    titleTplRef?: TemplateRef<any> | undefined;
+    captionTplRef?: TemplateRef<any> | undefined;
+    descriptionTplRef?: TemplateRef<any> | undefined;
+}
+
+declare class ImageViewerDirective {
+    private _overlay;
+    private _injector;
+    private _destroyRef;
+    get api(): {
+        open: (options: PictureOptions) => PictureRef;
+    };
+    private _open;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImageViewerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ImageViewerDirective, "[emrImageViewer]", ["emrImageViewer"], {}, {}, never, never, true, never>;
+}
+
+declare class ImageViewerPictureDirective {
+    private _imageViewer;
+    private _titleTplRef;
+    private _captionTplRef;
+    private _descriptionTplRef;
+    sourceUrl: i0.InputSignal<string>;
+    caption: i0.InputSignal<string | undefined>;
+    title: i0.InputSignal<string | undefined>;
+    description: i0.InputSignal<string | undefined>;
+    protected onClick(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImageViewerPictureDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ImageViewerPictureDirective, "[emrImageViewerPicture]", ["emrImageViewerPicture"], { "sourceUrl": { "alias": "sourceUrl"; "required": true; "isSignal": true; }; "caption": { "alias": "caption"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; }, {}, ["_titleTplRef", "_captionTplRef", "_descriptionTplRef"], never, true, never>;
+}
+
+declare class ImageViewerPictureCaptionDirective {
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImageViewerPictureCaptionDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ImageViewerPictureCaptionDirective, "[emrImageViewerPictureCaption]", never, {}, {}, never, never, true, never>;
+}
+
+declare class ImageViewerPictureDescriptionDirective {
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImageViewerPictureDescriptionDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ImageViewerPictureDescriptionDirective, "[emrImageViewerPictureDescription]", never, {}, {}, never, never, true, never>;
+}
+
+declare class ImageViewerPictureTitleDirective {
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImageViewerPictureTitleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ImageViewerPictureTitleDirective, "[emrImageViewerPictureTitle]", never, {}, {}, never, never, true, never>;
+}
+
+export { ImageViewerDirective, ImageViewerPictureCaptionDirective, ImageViewerPictureDescriptionDirective, ImageViewerPictureDirective, ImageViewerPictureTitleDirective };

package/incidents/index.d.ts

@@ -0,0 +1,119 @@
+import * as i0 from '@angular/core';
+import * as _ngrx_signals from '@ngrx/signals';
+import * as _elementar_rt_components_incidents from '@elementar-rt/components/incidents';
+
+declare class IncidentsComponent {
+    isVisible: boolean;
+    toggleVisibility(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IncidentsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IncidentsComponent, "emr-incidents", ["emrIncidents"], {}, {}, never, ["emr-incidents-bar", "emr-incidents-list"], true, never>;
+}
+
+declare class IncidentsBarComponent {
+    private _parent;
+    _handleClick(_event?: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IncidentsBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IncidentsBarComponent, "emr-incidents-bar", ["emrIncidentsBar"], {}, {}, never, ["emr-incidents-title", "emr-incidents-description", "[emrIncidentsToggleIcon]"], true, never>;
+}
+
+declare class IncidentsListComponent {
+    private _parent;
+    fixed: i0.InputSignalWithTransform<boolean, unknown>;
+    _handleClick(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IncidentsListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IncidentsListComponent, "emr-incidents-list", ["emr-incidents-list"], { "fixed": { "alias": "fixed"; "required": false; "isSignal": true; }; }, {}, never, ["emr-incident"], true, never>;
+}
+
+declare class IncidentComponent {
+    private _incidentsStore;
+    incidentId: i0.InputSignal<string>;
+    close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IncidentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IncidentComponent, "emr-incident,[emr-incident]", ["emrIncident"], { "incidentId": { "alias": "incidentId"; "required": false; "isSignal": true; }; }, {}, never, ["[emrIncidentIcon]", "emr-incident-title", "emr-incident-details", "[emrIncidentButton]", "[emrIncidentClose]"], true, never>;
+}
+
+declare class IncidentTitleComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IncidentTitleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IncidentTitleComponent, "emr-incident-title", ["emrIncidentTitle"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class IncidentDetailsComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IncidentDetailsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IncidentDetailsComponent, "emr-incident-details", ["emrIncidentDetails"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class IncidentButtonDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IncidentButtonDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<IncidentButtonDirective, "[emrIncidentButton]", ["emrIncidentButton"], {}, {}, never, never, true, never>;
+}
+
+declare class IncidentsTitleComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IncidentsTitleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IncidentsTitleComponent, "emr-incidents-title", ["emrIncidentTitle"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class IncidentsDescriptionComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IncidentsDescriptionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IncidentsDescriptionComponent, "emr-incidents-description", ["emrIncidentsDescription"], {}, {}, never, ["*"], true, never>;
+}
+
+interface Incident {
+    id: any;
+    title: string;
+    details?: string;
+}
+
+declare class IncidentsContainerComponent {
+    protected _incidentsStore: {
+        incidents: i0.Signal<Incident[]>;
+        title: i0.Signal<string>;
+        description: i0.Signal<string>;
+        show: (state: _elementar_rt_components_incidents.IncidentsState) => void;
+        hide: () => void;
+    } & _ngrx_signals.StateSource<{
+        incidents: Incident[];
+        title: string;
+        description: string;
+    }>;
+    hasIncidents: i0.Signal<boolean>;
+    title: i0.Signal<string>;
+    description: i0.Signal<string>;
+    incidents: i0.Signal<Incident[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IncidentsContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IncidentsContainerComponent, "emr-incidents-container,emr-incidents-global", ["emrIncidentsGlobal"], {}, {}, never, never, true, never>;
+}
+
+declare class IncidentsToggleIconDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IncidentsToggleIconDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<IncidentsToggleIconDirective, "[emrIncidentsToggleIcon]", ["emrIncidentsToggleIcon"], {}, {}, never, never, true, never>;
+}
+
+declare class IncidentIconDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IncidentIconDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<IncidentIconDirective, "[emrIncidentIcon]", ["emrIncidentIcon"], {}, {}, never, never, true, never>;
+}
+
+declare class IncidentCloseDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IncidentCloseDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<IncidentCloseDirective, "[emrIncidentClose]", ["emrIncidentClose"], {}, {}, never, never, true, never>;
+}
+
+interface IncidentsState {
+    incidents: Incident[];
+    title: string;
+    description: string;
+}
+declare const IncidentsStore: i0.Type<{
+    incidents: i0.Signal<Incident[]>;
+    title: i0.Signal<string>;
+    description: i0.Signal<string>;
+    show: (state: IncidentsState) => void;
+    hide: () => void;
+} & _ngrx_signals.StateSource<{
+    incidents: Incident[];
+    title: string;
+    description: string;
+}>>;
+
+export { IncidentButtonDirective, IncidentCloseDirective, IncidentComponent, IncidentDetailsComponent, IncidentIconDirective, IncidentTitleComponent, IncidentsBarComponent, IncidentsComponent, IncidentsContainerComponent, IncidentsDescriptionComponent, IncidentsListComponent, IncidentsStore, IncidentsTitleComponent, IncidentsToggleIconDirective };
+export type { IncidentsState };

package/index.d.ts

@@ -0,0 +1,2 @@
+
+export { };

package/inline-text-edit/index.d.ts

@@ -0,0 +1,39 @@
+import * as _angular_core from '@angular/core';
+import { AfterViewInit, AfterContentChecked, OnDestroy } from '@angular/core';
+
+declare class InlineTextEditComponent implements AfterViewInit, AfterContentChecked, OnDestroy {
+    private platformId;
+    private document;
+    enabled: _angular_core.InputSignal<boolean>;
+    placeholder: _angular_core.InputSignal<string>;
+    delay: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly contentChanged: _angular_core.OutputEmitterRef<string>;
+    isEditing: _angular_core.WritableSignal<boolean>;
+    isFocused: _angular_core.WritableSignal<boolean>;
+    private previousValue;
+    private minHeightSet;
+    private elementRef;
+    private renderer;
+    private emitTimeoutId;
+    constructor();
+    ngAfterViewInit(): void;
+    get isContentEditable(): boolean;
+    ngAfterContentChecked(): void;
+    ngOnDestroy(): void;
+    private setInitialMinHeight;
+    onFocus(): void;
+    onBlur(): void;
+    onEnter(event: Event): void;
+    onEscape(): void;
+    onPaste(event: ClipboardEvent): void;
+    onInput(): void;
+    private finishEdit;
+    private cancelEdit;
+    private placeCaretAtEnd;
+    private emitWithDelay;
+    private clearPendingEmission;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InlineTextEditComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InlineTextEditComponent, "emr-inline-text-edit,[emr-inline-text-edit]", never, { "enabled": { "alias": "enabled"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "delay": { "alias": "delay"; "required": false; "isSignal": true; }; }, { "contentChanged": "contentChanged"; }, never, ["*"], true, never>;
+}
+
+export { InlineTextEditComponent };

package/input-mask/index.d.ts

@@ -0,0 +1,36 @@
+import * as i0 from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+
+declare class CreditCardNumberMaskDirective {
+    private readonly ngControl;
+    private readonly hostElement;
+    readonly placeholder: i0.InputSignal<string>;
+    onInput(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CreditCardNumberMaskDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CreditCardNumberMaskDirective, "[emrCreditCardNumberMask]", ["emrCreditCardNumberMask"], { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class CreditCardExpiryDateMaskDirective implements ControlValueAccessor {
+    private readonly elementRef;
+    readonly placeholder: i0.InputSignal<string>;
+    onChange: (_: any) => void;
+    onTouched: () => void;
+    writeValue(value: string | null): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    protected onInput(event: Event): void;
+    onBlur(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CreditCardExpiryDateMaskDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CreditCardExpiryDateMaskDirective, "[emrCreditCardExpiryDateMask]", ["emrCreditCardExpiryDateMask"], { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class CreditCardCvvMaskDirective {
+    private readonly ngControl;
+    private readonly hostElement;
+    readonly placeholder: i0.InputSignal<string>;
+    onInput(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CreditCardCvvMaskDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CreditCardCvvMaskDirective, "[emrCreditCardCvvMask]", ["emrCreditCardCvvMask"], { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { CreditCardCvvMaskDirective, CreditCardExpiryDateMaskDirective, CreditCardNumberMaskDirective };

package/input-validator/index.d.ts

@@ -0,0 +1,5 @@
+import { ValidatorFn } from '@angular/forms';
+
+declare function expiryDateValidator(): ValidatorFn;
+
+export { expiryDateValidator };

package/kanban-board/index.d.ts

@@ -0,0 +1,68 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef, OnInit } from '@angular/core';
+import { CdkDragDrop, CdkDragStart, CdkDragMove, CdkDragEnd } from '@angular/cdk/drag-drop';
+
+interface KanbanColumn<T extends KanbanItem> {
+    id: any;
+    name: string;
+    color: string;
+    items: T[];
+}
+interface KanbanItem {
+    name: string;
+    position: number;
+}
+interface KanbanItemSortedEvent {
+    previousIndex: number;
+    currentIndex: number;
+}
+interface KanbanItemTransferredEvent<T> {
+    previousContainerData: T[];
+    currentContainerData: T[];
+    previousIndex: number;
+    currentIndex: number;
+}
+
+declare class KanbanItemDefDirective {
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KanbanItemDefDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KanbanItemDefDirective, "[emrKanbanItemDef]", never, {}, {}, never, never, true, never>;
+}
+
+declare class KanbanBoardComponent<T extends KanbanColumn<K>, K extends KanbanItem> implements OnInit {
+    protected _itemTplDef: _angular_core.Signal<KanbanItemDefDirective>;
+    private _headerContainer;
+    private _scrollContainer;
+    private _renderer;
+    private _destroyRef;
+    columns: _angular_core.InputSignal<T[]>;
+    colors: _angular_core.InputSignal<string[]>;
+    protected _hasVerticalScroll: _angular_core.WritableSignal<boolean>;
+    readonly columnEdit: _angular_core.OutputEmitterRef<T>;
+    readonly columnDelete: _angular_core.OutputEmitterRef<{
+        column: T;
+        index: number;
+    }>;
+    readonly itemAdd: _angular_core.OutputEmitterRef<void>;
+    readonly itemClick: _angular_core.OutputEmitterRef<K>;
+    readonly itemDropped: _angular_core.OutputEmitterRef<CdkDragDrop<K[], K[], any>>;
+    readonly itemSorted: _angular_core.OutputEmitterRef<KanbanItemSortedEvent>;
+    readonly itemTransferred: _angular_core.OutputEmitterRef<KanbanItemTransferredEvent<K>>;
+    private _startContainerXOffset;
+    private _itemXOffset;
+    private _itemWidth;
+    protected isDraggingActive: boolean;
+    private _autoScrollStarted;
+    ngOnInit(): void;
+    onDropped(event: CdkDragDrop<K[]>): void;
+    onScroll(event: Event): void;
+    onDragStarted(event: CdkDragStart, element: HTMLElement): void;
+    onDragMoved(event: CdkDragMove<K>): void;
+    onDragEnded(event: CdkDragEnd): void;
+    protected itemMousedown(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KanbanBoardComponent<any, any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KanbanBoardComponent<any, any>, "emr-kanban-board", ["emrKanbanBoard"], { "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "colors": { "alias": "colors"; "required": false; "isSignal": true; }; }, { "columnEdit": "columnEdit"; "columnDelete": "columnDelete"; "itemAdd": "itemAdd"; "itemClick": "itemClick"; "itemDropped": "itemDropped"; "itemSorted": "itemSorted"; "itemTransferred": "itemTransferred"; }, ["_itemTplDef"], never, true, never>;
+}
+
+export { KanbanBoardComponent, KanbanItemDefDirective };
+export type { KanbanColumn, KanbanItem, KanbanItemSortedEvent, KanbanItemTransferredEvent };

package/layout/index.d.ts

@@ -0,0 +1,75 @@
+import * as i0 from '@angular/core';
+import { OnInit, InjectionToken, EventEmitter } from '@angular/core';
+import * as i1 from '@angular/cdk/overlay';
+import * as _ngrx_signals from '@ngrx/signals';
+
+declare class LayoutComponent {
+    layoutId: i0.InputSignal<string>;
+    windowMode: i0.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LayoutComponent, "emr-layout", ["emrLayout"], { "layoutId": { "alias": "layoutId"; "required": false; "isSignal": true; }; "windowMode": { "alias": "windowMode"; "required": false; "isSignal": true; }; }, {}, never, ["emr-layout-topbar", "emr-layout-header", "emr-layout-sidebar", "*", "emr-layout-aside", "emr-layout-footer"], true, never>;
+}
+
+declare class LayoutHeaderComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LayoutHeaderComponent, "emr-layout-header", ["emrLayoutHeader"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class LayoutBodyComponent implements OnInit {
+    private _router;
+    private _elementRef;
+    private _platformId;
+    autoscrollToTop: i0.InputSignalWithTransform<boolean, unknown>;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutBodyComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LayoutBodyComponent, "emr-layout-body", ["emrLayoutBody"], { "autoscrollToTop": { "alias": "autoscrollToTop"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.CdkScrollable; inputs: {}; outputs: {}; }]>;
+}
+
+declare class LayoutFooterComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutFooterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LayoutFooterComponent, "emr-layout-footer", ["emrLayoutFooter"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class LayoutTopbarComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutTopbarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LayoutTopbarComponent, "emr-layout-topbar", ["emrLayoutTopbar"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class LayoutSidebarComponent {
+    private _parent;
+    private _layoutSidebarStore;
+    protected _isShown: i0.Signal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutSidebarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LayoutSidebarComponent, "emr-layout-sidebar", ["emrLayoutSidebar"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class LayoutAsideComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutAsideComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LayoutAsideComponent, "emr-layout-aside", ["emrLayoutAside"], {}, {}, never, ["*"], true, never>;
+}
+
+declare const LAYOUT: InjectionToken<unknown>;
+interface LayoutSidebarVisibilityChange {
+    layoutId: string;
+    shown: boolean;
+}
+
+declare class LayoutApiService {
+    private _layoutSidebarStore;
+    readonly sidebarVisibility: EventEmitter<LayoutSidebarVisibilityChange>;
+    hideSidebar(layoutId: string): void;
+    showSidebar(layoutId: string): void;
+    toggleSidebar(layoutId: string): void;
+    isSidebarShown(layoutId: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LayoutApiService>;
+}
+
+declare const LayoutSidebarStore: i0.Type<{
+    showSidebarVisibility: (layoutId: string, isShown: boolean) => void;
+} & _ngrx_signals.StateSource<{
+    [x: string]: boolean;
+}>>;
+
+export { LAYOUT, LayoutApiService, LayoutAsideComponent, LayoutBodyComponent, LayoutComponent, LayoutFooterComponent, LayoutHeaderComponent, LayoutSidebarComponent, LayoutSidebarStore, LayoutTopbarComponent };
+export type { LayoutSidebarVisibilityChange };

package/logo/index.d.ts

@@ -0,0 +1,21 @@
+import * as i0 from '@angular/core';
+
+type LogoAppearance = 'text' | 'image';
+
+declare class LogoComponent {
+    appearance: i0.InputSignal<LogoAppearance>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LogoComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LogoComponent, "emr-logo,[emr-logo]", ["emrLogo"], { "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class TextLogoComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextLogoComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TextLogoComponent, "emr-text-logo", ["emrTextLogo"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class ImageLogoComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImageLogoComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ImageLogoComponent, "emr-image-logo", never, {}, {}, never, never, true, never>;
+}
+
+export { ImageLogoComponent, LogoComponent, TextLogoComponent };