@ngstarter-ui/components 1.0.21

package/types/ngstarter-ui-components-image-resizer.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, "[ngsImageResizerImage]", ["ngsImageResizerImage"], {}, {}, never, never, true, never>;
+}
+
+declare class ImageResizer 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<ImageResizer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ImageResizer, "ngs-image-resizer", ["ngsImageResizer"], { "imageMaxWidth": { "alias": "imageMaxWidth"; "required": false; "isSignal": true; }; "imageMinWidth": { "alias": "imageMinWidth"; "required": false; "isSignal": true; }; }, { "imageResized": "imageResized"; }, ["imageRef"], ["[ngsImageResizerImage]"], true, never>;
+}
+
+export { ImageResizer, ImageResizerImageDirective };
+export type { ImageResizedEvent };

package/types/ngstarter-ui-components-image-viewer.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, "[ngsImageViewer]", ["ngsImageViewer"], {}, {}, 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, "[ngsImageViewerPicture]", ["ngsImageViewerPicture"], { "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, "[ngsImageViewerPictureCaption]", never, {}, {}, never, never, true, never>;
+}
+
+declare class ImageViewerPictureDescriptionDirective {
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImageViewerPictureDescriptionDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ImageViewerPictureDescriptionDirective, "[ngsImageViewerPictureDescription]", never, {}, {}, never, never, true, never>;
+}
+
+declare class ImageViewerPictureTitleDirective {
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImageViewerPictureTitleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ImageViewerPictureTitleDirective, "[ngsImageViewerPictureTitle]", never, {}, {}, never, never, true, never>;
+}
+
+export { ImageViewerDirective, ImageViewerPictureCaptionDirective, ImageViewerPictureDescriptionDirective, ImageViewerPictureDirective, ImageViewerPictureTitleDirective };

package/types/ngstarter-ui-components-image-zoom-viewer.d.ts

@@ -0,0 +1,34 @@
+import * as _angular_core from '@angular/core';
+import { OnDestroy, ElementRef, TemplateRef } from '@angular/core';
+
+declare class ImageZoomViewer implements OnDestroy {
+    private overlay;
+    private viewContainerRef;
+    private destroyRef;
+    readonly contentImageRef: _angular_core.Signal<ElementRef<any>>;
+    readonly zoomedTemplate: _angular_core.Signal<TemplateRef<any>>;
+    readonly isZoomed: _angular_core.WritableSignal<boolean>;
+    readonly imageSrc: _angular_core.WritableSignal<string>;
+    readonly imageAlt: _angular_core.WritableSignal<string>;
+    readonly imageRect: _angular_core.WritableSignal<DOMRect | undefined>;
+    readonly zoomedTransform: _angular_core.WritableSignal<string>;
+    private overlayRef;
+    private resizeSubscription?;
+    constructor();
+    ngOnDestroy(): void;
+    toggleZoom(): void;
+    openZoom(): void;
+    closeZoom(): void;
+    private calculateZoom;
+    private getImageElement;
+    private cleanupListeners;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ImageZoomViewer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ImageZoomViewer, "ngs-image-zoom-viewer", ["ngsImageZoomViewer"], {}, {}, ["contentImageRef"], ["*"], true, never>;
+}
+
+declare class ImageZoomViewerImage {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ImageZoomViewerImage, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ImageZoomViewerImage, "[ngsImageZoomViewerImage]", never, {}, {}, never, never, true, never>;
+}
+
+export { ImageZoomViewer, ImageZoomViewerImage };

package/types/ngstarter-ui-components-incidents.d.ts

