@ngstarter-ui/components 1.0.21

package/types/ngstarter-ui-components-text-editor.d.ts

@@ -0,0 +1,191 @@
+import * as i0 from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { Editor } from '@tiptap/core';
+import * as i1 from '@ngstarter-ui/components/upload';
+import { UploadFileSelectedEvent } from '@ngstarter-ui/components/upload';
+
+interface TextEditorInterface {
+    api: TextEditorAPI;
+}
+interface TextEditorAPI {
+    isCommandDisabled: (command: string, options?: any) => boolean | null;
+    isActive: (command: string, options?: any) => boolean | null;
+    runCommand: (command: string, options?: any) => void;
+    editor: () => Editor;
+}
+declare const TEXT_EDITOR: InjectionToken<unknown>;
+declare const TEXT_EDITOR_BUBBLE_MENU: InjectionToken<unknown>;
+
+declare class TextEditor {
+    private _document;
+    private _cdr;
+    private _injector;
+    private _content;
+    private _bubbleMenu;
+    private _imageBubbleMenu;
+    private _floatingMenu;
+    protected _value: string;
+    protected editor: Editor;
+    content: i0.InputSignal<string>;
+    extensions: i0.InputSignal<never[]>;
+    contentMaxHeight: i0.InputSignal<number | undefined>;
+    placeholder: i0.InputSignal<string>;
+    imageUploadFn: i0.InputSignal<((file: Blob) => Promise<string>) | undefined>;
+    readonly contentChange: i0.OutputEmitterRef<string>;
+    get api(): TextEditorAPI;
+    ngOnInit(): void;
+    isCommandDisabled(command: string, options?: any): boolean | null;
+    ngOnDestroy(): void;
+    private _runCommand;
+    private _init;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextEditor, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TextEditor, "ngs-text-editor", ["ngsTextEditor"], { "content": { "alias": "content"; "required": false; "isSignal": true; }; "extensions": { "alias": "extensions"; "required": false; "isSignal": true; }; "contentMaxHeight": { "alias": "contentMaxHeight"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "imageUploadFn": { "alias": "imageUploadFn"; "required": false; "isSignal": true; }; }, { "contentChange": "contentChange"; }, never, ["ngs-text-editor-toolbar", "ngs-text-editor-bubble-menu", "ngs-text-editor-floating-menu"], true, never>;
+}
+
+declare class TextEditorToolbar {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextEditorToolbar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TextEditorToolbar, "ngs-text-editor-toolbar", ["ngsTextEditorToolbar"], {}, {}, never, ["[ngsTextEditorCommand],ngs-text-editor-divider"], true, never>;
+}
+
+declare class TextEditorDivider {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextEditorDivider, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TextEditorDivider, "ngs-text-editor-divider", ["ngsTextEditorDivider"], {}, {}, never, never, true, never>;
+}
+
+declare class TextEditorBubbleMenu {
+    protected textEditor: TextEditorInterface;
+    getLinkUrl(): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextEditorBubbleMenu, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TextEditorBubbleMenu, "ngs-text-editor-bubble-menu", ["emitTextEditorBubbleMenu"], {}, {}, never, ["[ngsTextEditorCommandEditLink],[ngsCommentEditorCommandUnsetLink]", "[ngsTextEditorCommand],ngs-text-editor-divider"], true, never>;
+}
+
+declare class TextEditorFloatingMenu {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextEditorFloatingMenu, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TextEditorFloatingMenu, "ngs-text-editor-floating-menu", ["ngsTextEditorFloatingMenu"], {}, {}, never, ["[ngsTextEditorCommand],ngs-text-editor-divider"], true, never>;
+}
+
+declare class TextEditorCommandBlockquoteDirective {
+    protected textEditor: TextEditorInterface;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextEditorCommandBlockquoteDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TextEditorCommandBlockquoteDirective, "[ngsTextEditorCommandBlockquote]", ["ngsTextEditorCommandBlockquote"], {}, {}, never, never, true, never>;
+}
+
+declare class TextEditorCommandBoldDirective {
+    protected textEditor: TextEditorInterface;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextEditorCommandBoldDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TextEditorCommandBoldDirective, "[ngsTextEditorCommandBold]", ["ngsTextEditorCommandBold"], {}, {}, never, never, true, never>;
+}
+
+declare class TextEditorCommandBulletListDirective {
+    protected textEditor: TextEditorInterface;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextEditorCommandBulletListDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TextEditorCommandBulletListDirective, "[ngsTextEditorCommandBulletList]", ["ngsTextEditorCommandBulletList"], {}, {}, never, never, true, never>;
+}
+
+declare class TextEditorCommandCodeBlockDirective {
+    protected textEditor: TextEditorInterface;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextEditorCommandCodeBlockDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TextEditorCommandCodeBlockDirective, "[ngsTextEditorCommandCodeBlock]", ["ngsTextEditorCommandCodeBlock"], {}, {}, never, never, true, never>;
+}
+
+declare class TextEditorCommandCodeDirective {
+    protected textEditor: TextEditorInterface;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextEditorCommandCodeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TextEditorCommandCodeDirective, "[ngsTextEditorCommandCode]", ["ngsTextEditorCommandCode"], {}, {}, never, never, true, never>;
+}
+
+declare class TextEditorCommandEditLinkDirective {
+    private _destroyRef;
+    private _dialog;
+    protected textEditor: TextEditorInterface;
+    protected setLinkActive: boolean;
+    protected onClick(): void;
+    private _setLink;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextEditorCommandEditLinkDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TextEditorCommandEditLinkDirective, "[ngsTextEditorCommandEditLink]", ["ngsTextEditorCommandEditLink"], {}, {}, never, never, true, never>;
+}
+
+declare class TextEditorCommandImageDirective {
+    protected textEditor: TextEditorInterface;
+    protected onImageSelected(event: UploadFileSelectedEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextEditorCommandImageDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TextEditorCommandImageDirective, "[ngsTextEditorCommandImage]", ["ngsTextEditorCommandImage"], {}, {}, never, never, true, [{ directive: typeof i1.UploadTriggerDirective; inputs: {}; outputs: { "fileSelected": "fileSelected"; }; }]>;
+}
+
+declare class TextEditorCommandItalicDirective {
+    protected textEditor: TextEditorInterface;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextEditorCommandItalicDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TextEditorCommandItalicDirective, "[ngsTextEditorCommandItalic]", ["ngsTextEditorCommandItalic"], {}, {}, never, never, true, never>;
+}
+
+declare class TextEditorCommandDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextEditorCommandDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TextEditorCommandDirective, "[ngsTextEditorCommand]", ["ngsTextEditorCommand"], {}, {}, never, never, true, never>;
+}
+
+declare class TextEditorCommandYoutubeDirective {
+    protected textEditor: TextEditorInterface;
+    private _dialog;
+    private _destroyRef;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextEditorCommandYoutubeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TextEditorCommandYoutubeDirective, "[ngsTextEditorCommandYoutube]", ["ngsTextEditorCommandYoutube"], {}, {}, never, never, true, never>;
+}
+
+declare class TextEditorCommandUnsetLinkDirective {
+    protected textEditor: TextEditorInterface;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextEditorCommandUnsetLinkDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TextEditorCommandUnsetLinkDirective, "[ngsTextEditorCommandUnsetLink]", ["ngsTextEditorCommandUnsetLink"], {}, {}, never, never, true, never>;
+}
+
+declare class TextEditorCommandStrikeDirective {
+    protected textEditor: TextEditorInterface;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextEditorCommandStrikeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TextEditorCommandStrikeDirective, "[ngsTextEditorCommandStrike]", ["ngsTextEditorCommandStrike"], {}, {}, never, never, true, never>;
+}
+
+declare class TextEditorCommandOrderedListDirective {
+    protected textEditor: TextEditorInterface;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextEditorCommandOrderedListDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TextEditorCommandOrderedListDirective, "[ngsTextEditorCommandOrderedList]", ["ngsTextEditorCommandOrderedList"], {}, {}, never, never, true, never>;
+}
+
+declare class TextEditorCommandLinkDirective {
+    private _destroyRef;
+    private _dialog;
+    protected textEditor: TextEditorInterface;
+    protected setLinkActive: boolean;
+    protected onClick(): void;
+    private _setLink;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextEditorCommandLinkDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TextEditorCommandLinkDirective, "[ngsTextEditorCommandLink]", ["ngsTextEditorCommandLink"], {}, {}, never, never, true, never>;
+}
+
+declare class TextEditorCommandHeadingDirective {
+    protected textEditor: TextEditorInterface;
+    level: i0.InputSignalWithTransform<number, unknown>;
+    protected get isActive(): boolean;
+    protected get isDisabled(): boolean;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextEditorCommandHeadingDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TextEditorCommandHeadingDirective, "[ngsTextEditorCommandHeading]", ["ngsTextEditorCommandHeading"], { "level": { "alias": "level"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class TextEditorCommandHorizontalRuleDirective {
+    protected textEditor: TextEditorInterface;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextEditorCommandHorizontalRuleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TextEditorCommandHorizontalRuleDirective, "[ngsTextEditorCommandHorizontalRule]", never, {}, {}, never, never, true, never>;
+}
+
+export { TEXT_EDITOR, TEXT_EDITOR_BUBBLE_MENU, TextEditor, TextEditorBubbleMenu, TextEditorCommandBlockquoteDirective, TextEditorCommandBoldDirective, TextEditorCommandBulletListDirective, TextEditorCommandCodeBlockDirective, TextEditorCommandCodeDirective, TextEditorCommandDirective, TextEditorCommandEditLinkDirective, TextEditorCommandHeadingDirective, TextEditorCommandHorizontalRuleDirective, TextEditorCommandImageDirective, TextEditorCommandItalicDirective, TextEditorCommandLinkDirective, TextEditorCommandOrderedListDirective, TextEditorCommandStrikeDirective, TextEditorCommandUnsetLinkDirective, TextEditorCommandYoutubeDirective, TextEditorDivider, TextEditorFloatingMenu, TextEditorToolbar };
+export type { TextEditorAPI, TextEditorInterface };

package/types/ngstarter-ui-components-thumbnail-maker.d.ts

@@ -0,0 +1,35 @@
+import * as _angular_core from '@angular/core';
+
+interface ThumbnailMakerApi {
+    getDataUrl: () => string;
+    toBlob: (callback: BlobCallback) => void;
+    getCanvas: () => HTMLCanvasElement;
+    increase: () => void;
+    decrease: () => void;
+}
+
+declare class ThumbnailMaker {
+    private _content;
+    private _dragImage;
+    private _thumbnailSize;
+    src: _angular_core.InputSignal<string>;
+    helperText: _angular_core.InputSignal<string>;
+    get api(): ThumbnailMakerApi;
+    protected scale: number;
+    protected min: number;
+    protected max: number;
+    protected loading: boolean;
+    protected alreadyDragged: boolean;
+    protected get isEqualsToMinScale(): boolean;
+    protected get isEqualsToMaxScale(): boolean;
+    protected onLoad(event: Event): void;
+    protected onDragStart(event: Event): void;
+    protected onScaleChange($event: number): void;
+    protected increase(): void;
+    protected decrease(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThumbnailMaker, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThumbnailMaker, "ngs-thumbnail-maker", ["ngsThumbnailMaker"], { "src": { "alias": "src"; "required": true; "isSignal": true; }; "helperText": { "alias": "helperText"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { ThumbnailMaker };
+export type { ThumbnailMakerApi };

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

@@ -0,0 +1,109 @@
+import * as _angular_core from '@angular/core';
+import { OnDestroy, AfterViewInit, InjectionToken } from '@angular/core';
+import * as rxjs from 'rxjs';
+
+declare class Tiles {
+    private reorder;
+    readonly el: HTMLElement;
+    readonly element: _angular_core.WritableSignal<HTMLElement | null>;
+    readonly order: _angular_core.WritableSignal<Map<Tile, number>>;
+    readonly tiles: _angular_core.Signal<readonly Tile[]>;
+    readonly items: _angular_core.InputSignal<any[]>;
+    readonly gap: _angular_core.InputSignal<string | number>;
+    readonly columns: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly orderChange: _angular_core.OutputEmitterRef<Map<number, number>>;
+    readonly orderChanged: _angular_core.OutputEmitterRef<any[]>;
+    readonly layoutChanged: _angular_core.OutputEmitterRef<any[]>;
+    private rearrangeTimer;
+    private lastSourceVisualIndex;
+    private lastTargetVisualIndex;
+    private lastSwapTime;
+    private lastSwapX;
+    private lastSwapY;
+    private initialItems;
+    private isInitialized;
+    private isDragging;
+    constructor();
+    private calculateLayout;
+    onDragEnd(tile: Tile): void;
+    onDragStart(): void;
+    rearrange(element: HTMLElement, event: PointerEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Tiles, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Tiles, "ngs-tiles", ["ngsTiles"], { "items": { "alias": "items"; "required": false; "isSignal": true; }; "gap": { "alias": "gap"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; }, { "orderChange": "orderChange"; "orderChanged": "orderChanged"; "layoutChanged": "layoutChanged"; }, ["tiles"], ["*"], true, never>;
+}
+
+declare class Tile implements OnDestroy, AfterViewInit {
+    readonly element: HTMLElement;
+    private readonly wrapper;
+    private readonly service;
+    private readonly breakpointObserver;
+    private readonly breakpointState;
+    protected readonly tiles: Tiles;
+    protected readonly dragged: _angular_core.WritableSignal<boolean>;
+    protected readonly initialized: _angular_core.WritableSignal<boolean>;
+    protected readonly heightPx: _angular_core.WritableSignal<string | null>;
+    readonly width: _angular_core.InputSignal<number>;
+    readonly widthSm: _angular_core.InputSignal<number | undefined>;
+    readonly widthMd: _angular_core.InputSignal<number | undefined>;
+    readonly widthLg: _angular_core.InputSignal<number | undefined>;
+    readonly widthXl: _angular_core.InputSignal<number | undefined>;
+    readonly height: _angular_core.InputSignal<number>;
+    readonly heightSm: _angular_core.InputSignal<number | undefined>;
+    readonly heightMd: _angular_core.InputSignal<number | undefined>;
+    readonly heightLg: _angular_core.InputSignal<number | undefined>;
+    readonly heightXl: _angular_core.InputSignal<number | undefined>;
+    readonly gridColumn: _angular_core.Signal<string>;
+    readonly gridRow: _angular_core.Signal<string>;
+    constructor();
+    onPointerMove(event: PointerEvent): void;
+    onDrag(offset: readonly [number, number], end?: boolean): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Tile, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Tile, "ngs-tile", ["ngsTile"], { "width": { "alias": "width"; "required": true; "isSignal": true; }; "widthSm": { "alias": "width.sm"; "required": false; "isSignal": true; }; "widthMd": { "alias": "width.md"; "required": false; "isSignal": true; }; "widthLg": { "alias": "width.lg"; "required": false; "isSignal": true; }; "widthXl": { "alias": "width.xl"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": true; "isSignal": true; }; "heightSm": { "alias": "height.sm"; "required": false; "isSignal": true; }; "heightMd": { "alias": "height.md"; "required": false; "isSignal": true; }; "heightLg": { "alias": "height.lg"; "required": false; "isSignal": true; }; "heightXl": { "alias": "height.xl"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class TileService implements OnDestroy {
+    private readonly isBrowser;
+    private readonly el;
+    private readonly tiles;
+    private readonly sub;
+    private readonly offset$;
+    private readonly resize$;
+    private readonly mutations$;
+    private lastRect;
+    private readonly position$;
+    init(element?: HTMLElement): void;
+    private animate;
+    setOffset(offset: readonly [number, number]): void;
+    ngOnDestroy(): void;
+    private getRect;
+    private setRect;
+    private setPosition;
+    private cleanup;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TileService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TileService>;
+}
+
+declare class TileHandleDirective {
+    private readonly doc;
+    private readonly tile;
+    private x;
+    private y;
+    private startX;
+    private startY;
+    private isActuallyDragging;
+    protected readonly pointerSub: rxjs.Subscription;
+    protected onPointer(x?: number, y?: number, end?: boolean): void;
+    protected onStart(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TileHandleDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TileHandleDirective, "[ngsTileHandle]", never, {}, {}, never, never, true, never>;
+}
+
+type ReorderFunction = (order: Map<any, number>, currentVisualIndex: number, newVisualIndex: number) => Map<any, number>;
+declare const tilesSwap: ReorderFunction;
+declare const tilesShift: ReorderFunction;
+declare const TILES_REORDER: InjectionToken<ReorderFunction>;
+
+export { TILES_REORDER, Tile, TileHandleDirective, TileService, Tiles, tilesShift, tilesSwap };
+export type { ReorderFunction };

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

@@ -0,0 +1,57 @@
+import * as i0 from '@angular/core';
+import { TemplateRef } from '@angular/core';
+
+declare class Timeline {
+    static ɵfac: i0.ɵɵFactoryDeclaration<Timeline, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Timeline, "ngs-timeline", ["ngsTimeline"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class TimelineHeader {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimelineHeader, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TimelineHeader, "ngs-timeline-header", ["ngsTimelineHeader"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class TimelineItemIndicatorDirective {
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimelineItemIndicatorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TimelineItemIndicatorDirective, "[ngsTimelineItemIndicator]", ["ngsTimelineItemIndicator"], {}, {}, never, never, true, never>;
+}
+
+declare class TimelineItem {
+    readonly indicatorRef: i0.Signal<TimelineItemIndicatorDirective | undefined>;
+    get indicatorTemplateRef(): TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimelineItem, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TimelineItem, "ngs-timeline-item", ["ngsTimelineItem"], {}, {}, ["indicatorRef"], ["ngs-timeline-timestamp", "ngs-timeline-title", "ngs-timeline-subtitle", "ngs-timeline-description", "ngs-timeline-attributes", "ngs-timeline-content"], true, never>;
+}
+
+declare class TimelineAttributes {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimelineAttributes, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TimelineAttributes, "ngs-timeline-attributes", ["ngsTimelineAttributes"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class TimelineDescription {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimelineDescription, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TimelineDescription, "ngs-timeline-description", ["ngsTimelineDescription"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class TimelineTimestamp {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimelineTimestamp, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TimelineTimestamp, "ngs-timeline-timestamp", ["ngsTimelineTimestamp"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class TimelineTitle {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimelineTitle, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TimelineTitle, "ngs-timeline-title", ["ngsTimelineTitle"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class TimelineSubtitle {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimelineSubtitle, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TimelineSubtitle, "ngs-timeline-subtitle", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class TimelineContent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimelineContent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TimelineContent, "ngs-timeline-content", never, {}, {}, never, ["*"], true, never>;
+}
+
+export { Timeline, TimelineAttributes, TimelineContent, TimelineDescription, TimelineHeader, TimelineItem, TimelineItemIndicatorDirective, TimelineSubtitle, TimelineTimestamp, TimelineTitle };

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

@@ -0,0 +1,115 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef, ElementRef, EventEmitter, OnDestroy, Signal, InjectionToken } from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { ControlValueAccessor, Validator, AbstractControl, ValidationErrors } from '@angular/forms';
+import { Subject } from 'rxjs';
+
+declare class Timepicker {
+    private _overlay;
+    private _viewContainerRef;
+    private _localeId;
+    private _config;
+    readonly _template: _angular_core.Signal<TemplateRef<any>>;
+    readonly _panel: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
+    readonly opened: EventEmitter<void>;
+    readonly closed: EventEmitter<void>;
+    private _overlayRef;
+    private _input;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    interval: _angular_core.InputSignalWithTransform<number, string | number>;
+    protected _timeOptions: _angular_core.Signal<{
+        label: string;
+        value: string;
+    }[]>;
+    private _toTimeString;
+    constructor();
+    _registerInput(input: any): void;
+    open(): void;
+    close(): void;
+    _isSelected(value: string): boolean;
+    private _scrollToSelected;
+    _selectValue(value: string): void;
+    isOpen(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Timepicker, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Timepicker, "ngs-timepicker", ["ngsTimepicker"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "interval": { "alias": "interval"; "required": false; "isSignal": true; }; }, { "opened": "opened"; "closed": "closed"; }, never, never, true, never>;
+}
+
+declare class TimepickerToggleIcon {
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TimepickerToggleIcon, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TimepickerToggleIcon, "[ngsTimepickerToggleIcon]", never, {}, {}, never, never, true, never>;
+}
+
+declare class TimepickerToggle implements OnDestroy {
+    private _stateChanges;
+    customIcons: _angular_core.Signal<readonly TimepickerToggleIcon[]>;
+    timepicker: _angular_core.InputSignal<Timepicker | null>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    ngOnDestroy(): void;
+    _open(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TimepickerToggle, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TimepickerToggle, "ngs-timepicker-toggle", ["ngsTimepickerToggle"], { "timepicker": { "alias": "for"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, ["customIcons"], ["[ngsTimepickerToggleIcon]"], true, never>;
+}
+
+declare class TimepickerInput<D = any> implements ControlValueAccessor, OnDestroy, Validator {
+    private _elementRef;
+    private _formField;
+    private _localeId;
+    private _disabledByCva;
+    protected _disabledInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: Signal<boolean>;
+    readonly max: _angular_core.InputSignalWithTransform<D | null, unknown>;
+    readonly min: _angular_core.InputSignalWithTransform<D | null, unknown>;
+    readonly openOnClick: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly ngsTimepicker: _angular_core.InputSignal<Timepicker>;
+    private _timepicker;
+    private _onChange;
+    private _onTouched;
+    private _validatorOnChange;
+    private _modelValue;
+    private _destroyed;
+    private _timepickerDestroyed;
+    private _isTimepickerOpen;
+    private _lastExternalDate;
+    constructor();
+    ngOnDestroy(): void;
+    private _registerTimepicker;
+    writeValue(value: any): void;
+    registerOnChange(fn: (value: any) => void): void;
+    registerOnTouched(fn: () => void): void;
+    registerOnValidatorChange(fn: () => void): void;
+    validate(control: AbstractControl): ValidationErrors | null;
+    private _doValidate;
+    private _updateNativeValidity;
+    setDisabledState(isDisabled: boolean): void;
+    _onInput(value: string): void;
+    _onBlur(): void;
+    private _toTimeString;
+    _onFocus(): void;
+    _onClick(): void;
+    _setValue(value: string): void;
+    private _mergeTimeIntoDate;
+    private _formatValue;
+    _parseValue(value: any): string;
+    get value(): string;
+    getConnectedOverlayOrigin(): ElementRef;
+    getOverlayWidth(): string | number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TimepickerInput<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TimepickerInput<any>, "input[ngsTimepicker]", never, { "_disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "openOnClick": { "alias": "openOnClick"; "required": false; "isSignal": true; }; "ngsTimepicker": { "alias": "ngsTimepicker"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class TimepickerIntl {
+    readonly changes: Subject<void>;
+    openTimepickerLabel: string;
+    closeTimepickerLabel: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TimepickerIntl, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TimepickerIntl>;
+}
+
+interface TimepickerConfig {
+    interval?: number | string;
+}
+declare const TIMEPICKER_CONFIG: InjectionToken<TimepickerConfig>;
+
+export { TIMEPICKER_CONFIG, Timepicker, TimepickerInput, TimepickerIntl, TimepickerToggle, TimepickerToggleIcon };
+export type { TimepickerConfig };

package/types/ngstarter-ui-components-timezone-select.d.ts

@@ -0,0 +1,75 @@
+import * as _angular_core from '@angular/core';
+import { OnInit, Renderer2 } from '@angular/core';
+import { ControlValueAccessor, NgControl } from '@angular/forms';
+import { FormFieldControl } from '@ngstarter-ui/components/form-field';
+import { Subject } from 'rxjs';
+
+interface LocalizedTimezone {
+    id: string;
+    name: string;
+    shortName?: string;
+    offsetName?: string;
+}
+interface TimezoneGroup {
+    name: string;
+    timezones: LocalizedTimezone[];
+}
+
+declare class TimezoneSelect implements OnInit, FormFieldControl<any>, ControlValueAccessor {
+    protected localeId: string;
+    protected renderer: Renderer2;
+    private readonly _focusMonitor;
+    private readonly _elementRef;
+    private readonly _formField;
+    ngControl: NgControl | null;
+    private searchInput;
+    private selectRef;
+    protected timezoneGroups: _angular_core.WritableSignal<TimezoneGroup[]>;
+    readonly touched: _angular_core.WritableSignal<boolean>;
+    readonly stateChanges: Subject<void>;
+    readonly controlType = "ngs-timezone-select";
+    readonly id: string;
+    readonly _userAriaDescribedBy: _angular_core.InputSignal<string>;
+    readonly locale: _angular_core.InputSignal<string>;
+    readonly _placeholder: _angular_core.InputSignal<string>;
+    readonly _required: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly _disabledByInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly _value: _angular_core.ModelSignal<string | null>;
+    protected searchTerm: _angular_core.ModelSignal<string>;
+    private readonly _focused;
+    private readonly _disabledByCva;
+    private readonly _disabled;
+    readonly opened: _angular_core.OutputEmitterRef<void>;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    onChange: (_: any) => void;
+    onTouched: () => void;
+    get focused(): boolean;
+    get empty(): boolean;
+    get shouldLabelFloat(): boolean;
+    get userAriaDescribedBy(): string;
+    get placeholder(): string;
+    get required(): boolean;
+    get disabled(): boolean;
+    get value(): string | null;
+    get errorState(): boolean;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onFocusIn(): void;
+    onFocusOut(event: any): void;
+    onContainerClick(event: MouseEvent): void;
+    setDescribedByIds(ids: string[]): void;
+    writeValue(timezone: string | null): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    protected onSelectOpened(): void;
+    clearSearch(event: MouseEvent): void;
+    protected onSelectClosed(): void;
+    private _updateValue;
+    focus(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TimezoneSelect, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TimezoneSelect, "ngs-timezone-select", ["ngsTimezoneSelect"], { "_userAriaDescribedBy": { "alias": "aria-describedby"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "_placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "_required": { "alias": "required"; "required": false; "isSignal": true; }; "_disabledByInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "_value": { "alias": "value"; "required": false; "isSignal": true; }; "searchTerm": { "alias": "searchTerm"; "required": false; "isSignal": true; }; }, { "_value": "valueChange"; "searchTerm": "searchTermChange"; "opened": "opened"; "closed": "closed"; }, never, never, true, never>;
+}
+
+export { TimezoneSelect };

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

@@ -0,0 +1,74 @@
+import * as i0 from '@angular/core';
+import { ElementRef, ModelSignal, TemplateRef, AfterViewInit, OnDestroy } from '@angular/core';
+import { DialogRef } from '@ngstarter-ui/components/dialog';
+
+interface ToolbarBaseItem {
+    elementRef: ElementRef;
+    hidden: ModelSignal<boolean>;
+    template: () => TemplateRef<any>;
+}
+
+declare class ToolbarItem implements ToolbarBaseItem {
+    readonly elementRef: ElementRef<any>;
+    readonly hidden: i0.ModelSignal<boolean>;
+    readonly template: i0.Signal<TemplateRef<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarItem, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ToolbarItem, "ngs-toolbar-item", never, { "hidden": { "alias": "hidden"; "required": false; "isSignal": true; }; }, { "hidden": "hiddenChange"; }, never, ["*"], true, never>;
+}
+
+declare class ToolbarNav implements ToolbarBaseItem {
+    readonly elementRef: ElementRef<any>;
+    readonly hidden: i0.ModelSignal<boolean>;
+    readonly template: i0.Signal<TemplateRef<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarNav, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ToolbarNav, "ngs-toolbar-nav", ["ngsToolbarNav"], { "hidden": { "alias": "hidden"; "required": false; "isSignal": true; }; }, { "hidden": "hiddenChange"; }, never, ["*"], true, never>;
+}
+
+declare class ToolbarSpacer {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarSpacer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ToolbarSpacer, "ngs-toolbar-spacer", never, {}, {}, never, never, true, never>;
+}
+
+declare class ToolbarRow {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarRow, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ToolbarRow, "ngs-toolbar-row", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class Toolbar implements AfterViewInit, OnDestroy {
+    private _elementRef;
+    private _zone;
+    private _platformId;
+    private _injector;
+    private _dialog;
+    readonly toolbarItems: i0.Signal<readonly ToolbarItem[]>;
+    readonly navItems: i0.Signal<readonly ToolbarNav[]>;
+    readonly items: i0.WritableSignal<ToolbarBaseItem[]>;
+    readonly spacers: i0.Signal<readonly ToolbarSpacer[]>;
+    readonly _rows: i0.Signal<readonly ToolbarRow[]>;
+    protected readonly _overflowItems: i0.WritableSignal<ToolbarBaseItem[]>;
+    protected _dialogRef: DialogRef<any> | null;
+    private _resizeObserver?;
+    private _itemWidths;
+    constructor();
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    protected _openOverflowDialog(template: TemplateRef<any>): void;
+    protected _closeOverflowDialog(): void;
+    private _updateOverflow;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Toolbar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Toolbar, "ngs-toolbar", ["ngsToolbar"], {}, {}, ["toolbarItems", "navItems", "spacers", "_rows"], ["*"], true, never>;
+}
+
+declare class ToolbarNavLink {
+    /** The active state of the link. */
+    readonly active: i0.InputSignal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarNavLink, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ToolbarNavLink, "ngs-toolbar-nav-link,a[ngs-toolbar-nav-link]", ["ngsToolbarNavLink"], { "active": { "alias": "active"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ToolbarTitle {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarTitle, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ToolbarTitle, "ngs-toolbar-title", never, {}, {}, never, ["*"], true, never>;
+}
+
+export { Toolbar, ToolbarItem, ToolbarNav, ToolbarNavLink, ToolbarRow, ToolbarSpacer, ToolbarTitle };