@elementar-rt/components 0.6.55

package/README.md

@@ -0,0 +1,49 @@
+# Elementar UI
+
+[Overview](https://elementarui.r-tulika.me) | [Live Demo](https://demo.elementarui.r-tulika.me) | [Documentation](https://docs.elementarui.r-tulika.me)
+
+# Modern Angular UI Components & Admin Panel, based on [Angular Material 3](https://material.angular.io) components and [Tailwind](https://tailwindcss.com/) css framework
+
+## Key features
+
+- Based on the most popular Angular material components
+- All components are designed from scratch specifically for the elementar admin
+- It has a large number of components aimed at creating real projects
+- Free and Open Source for personal and commercial purposes
+
+## What's included:
+
+- Angular 20+ & Typescript
+- Tailwind 4+ & SCSS
+- High resolution
+- Flexibly configurable themes (3 themes included)
+- Light & dark color schemes in each theme
+- 50+ Angular Components
+
+## Install
+
+If you don't have a project yet, just create a new project (sass styles are mandatory):
+
+```bash
+npx @angular/cli@20 new elementar-project-name --style=scss 
+```
+
+Go to directory `elementar-project-name` (or your project folder name) and run the command:
+
+```bash
+ng add @elementar-rt/components
+```
+
+> **Note:** The npm package is currently being republished. If `ng add` fails, build the library locally:
+> ```bash
+> git clone https://github.com/randrost/elementar-ui.git
+> cd elementar-ui
+> npm install
+> npm run build:components:prod
+> ```
+> Then link the built library into your project from `dist/components/`.
+
+## Demo Layouts
+
+Demo layouts are coming soon. They will be available as separate repositories under this project.
+

package/action-required/index.d.ts

@@ -0,0 +1,13 @@
+import * as _angular_core from '@angular/core';
+
+declare class ActionRequiredComponent {
+    actionText: _angular_core.InputSignal<unknown>;
+    iconName: _angular_core.InputSignal<unknown>;
+    description: _angular_core.InputSignal<unknown>;
+    buttonText: _angular_core.InputSignal<unknown>;
+    readonly buttonClicked: _angular_core.OutputEmitterRef<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ActionRequiredComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ActionRequiredComponent, "emr-action-required", ["emrActionRequired"], { "actionText": { "alias": "actionText"; "required": false; "isSignal": true; }; "iconName": { "alias": "iconName"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": true; "isSignal": true; }; "buttonText": { "alias": "buttonText"; "required": true; "isSignal": true; }; }, { "buttonClicked": "buttonClicked"; }, never, never, true, never>;
+}
+
+export { ActionRequiredComponent };

package/alert/index.d.ts

@@ -0,0 +1,51 @@
+import * as i0 from '@angular/core';
+import { TemplateRef, InjectionToken } from '@angular/core';
+import * as i1 from '@angular/material/core';
+
+declare class AlertIconDirective {
+    readonly templateRef: TemplateRef<any> | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlertIconDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AlertIconDirective, "[emrAlertIcon]", ["emrAlertIcon"], {}, {}, never, never, true, never>;
+}
+
+declare class AlertComponent {
+    private _renderer;
+    private _elementRef;
+    readonly iconRef: i0.Signal<AlertIconDirective | undefined>;
+    autoClose: i0.InputSignalWithTransform<number | null, unknown>;
+    bordered: i0.InputSignalWithTransform<boolean, unknown>;
+    variant: i0.InputSignal<string>;
+    readonly closed: i0.OutputEmitterRef<void>;
+    private _autoCloseTimeout;
+    constructor();
+    get api(): {
+        close: () => void;
+    };
+    protected get iconRefTemplate(): TemplateRef<any>;
+    private _close;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlertComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AlertComponent, "emr-alert", ["emrAlert"], { "autoClose": { "alias": "autoClose"; "required": false; "isSignal": true; }; "bordered": { "alias": "bordered"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, { "closed": "closed"; }, ["iconRef"], ["[emrAlertIcon]", "emr-alert-title,[emrAlertTitle]", "*", "[emrAlertAction]"], true, never>;
+}
+
+declare class AlertTitleDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlertTitleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AlertTitleDirective, "emr-alert-title,[emrAlertTitle]", ["emrAlertTitle"], {}, {}, never, never, true, never>;
+}
+
+declare class AlertCloseDirective {
+    private _alert;
+    protected _handleClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlertCloseDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AlertCloseDirective, "[emrAlertClose]", ["emrAlertClose"], {}, {}, never, never, true, never>;
+}
+
+declare class AlertActionDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlertActionDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AlertActionDirective, "[emrAlertAction]", ["emrAlertAction"], {}, {}, never, never, true, [{ directive: typeof i1.MatRipple; inputs: {}; outputs: {}; }]>;
+}
+
+declare const ALERT: InjectionToken<unknown>;
+type AlertVariant = 'default' | 'secondary' | 'positive' | 'informative' | 'negative' | 'notice' | string;
+
+export { ALERT, AlertActionDirective, AlertCloseDirective, AlertComponent, AlertIconDirective, AlertTitleDirective };
+export type { AlertVariant };

package/announcement/index.d.ts

@@ -0,0 +1,45 @@
+import * as _angular_core from '@angular/core';
+import * as _ngrx_signals from '@ngrx/signals';
+
+declare class AnnouncementComponent {
+    private _elementRef;
+    private _renderer;
+    variant: _angular_core.InputSignal<string>;
+    iconName: _angular_core.InputSignal<string>;
+    closable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    constructor();
+    protected close(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AnnouncementComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AnnouncementComponent, "emr-announcement", ["emrAnnouncement"], { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "iconName": { "alias": "iconName"; "required": false; "isSignal": true; }; "closable": { "alias": "closable"; "required": false; "isSignal": true; }; }, { "closed": "closed"; }, never, ["*"], true, never>;
+}
+
+type AnnouncementVariant = 'neutral' | 'negative' | 'warning' | 'positive' | 'informative' | string;
+interface Announcement {
+    iconName?: string;
+    variant: AnnouncementVariant;
+    message: string;
+}
+
+declare class AnnouncementGlobalComponent {
+    private _announcementStore;
+    announcement: _angular_core.Signal<Announcement | null>;
+    readonly announcementClose: _angular_core.OutputEmitterRef<void>;
+    onClose(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AnnouncementGlobalComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AnnouncementGlobalComponent, "emr-announcement-global", ["emrAnnouncementGlobal"], {}, { "announcementClose": "announcementClose"; }, never, never, true, never>;
+}
+
+interface AnnouncementState {
+    announcement: Announcement | null;
+}
+declare const AnnouncementStore: _angular_core.Type<{
+    announcement: _angular_core.Signal<Announcement | null>;
+    show: (announcement: Announcement) => void;
+    hide: () => void;
+} & _ngrx_signals.StateSource<{
+    announcement: Announcement | null;
+}>>;
+
+export { AnnouncementComponent, AnnouncementGlobalComponent, AnnouncementStore };
+export type { Announcement, AnnouncementState, AnnouncementVariant };

package/avatar/index.d.ts

@@ -0,0 +1,67 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, OnInit, OnChanges, AfterViewInit, SimpleChanges } from '@angular/core';
+
+declare const AVATAR_ACCESSOR: InjectionToken<unknown>;
+type AvatarPresenceIndicator = 'online' | 'offline' | 'away' | null | string;
+
+declare class AvatarComponent implements OnInit, OnChanges, AfterViewInit {
+    private _elementRef;
+    image: _angular_core.InputSignal<string>;
+    clickable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    label: _angular_core.InputSignal<string>;
+    alt: _angular_core.InputSignal<string>;
+    automaticColor: _angular_core.InputSignal<unknown>;
+    presenceIndicator: _angular_core.InputSignal<AvatarPresenceIndicator>;
+    protected imageLoaded: boolean;
+    protected showLabel: boolean;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    onImageLoaded(): void;
+    private _setAutomaticColor;
+    private _newShade;
+    isValidHex(color: any): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvatarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvatarComponent, "emr-avatar,[emr-avatar]", ["emrAvatar"], { "image": { "alias": "image"; "required": false; "isSignal": true; }; "clickable": { "alias": "clickable"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "alt": { "alias": "alt"; "required": false; "isSignal": true; }; "automaticColor": { "alias": "automaticColor"; "required": false; "isSignal": true; }; "presenceIndicator": { "alias": "presenceIndicator"; "required": false; "isSignal": true; }; }, {}, never, ["mat-icon,emr-icon"], true, never>;
+}
+
+declare class AvatarGroupComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvatarGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvatarGroupComponent, "emr-avatar-group", ["emrAvatarGroup"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class AvatarTotalComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvatarTotalComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvatarTotalComponent, "emr-avatar-total,[emr-avatar-total]", ["emrAvatarTotal"], {}, {}, never, ["*"], true, never>;
+}
+
+interface Preset {
+    style: any;
+    options?: {
+        scale?: number;
+        backgroundColor?: string[];
+        fontWeight?: number;
+    };
+}
+declare class DicebearComponent implements OnInit {
+    image: _angular_core.InputSignal<string>;
+    clickable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    key: _angular_core.InputSignal<any>;
+    preset: _angular_core.InputSignal<string>;
+    alt: _angular_core.InputSignal<string | undefined>;
+    presenceIndicator: _angular_core.InputSignal<AvatarPresenceIndicator>;
+    protected imageLoaded: boolean;
+    protected svg: string;
+    ngOnInit(): void;
+    onImageLoaded(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DicebearComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DicebearComponent, "emr-dicebear,[emr-dicebear]", ["emrDicebear"], { "image": { "alias": "image"; "required": false; "isSignal": true; }; "clickable": { "alias": "clickable"; "required": false; "isSignal": true; }; "key": { "alias": "key"; "required": false; "isSignal": true; }; "preset": { "alias": "preset"; "required": false; "isSignal": true; }; "alt": { "alias": "alt"; "required": false; "isSignal": true; }; "presenceIndicator": { "alias": "presenceIndicator"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class AvatarMoreComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvatarMoreComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvatarMoreComponent, "emr-avatar-more,[emr-avatar-more]", ["emrAvatarMore"], {}, {}, never, ["*"], true, never>;
+}
+
+export { AVATAR_ACCESSOR, AvatarComponent, AvatarGroupComponent, AvatarMoreComponent, AvatarTotalComponent, DicebearComponent };
+export type { AvatarPresenceIndicator, Preset };

package/block-loader/index.d.ts

@@ -0,0 +1,21 @@
+import * as i0 from '@angular/core';
+import { OnInit, OnDestroy } from '@angular/core';
+
+declare class BlockLoaderContainerDirective implements OnInit, OnDestroy {
+    private elementRef;
+    private renderer;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BlockLoaderContainerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BlockLoaderContainerDirective, "[emrBlockLoaderContainer]", never, {}, {}, never, never, true, never>;
+}
+
+declare class BlockLoaderComponent {
+    readonly loading: i0.InputSignalWithTransform<boolean, unknown>;
+    readonly spinnerDiameter: i0.InputSignalWithTransform<number, unknown>;
+    readonly spinnerStrokeWidth: i0.InputSignalWithTransform<number, unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BlockLoaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BlockLoaderComponent, "emr-block-loader", ["emrBlockLoader"], { "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "spinnerDiameter": { "alias": "spinnerDiameter"; "required": false; "isSignal": true; }; "spinnerStrokeWidth": { "alias": "spinnerStrokeWidth"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { BlockLoaderComponent, BlockLoaderContainerDirective };

package/block-state/index.d.ts

@@ -0,0 +1,33 @@
+import * as i0 from '@angular/core';
+
+declare class BlockStateComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BlockStateComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BlockStateComponent, "emr-block-state", ["emrBlockState"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class BlockStateImageComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BlockStateImageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BlockStateImageComponent, "emr-block-state-image", ["emrBlockStateImage"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class BlockStateIconComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BlockStateIconComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BlockStateIconComponent, "emr-block-state-icon", ["emrBlockStateIcon"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class BlockStateTitleComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BlockStateTitleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BlockStateTitleComponent, "emr-block-state-title,[emr-block-state-title]", ["emrBlockStateTitle"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class BlockStateContentComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BlockStateContentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BlockStateContentComponent, "emr-block-state-content", ["emrBlockStateContent"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class BlockStateActionsComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BlockStateActionsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BlockStateActionsComponent, "emr-block-state-actions", ["emrBlockStateActions"], {}, {}, never, ["*"], true, never>;
+}
+
+export { BlockStateActionsComponent, BlockStateComponent, BlockStateContentComponent, BlockStateIconComponent, BlockStateImageComponent, BlockStateTitleComponent };

package/brand-colors/index.d.ts

@@ -0,0 +1,27 @@
+import * as _angular_core from '@angular/core';
+import { OnChanges, SimpleChanges } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { BooleanInput } from '@angular/cdk/coercion';
+
+declare class BrandColorsComponent implements ControlValueAccessor, OnChanges {
+    private _cdr;
+    protected _disabled: boolean;
+    protected _selectedColor: string;
+    colors: _angular_core.InputSignal<string[]>;
+    selectedColor: _angular_core.InputSignal<string | undefined>;
+    withGradient: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly colorChange: _angular_core.OutputEmitterRef<string>;
+    _onChange: any;
+    _onTouched: any;
+    ngOnChanges(changes: SimpleChanges): void;
+    selectColor(color: string): void;
+    writeValue(_selectedColor: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: BooleanInput): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BrandColorsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BrandColorsComponent, "emr-brand-colors", ["emrBrandColors"], { "colors": { "alias": "colors"; "required": false; "isSignal": true; }; "selectedColor": { "alias": "selectedColor"; "required": false; "isSignal": true; }; "withGradient": { "alias": "withGradient"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "colorChange": "colorChange"; }, never, never, true, never>;
+}
+
+export { BrandColorsComponent };

package/breadcrumbs/index.d.ts

@@ -0,0 +1,104 @@
+import * as i0 from '@angular/core';
+import { TemplateRef } from '@angular/core';
+import * as _ngrx_signals from '@ngrx/signals';
+
+declare class BreadcrumbsComponent<T> {
+    itemRef: i0.Signal<TemplateRef<any>>;
+    activeItemRef: i0.Signal<TemplateRef<any>>;
+    separatorRef: i0.Signal<TemplateRef<any>>;
+    dataSource: i0.InputSignal<T[]>;
+    lastItemAsLink: i0.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbsComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BreadcrumbsComponent<any>, "emr-breadcrumbs", ["emrBreadcrumbs"], { "dataSource": { "alias": "dataSource"; "required": false; "isSignal": true; }; "lastItemAsLink": { "alias": "lastItemAsLink"; "required": false; "isSignal": true; }; }, {}, ["itemRef", "activeItemRef", "separatorRef"], ["*"], true, never>;
+}
+
+declare class BreadcrumbItemComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BreadcrumbItemComponent, "emr-breadcrumb-item,[emr-breadcrumb-item]", ["emrBreadcrumbItem"], {}, {}, never, ["[emrBreadcrumbItemIcon]", "emr-breadcrumb-title", "*"], true, never>;
+}
+
+declare class BreadcrumbSeparatorComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbSeparatorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BreadcrumbSeparatorComponent, "emr-breadcrumb-separator", ["emrBreadcrumbSeparator"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class BreadcrumbTitleComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbTitleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BreadcrumbTitleComponent, "emr-breadcrumb-title", ["emrBreadcrumbTitle"], {}, {}, never, ["*"], true, never>;
+}
+
+interface Breadcrumb {
+    id: any;
+    name?: string;
+    title?: string;
+    type: 'link' | 'separator' | null | string;
+    icon?: string;
+    route?: string;
+    [propName: string]: any;
+}
+
+declare class BreadcrumbItemIconDefDirective {
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbItemIconDefDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BreadcrumbItemIconDefDirective, "[emrBreadcrumbItemIconDef]", never, {}, {}, never, never, true, never>;
+}
+
+declare class BreadcrumbItemNameDefDirective {
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbItemNameDefDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BreadcrumbItemNameDefDirective, "[emrBreadcrumbItemNameDef]", never, {}, {}, never, never, true, never>;
+}
+
+declare class BreadcrumbItemTitleDefDirective {
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbItemTitleDefDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BreadcrumbItemTitleDefDirective, "[emrBreadcrumbItemTitleDef]", never, {}, {}, never, never, true, never>;
+}
+
+declare class BreadcrumbsGlobalComponent {
+    private _breadcrumbsStore;
+    protected itemIconDef: i0.Signal<BreadcrumbItemIconDefDirective | undefined>;
+    protected itemNameDef: i0.Signal<BreadcrumbItemNameDefDirective | undefined>;
+    protected itemTitleDef: i0.Signal<BreadcrumbItemTitleDefDirective | undefined>;
+    breadcrumbs: i0.Signal<Breadcrumb[]>;
+    lastItemAsLink: i0.InputSignalWithTransform<boolean, unknown>;
+    separator: i0.InputSignal<string>;
+    get iconTemplateRef(): TemplateRef<any>;
+    get titleTemplateRef(): TemplateRef<any>;
+    get nameTemplateRef(): TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbsGlobalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BreadcrumbsGlobalComponent, "emr-breadcrumbs-global", ["emrBreadcrumbsGlobal"], { "lastItemAsLink": { "alias": "lastItemAsLink"; "required": false; "isSignal": true; }; "separator": { "alias": "separator"; "required": false; "isSignal": true; }; }, {}, ["itemIconDef", "itemNameDef", "itemTitleDef"], never, true, never>;
+}
+
+declare class BreadcrumbItemDefDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbItemDefDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BreadcrumbItemDefDirective, "[emrBreadcrumbItemDef]", never, {}, {}, never, never, true, never>;
+}
+
+declare class BreadcrumbSeparatorDefDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbSeparatorDefDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BreadcrumbSeparatorDefDirective, "[emrBreadcrumbSeparatorDef]", never, {}, {}, never, never, true, never>;
+}
+
+declare class BreadcrumbActiveItemDefDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbActiveItemDefDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BreadcrumbActiveItemDefDirective, "[emrBreadcrumbActiveItemDef]", never, {}, {}, never, never, true, never>;
+}
+
+declare class BreadcrumbItemIconDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbItemIconDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BreadcrumbItemIconDirective, "[emrBreadcrumbItemIcon]", ["emrBreadcrumbItemIcon"], {}, {}, never, never, true, never>;
+}
+
+interface BreadcrumbsState {
+    breadcrumbs: Breadcrumb[];
+}
+declare const BreadcrumbsStore: i0.Type<{
+    breadcrumbs: i0.Signal<Breadcrumb[]>;
+    setBreadcrumbs: (breadcrumbs: Breadcrumb[]) => void;
+} & _ngrx_signals.StateSource<{
+    breadcrumbs: Breadcrumb[];
+}>>;
+
+export { BreadcrumbActiveItemDefDirective, BreadcrumbItemComponent, BreadcrumbItemDefDirective, BreadcrumbItemIconDefDirective, BreadcrumbItemIconDirective, BreadcrumbItemNameDefDirective, BreadcrumbItemTitleDefDirective, BreadcrumbSeparatorComponent, BreadcrumbSeparatorDefDirective, BreadcrumbTitleComponent, BreadcrumbsComponent, BreadcrumbsGlobalComponent, BreadcrumbsStore };
+export type { BreadcrumbsState };

package/card-overlay/index.d.ts

@@ -0,0 +1,20 @@
+import * as i0 from '@angular/core';
+import { OnInit } from '@angular/core';
+
+declare class CardOverlayComponent {
+    withTranslate: i0.InputSignalWithTransform<boolean, unknown>;
+    withBlur: i0.InputSignalWithTransform<boolean, unknown>;
+    disabled: i0.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CardOverlayComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CardOverlayComponent, "emr-card-overlay", ["emrCardOverlay"], { "withTranslate": { "alias": "withTranslate"; "required": false; "isSignal": true; }; "withBlur": { "alias": "withBlur"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class CardOverlayContainerDirective implements OnInit {
+    private _elementRef;
+    private _renderer;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CardOverlayContainerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CardOverlayContainerDirective, "[emrCardOverlayContainer]", ["emrCardOverlayContainer"], {}, {}, never, never, true, never>;
+}
+
+export { CardOverlayComponent, CardOverlayContainerDirective };

package/carousel/index.d.ts

@@ -0,0 +1,75 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, OnInit } from '@angular/core';
+
+interface CarouselApiInterface {
+    previous: () => void;
+    next: () => void;
+    isPreviousDisabled: () => boolean;
+    isNextDisabled: () => boolean;
+    selectedIndex: () => number;
+}
+interface CarouselInterface {
+    api: CarouselApiInterface;
+}
+interface CarouselCardInterface {
+    element: HTMLElement;
+}
+declare const CAROUSEL: InjectionToken<unknown>;
+declare const CAROUSEL_CARD: InjectionToken<unknown>;
+
+declare class CarouselComponent {
+    private _content;
+    private _cards;
+    fade: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    snapToCenter: _angular_core.InputSignal<boolean>;
+    snapDebounceTime: _angular_core.InputSignal<number>;
+    snapDuration: _angular_core.InputSignal<number>;
+    resistanceFactor: _angular_core.InputSignal<number>;
+    velocityThreshold: _angular_core.InputSignal<number>;
+    visibilityDebounceTime: _angular_core.InputSignal<number>;
+    readonly indexChange: _angular_core.OutputEmitterRef<number>;
+    protected _index: _angular_core.WritableSignal<number>;
+    get api(): CarouselApiInterface;
+    protected onIndexChanged(index: number): void;
+    private _previous;
+    private _next;
+    private _scrollToCard;
+    private _visibleInParentViewport;
+    private get _isPreviousDisabled();
+    private get _isNextDisabled();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CarouselComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CarouselComponent, "emr-carousel", ["emrCarousel"], { "fade": { "alias": "fade"; "required": false; "isSignal": true; }; "snapToCenter": { "alias": "snapToCenter"; "required": false; "isSignal": true; }; "snapDebounceTime": { "alias": "snapDebounceTime"; "required": false; "isSignal": true; }; "snapDuration": { "alias": "snapDuration"; "required": false; "isSignal": true; }; "resistanceFactor": { "alias": "resistanceFactor"; "required": false; "isSignal": true; }; "velocityThreshold": { "alias": "velocityThreshold"; "required": false; "isSignal": true; }; "visibilityDebounceTime": { "alias": "visibilityDebounceTime"; "required": false; "isSignal": true; }; }, { "indexChange": "indexChange"; }, ["_cards"], ["emr-carousel-card,[emr-carousel-card]", "[emrCarouselControls]"], true, never>;
+}
+
+declare class CarouselCardComponent {
+    private _elementRef;
+    get element(): HTMLElement;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CarouselCardComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CarouselCardComponent, "emr-carousel-card,[emr-carousel-card]", ["emrCarouselCard"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class CarouselControlsDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CarouselControlsDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CarouselControlsDirective, "[emrCarouselControls]", never, {}, {}, never, never, true, never>;
+}
+
+declare class CarouselPreviousDirective implements OnInit {
+    protected _carousel: CarouselInterface | null;
+    carousel: _angular_core.InputSignal<CarouselInterface | null>;
+    ngOnInit(): void;
+    _handleClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CarouselPreviousDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CarouselPreviousDirective, "[emrCarouselPrevious]", ["emrCarouselPrevious"], { "carousel": { "alias": "carousel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class CarouselNextDirective implements OnInit {
+    protected _carousel: CarouselInterface | null;
+    carousel: _angular_core.InputSignal<CarouselInterface | null>;
+    ngOnInit(): void;
+    _handleClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CarouselNextDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CarouselNextDirective, "[emrCarouselNext]", ["emrCarouselNext"], { "carousel": { "alias": "carousel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { CAROUSEL, CAROUSEL_CARD, CarouselCardComponent, CarouselComponent, CarouselControlsDirective, CarouselNextDirective, CarouselPreviousDirective };
+export type { CarouselApiInterface, CarouselCardInterface, CarouselInterface };

package/code-highlighter/index.d.ts

@@ -0,0 +1,18 @@
+import * as _angular_core from '@angular/core';
+import { OnChanges, SimpleChanges } from '@angular/core';
+import { SafeHtml } from '@angular/platform-browser';
+
+declare class CodeHighlighter implements OnChanges {
+    private sanitizer;
+    code: _angular_core.InputSignal<string>;
+    language: _angular_core.InputSignal<string>;
+    theme: _angular_core.InputSignal<string>;
+    inline: _angular_core.InputSignal<boolean>;
+    readonly content: _angular_core.WritableSignal<SafeHtml | null>;
+    readonly isLoading: _angular_core.WritableSignal<boolean>;
+    ngOnChanges(changes: SimpleChanges): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CodeHighlighter, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CodeHighlighter, "emr-code-highlighter", ["emrCodeHighlighter"], { "code": { "alias": "code"; "required": true; "isSignal": true; }; "language": { "alias": "language"; "required": false; "isSignal": true; }; "theme": { "alias": "theme"; "required": false; "isSignal": true; }; "inline": { "alias": "inline"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { CodeHighlighter };

package/color-picker/index.d.ts

@@ -0,0 +1,92 @@
+import * as _angular_core from '@angular/core';
+import { OnInit, OnChanges, SimpleChanges, OnDestroy, TemplateRef } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { TinyColor } from '@ctrl/tinycolor';
+
+type ColorPickerPosition = 'below-start' | 'below-center' | 'below-end' | 'above-start' | 'above-center' | 'above-end' | 'before-start' | 'before-center' | 'before-end' | 'after-start' | 'after-center' | 'after-end' | string;
+type ColorPickerResultFormat = 'hex' | 'rgb' | 'hsl' | 'hsv';
+
+declare class ColorPickerComponent implements OnInit, OnChanges, ControlValueAccessor {
+    private cdr;
+    color: _angular_core.InputSignal<string>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    asDropdown: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    showOpacity: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    resultFormat: _angular_core.InputSignal<ColorPickerResultFormat>;
+    readonly colorChange: _angular_core.OutputEmitterRef<string>;
+    readonly rawColorChange: _angular_core.OutputEmitterRef<TinyColor>;
+    private tmpColor;
+    protected hexColor: string;
+    protected _color: _angular_core.WritableSignal<TinyColor>;
+    protected _colorFromHue: _angular_core.WritableSignal<TinyColor | null | undefined>;
+    protected _disabled: _angular_core.WritableSignal<boolean>;
+    protected alpha: _angular_core.WritableSignal<number>;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    onChange: any;
+    onTouched: any;
+    writeValue(color: string): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: BooleanInput): void;
+    protected copyToClipboard(event: MouseEvent, hexInput: HTMLInputElement): Promise<void>;
+    protected onSaturationColorChange(tinyColor: TinyColor): void;
+    protected _handleContextMenu(event: Event): void;
+    protected onAlphaChange(alpha: number): void;
+    protected onHueColorChange(color: TinyColor): void;
+    protected onHexColorChange(color: string): void;
+    protected onHexColorBlur(): void;
+    protected _setHexColor(tinyColor: TinyColor): void;
+    private _setColor;
+    private emitEvent;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ColorPickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ColorPickerComponent, "emr-color-picker", ["emrColorPicker"], { "color": { "alias": "color"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "asDropdown": { "alias": "asDropdown"; "required": false; "isSignal": true; }; "showOpacity": { "alias": "showOpacity"; "required": false; "isSignal": true; }; "resultFormat": { "alias": "resultFormat"; "required": false; "isSignal": true; }; }, { "colorChange": "colorChange"; "rawColorChange": "rawColorChange"; }, never, never, true, never>;
+}
+
+declare class ColorPickerThumbnailComponent {
+    private _elementRef;
+    color: _angular_core.InputSignal<string>;
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ColorPickerThumbnailComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ColorPickerThumbnailComponent, "emr-color-picker-thumbnail,[emr-color-picker-thumbnail]", ["emrColorPickerThumbnail"], { "color": { "alias": "color"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ColorPickerTriggerForDirective implements OnDestroy {
+    private _overlay;
+    private _elementRef;
+    private _directionality;
+    private _viewContainerRef;
+    private _injector;
+    private _destroyRef;
+    colorPickerTemplateRef: _angular_core.InputSignal<TemplateRef<any>>;
+    position: _angular_core.InputSignal<string>;
+    readonly opened: _angular_core.OutputEmitterRef<void>;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    private _portal;
+    private _overlayRef;
+    private _destroy$;
+    constructor();
+    ngOnDestroy(): void;
+    get api(): {
+        isOpen: () => boolean;
+        open: () => void;
+        close: () => void;
+    };
+    protected _handleClick(event: MouseEvent): void;
+    private _isOpen;
+    private _open;
+    private _close;
+    private _destroyOverlay;
+    private _subscribeToOutsideClicks;
+    private _getPopoverContentPortal;
+    private _getOverlayConfig;
+    private _getOverlayPositionStrategy;
+    private _getOverlayPositions;
+    private _setType;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ColorPickerTriggerForDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ColorPickerTriggerForDirective, "[emrColorPickerTriggerFor]", ["emrColorPickerTriggerFor"], { "colorPickerTemplateRef": { "alias": "emrColorPickerTriggerFor"; "required": true; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; }, { "opened": "opened"; "closed": "closed"; }, never, never, true, never>;
+}
+
+export { ColorPickerComponent, ColorPickerThumbnailComponent, ColorPickerTriggerForDirective };
+export type { ColorPickerPosition, ColorPickerResultFormat };