@@ -0,0 +1,119 @@
+import * as i0 from '@angular/core';
+import * as _ngrx_signals from '@ngrx/signals';
+import * as _ngstarter_ui_components_incidents from '@ngstarter-ui/components/incidents';
+
+declare class Incidents {
+    isVisible: boolean;
+    toggleVisibility(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Incidents, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Incidents, "ngs-incidents", ["ngsIncidents"], {}, {}, never, ["ngs-incidents-bar", "ngs-incidents-list"], true, never>;
+}
+
+declare class IncidentsBar {
+    private _parent;
+    _handleClick(_event?: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IncidentsBar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IncidentsBar, "ngs-incidents-bar", ["ngsIncidentsBar"], {}, {}, never, ["ngs-incidents-title", "ngs-incidents-description", "[ngsIncidentsToggleIcon]"], true, never>;
+}
+
+declare class IncidentsList {
+    private _parent;
+    fixed: i0.InputSignalWithTransform<boolean, unknown>;
+    _handleClick(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IncidentsList, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IncidentsList, "ngs-incidents-list", ["ngs-incidents-list"], { "fixed": { "alias": "fixed"; "required": false; "isSignal": true; }; }, {}, never, ["ngs-incident"], true, never>;
+}
+
+declare class Incident$1 {
+    private _incidentsStore;
+    incidentId: i0.InputSignal<string>;
+    close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Incident$1, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Incident$1, "ngs-incident,[ngs-incident]", ["ngsIncident"], { "incidentId": { "alias": "incidentId"; "required": false; "isSignal": true; }; }, {}, never, ["[ngsIncidentIcon]", "ngs-incident-title", "ngs-incident-details", "[ngsIncidentButton]", "[ngsIncidentClose]"], true, never>;
+}
+
+declare class IncidentTitle {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IncidentTitle, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IncidentTitle, "ngs-incident-title", ["ngsIncidentTitle"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class IncidentDetails {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IncidentDetails, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IncidentDetails, "ngs-incident-details", ["ngsIncidentDetails"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class IncidentButtonDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IncidentButtonDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<IncidentButtonDirective, "[ngsIncidentButton]", ["ngsIncidentButton"], {}, {}, never, never, true, never>;
+}
+
+declare class IncidentsTitle {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IncidentsTitle, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IncidentsTitle, "ngs-incidents-title", ["ngsIncidentTitle"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class IncidentsDescription {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IncidentsDescription, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IncidentsDescription, "ngs-incidents-description", ["ngsIncidentsDescription"], {}, {}, never, ["*"], true, never>;
+}
+
+interface Incident {
+    id: any;
+    title: string;
+    details?: string;
+}
+
+declare class IncidentsContainer {
+    protected _incidentsStore: {
+        incidents: i0.Signal<Incident[]>;
+        title: i0.Signal<string>;
+        description: i0.Signal<string>;
+        show: (state: _ngstarter_ui_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<IncidentsContainer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IncidentsContainer, "ngs-incidents-container,ngs-incidents-global", ["ngsIncidentsGlobal"], {}, {}, never, never, true, never>;
+}
+
+declare class IncidentsToggleIconDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IncidentsToggleIconDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<IncidentsToggleIconDirective, "[ngsIncidentsToggleIcon]", ["ngsIncidentsToggleIcon"], {}, {}, never, never, true, never>;
+}
+
+declare class IncidentIconDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IncidentIconDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<IncidentIconDirective, "[ngsIncidentIcon]", ["ngsIncidentIcon"], {}, {}, never, never, true, never>;
+}
+
+declare class IncidentCloseDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IncidentCloseDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<IncidentCloseDirective, "[ngsIncidentClose]", ["ngsIncidentClose"], {}, {}, 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 { Incident$1 as Incident, IncidentButtonDirective, IncidentCloseDirective, IncidentDetails, IncidentIconDirective, IncidentTitle, Incidents, IncidentsBar, IncidentsContainer, IncidentsDescription, IncidentsList, IncidentsStore, IncidentsTitle, IncidentsToggleIconDirective };
+export type { IncidentsState };

package/types/ngstarter-ui-components-inline-text-edit.d.ts

@@ -0,0 +1,39 @@
+import * as _angular_core from '@angular/core';
+import { AfterViewInit, AfterContentChecked, OnDestroy } from '@angular/core';
+
+declare class InlineTextEdit 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<InlineTextEdit, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InlineTextEdit, "ngs-inline-text-edit,[ngs-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 { InlineTextEdit };

package/types/ngstarter-ui-components-input-mask.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, "[ngsCreditCardNumberMask]", ["ngsCreditCardNumberMask"], { "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, "[ngsCreditCardExpiryDateMask]", ["ngsCreditCardExpiryDateMask"], { "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, "[ngsCreditCardCvvMask]", ["ngsCreditCardCvvMask"], { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { CreditCardCvvMaskDirective, CreditCardExpiryDateMaskDirective, CreditCardNumberMaskDirective };

package/types/ngstarter-ui-components-input-validator.d.ts

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

package/types/ngstarter-ui-components-input.d.ts

@@ -0,0 +1,53 @@
+import * as _angular_core from '@angular/core';
+import { OnInit, DoCheck, ElementRef } from '@angular/core';
+import { NgControl } from '@angular/forms';
+import { FormFieldControl } from '@ngstarter-ui/components/form-field';
+import { ErrorStateMatcher } from '@ngstarter-ui/components/core';
+
+declare class Input implements OnInit, DoCheck, FormFieldControl<string> {
+    protected elementRef: ElementRef<any>;
+    readonly ngControl: NgControl | null;
+    readonly stateChanges: _angular_core.WritableSignal<void>;
+    private _destroyRef;
+    private _defaultErrorStateMatcher;
+    private _parentForm;
+    private _parentFormGroup;
+    _id: _angular_core.InputSignal<string>;
+    get id(): string;
+    _placeholder: _angular_core.InputSignal<string>;
+    get placeholder(): string;
+    _required: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    get required(): boolean;
+    _disabled: _angular_core.InputSignalWithTransform<boolean, any>;
+    get disabled(): boolean;
+    readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    errorStateMatcher: _angular_core.InputSignal<ErrorStateMatcher | undefined>;
+    private _value;
+    get value(): string;
+    set value(value: string);
+    focusedValue: boolean;
+    private _focused;
+    get focused(): boolean;
+    errorStateValue: boolean;
+    private _errorState;
+    get errorState(): boolean;
+    isRequired: _angular_core.Signal<boolean>;
+    emptyValue: boolean;
+    private _empty;
+    get empty(): boolean;
+    shouldLabelFloatValue: boolean;
+    private _shouldLabelFloat;
+    get shouldLabelFloat(): boolean;
+    constructor();
+    ngOnInit(): void;
+    ngDoCheck(): void;
+    private updateErrorState;
+    onFocus(): void;
+    onBlur(): void;
+    onInput(event: Event): void;
+    focus(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Input, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<Input, "input[ngsInput], textarea[ngsInput]", ["ngsInput"], { "_id": { "alias": "id"; "required": false; "isSignal": true; }; "_placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "_required": { "alias": "required"; "required": false; "isSignal": true; }; "_disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "errorStateMatcher": { "alias": "errorStateMatcher"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { Input };

package/types/ngstarter-ui-components-kanban-board.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, "[ngsKanbanItemDef]", never, {}, {}, never, never, true, never>;
+}
+
+declare class KanbanBoard<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<KanbanBoard<any, any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KanbanBoard<any, any>, "ngs-kanban-board", ["ngsKanbanBoard"], { "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 { KanbanBoard, KanbanItemDefDirective };
+export type { KanbanColumn, KanbanItem, KanbanItemSortedEvent, KanbanItemTransferredEvent };

package/types/ngstarter-ui-components-kbd.d.ts

@@ -0,0 +1,13 @@
+import * as i0 from '@angular/core';
+
+declare class Kbd {
+    static ɵfac: i0.ɵɵFactoryDeclaration<Kbd, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Kbd, "ngs-kbd", ["ngsKbd"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class KbdGroup {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbdGroup, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbdGroup, "ngs-kbd-group", ["ngsKbdGroup"], {}, {}, never, ["ngs-kbd"], true, never>;
+}
+
+export { Kbd, KbdGroup };

package/types/ngstarter-ui-components-layout.d.ts

@@ -0,0 +1,83 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, OnInit, EventEmitter } from '@angular/core';
+import * as i1 from '@angular/cdk/scrolling';
+import { CdkScrollable } from '@angular/cdk/scrolling';
+import * as _ngrx_signals from '@ngrx/signals';
+
+declare class Layout {
+    layoutId: i0.InputSignal<string>;
+    root: i0.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Layout, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Layout, "ngs-layout", ["ngsLayout"], { "layoutId": { "alias": "layoutId"; "required": false; "isSignal": true; }; "root": { "alias": "root"; "required": false; "isSignal": true; }; }, {}, never, ["ngs-layout-topbar", "ngs-layout-header", "ngs-layout-sidebar", "*", "ngs-layout-aside", "ngs-layout-footer"], true, never>;
+}
+
+declare class LayoutHeader {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutHeader, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LayoutHeader, "ngs-layout-header", ["ngsLayoutHeader"], {}, {}, never, ["*"], true, never>;
+}
+
+declare const LAYOUT: InjectionToken<unknown>;
+interface LayoutSidebarVisibilityChange {
+    layoutId: string;
+    shown: boolean;
+}
+interface LayoutContentInterface {
+    scrollContainer(): HTMLElement;
+    scrollable?: CdkScrollable;
+}
+declare const LAYOUT_CONTENT: InjectionToken<LayoutContentInterface>;
+
+declare class LayoutContent implements OnInit, LayoutContentInterface {
+    private _router;
+    private _elementRef;
+    private _platformId;
+    readonly scrollable: CdkScrollable;
+    autoscrollToTop: i0.InputSignalWithTransform<boolean, unknown>;
+    scrollContainer(): HTMLElement;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutContent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LayoutContent, "ngs-layout-content", ["ngsLayoutContent"], { "autoscrollToTop": { "alias": "autoscrollToTop"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.CdkScrollable; inputs: {}; outputs: {}; }]>;
+}
+
+declare class LayoutFooter {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutFooter, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LayoutFooter, "ngs-layout-footer", ["ngsLayoutFooter"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class LayoutTopbar {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutTopbar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LayoutTopbar, "ngs-layout-topbar", ["ngsLayoutTopbar"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class LayoutSidebar {
+    private _parent;
+    private _layoutSidebarStore;
+    protected _isShown: i0.Signal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutSidebar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LayoutSidebar, "ngs-layout-sidebar", ["ngsLayoutSidebar"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class LayoutAside {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutAside, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LayoutAside, "ngs-layout-aside", ["ngsLayoutAside"], {}, {}, never, ["*"], true, never>;
+}
+
+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, LAYOUT_CONTENT, Layout, LayoutApiService, LayoutAside, LayoutContent, LayoutFooter, LayoutHeader, LayoutSidebar, LayoutSidebarStore, LayoutTopbar };
+export type { LayoutContentInterface, LayoutSidebarVisibilityChange };

package/types/ngstarter-ui-components-list.d.ts

@@ -0,0 +1,98 @@
+import * as i0 from '@angular/core';
+import { OnInit } from '@angular/core';
+import * as i1 from '@ngstarter-ui/components/core';
+import { SelectionModel } from '@angular/cdk/collections';
+
+declare class List {
+    disabled: i0.InputSignalWithTransform<boolean, unknown>;
+    disableRipple: i0.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<List, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<List, "ngs-list", ["ngsList"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "disableRipple": { "alias": "disableRipple"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ActionList extends List {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActionList, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ActionList, "ngs-action-list", ["ngsActionList"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class NavList extends List {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavList, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NavList, "ngs-nav-list", ["ngsNavList"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class ListItemAvatar {
+    private readonly _elementRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListItemAvatar, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ListItemAvatar, "[ngsListItemAvatar]", never, {}, {}, never, never, true, never>;
+}
+
+declare class ListItemIcon {
+    private readonly _elementRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListItemIcon, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ListItemIcon, "[ngsListItemIcon]", never, {}, {}, never, never, true, never>;
+}
+
+declare class ListItemTitle {
+    private readonly _elementRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListItemTitle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ListItemTitle, "[ngsListItemTitle]", never, {}, {}, never, never, true, never>;
+}
+
+declare class ListItemLine {
+    private readonly _elementRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListItemLine, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ListItemLine, "[ngsListItemLine], [ngsLine]", never, {}, {}, never, never, true, never>;
+}
+
+declare class ListItemMeta {
+    private readonly _elementRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListItemMeta, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ListItemMeta, "[ngsListItemMeta]", never, {}, {}, never, never, true, never>;
+}
+
+declare class ListItem {
+    private _list;
+    disabled: i0.InputSignalWithTransform<boolean, unknown>;
+    lines: i0.InputSignalWithTransform<number | null, any>;
+    readonly _avatars: i0.Signal<readonly ListItemAvatar[]>;
+    readonly _icons: i0.Signal<readonly ListItemIcon[]>;
+    readonly _titles: i0.Signal<readonly ListItemTitle[]>;
+    readonly _lines: i0.Signal<readonly ListItemLine[]>;
+    readonly _meta: i0.Signal<readonly ListItemMeta[]>;
+    get disableRipple(): boolean | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListItem, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ListItem, "ngs-list-item, a[ngs-list-item], button[ngs-list-item]", ["ngsListItem"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "lines": { "alias": "lines"; "required": false; "isSignal": true; }; }, {}, ["_avatars", "_icons", "_titles", "_lines", "_meta"], ["[ngsListItemAvatar],[ngsListItemIcon]", "[ngsListItemTitle]", "[ngsListItemLine],[ngsLine]", "*", "[ngsListItemMeta]"], true, [{ directive: typeof i1.Ripple; inputs: { "ngsRippleDisabled": "disableRipple"; }; outputs: {}; }]>;
+}
+
+declare class SelectionList extends List implements OnInit {
+    multiple: i0.InputSignalWithTransform<boolean, unknown>;
+    readonly selectionChange: i0.OutputEmitterRef<any>;
+    readonly options: i0.Signal<readonly any[]>;
+    selectedOptions: SelectionModel<ListOption>;
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectionList, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SelectionList, "ngs-selection-list", ["ngsSelectionList"], { "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; }, { "selectionChange": "selectionChange"; }, ["options"], ["*"], true, never>;
+}
+
+declare class ListOption extends ListItem {
+    protected _selectionList: SelectionList;
+    private _changeDetectorRef;
+    readonly _avatars: i0.Signal<readonly ListItemAvatar[]>;
+    readonly _icons: i0.Signal<readonly ListItemIcon[]>;
+    readonly _meta: i0.Signal<readonly ListItemMeta[]>;
+    selected: i0.ModelSignal<boolean>;
+    value: i0.InputSignal<any>;
+    readonly selectedChange: i0.OutputEmitterRef<boolean>;
+    _toggle(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListOption, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ListOption, "ngs-list-option", ["ngsListOption"], { "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "selected": "selectedChange"; "selectedChange": "selectedChange"; }, ["_avatars", "_icons", "_meta"], ["[ngsListItemAvatar],[ngsListItemIcon]", "[ngsListItemTitle]", "[ngsListItemLine],[ngsLine]", "*", "[ngsListItemMeta]"], true, never>;
+}
+
+declare class Subheader {
+    private readonly _elementRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Subheader, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<Subheader, "[ngsSubheader]", never, {}, {}, never, never, true, never>;
+}
+
+export { ActionList, List, ListItem, ListItemAvatar, ListItemIcon, ListItemLine, ListItemMeta, ListItemTitle, ListOption, NavList, SelectionList, Subheader };