@tolle_/tolle-ui 18.2.28 → 18.2.30

package/lib/reasoning.component.d.ts

@@ -0,0 +1,127 @@
+import { EventEmitter, OnChanges, OnDestroy, OnInit, SimpleChanges } from '@angular/core';
+import { type VariantProps } from 'class-variance-authority';
+import * as i0 from "@angular/core";
+/**
+ * Coordinates a `tolle-reasoning` with its trigger and content.
+ *
+ * The trigger and content are OnPush children, so the open/streaming/duration
+ * state they render from is published here rather than read off the parent.
+ *
+ * Provided on `ReasoningComponent`, so each trace gets its own instance.
+ */
+export declare class ReasoningService {
+    private readonly openSource;
+    /** Emits whether the trace is expanded. */
+    readonly open$: import("rxjs").Observable<boolean>;
+    private readonly streamingSource;
+    /** Emits whether the model is still producing the trace. */
+    readonly streaming$: import("rxjs").Observable<boolean>;
+    private readonly durationSource;
+    /** Emits how long the model spent reasoning, in seconds. */
+    readonly duration$: import("rxjs").Observable<number>;
+    /** True while the trace is expanded. */
+    get open(): boolean;
+    setOpen(value: boolean): void;
+    toggle(): void;
+    setStreaming(value: boolean): void;
+    setDuration(value: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReasoningService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ReasoningService>;
+}
+declare const reasoningVariants: (props?: ({
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type ReasoningProps = VariantProps<typeof reasoningVariants>;
+/**
+ * A collapsible view of the model's reasoning, collapsed by default.
+ *
+ * While `streaming` is true the trigger reads "Thinking…"; once it finishes the
+ * trigger reports how long the model thought, using `duration`.
+ *
+ * Compose it from `tolle-reasoning-trigger` and `tolle-reasoning-content`.
+ * @new
+ */
+export declare class ReasoningComponent implements OnInit, OnChanges, OnDestroy {
+    /** Whether the trace is expanded. @default false */
+    open: boolean;
+    /** True while the model is still producing the trace. @default false */
+    streaming: boolean;
+    /** Seconds the model spent reasoning, shown once streaming finishes. @default 0 */
+    duration: number;
+    /** Text scale of the trace. @default 'default' */
+    size: ReasoningProps['size'];
+    /** Extra Tailwind classes merged onto the trace via `cn()` (last-wins). */
+    class: string;
+    /** Emitted with the new state whenever the trace is expanded or collapsed. */
+    openChange: EventEmitter<boolean>;
+    private readonly service;
+    private readonly cdr;
+    private readonly subscriptions;
+    /** True while an `open` input is being pushed into the service. */
+    private applyingInput;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private applyInput;
+    ngOnDestroy(): void;
+    get computedClass(): string;
+    private sync;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReasoningComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ReasoningComponent, "tolle-reasoning", never, { "open": { "alias": "open"; "required": false; }; "streaming": { "alias": "streaming"; "required": false; }; "duration": { "alias": "duration"; "required": false; }; "size": { "alias": "size"; "required": false; }; "class": { "alias": "class"; "required": false; }; }, { "openChange": "openChange"; }, never, ["*"], true, never>;
+}
+/**
+ * Toggle for a `tolle-reasoning`. Shows a live "Thinking…" label while the
+ * trace is streaming and the elapsed thinking time once it is done.
+ */
+export declare class ReasoningTriggerComponent implements OnChanges, OnInit, OnDestroy {
+    /**
+     * Angular writes a bound `class` input through its styling path, which does
+     * not mark an OnPush component dirty — without this hook the component keeps
+     * rendering the class it was born with.
+     */
+    ngOnChanges(): void;
+    /** Remixicon class shown before the label. @default 'ri-brain-line' */
+    icon: string;
+    /** Label shown while the trace is streaming. @default 'Thinking…' */
+    thinkingLabel: string;
+    /** Label used when the trace finished without a measured duration. @default 'Thought for a few seconds' */
+    fallbackLabel: string;
+    /** Extra Tailwind classes merged onto the trigger via `cn()` (last-wins). */
+    class: string;
+    private readonly service;
+    private readonly cdr;
+    private readonly subscriptions;
+    open: boolean;
+    streaming: boolean;
+    duration: number;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /** "Thinking…" while streaming, otherwise how long the model thought. */
+    get label(): string;
+    get computedClass(): string;
+    onToggle(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReasoningTriggerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ReasoningTriggerComponent, "tolle-reasoning-trigger", never, { "icon": { "alias": "icon"; "required": false; }; "thinkingLabel": { "alias": "thinkingLabel"; "required": false; }; "fallbackLabel": { "alias": "fallbackLabel"; "required": false; }; "class": { "alias": "class"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+/** The reasoning text itself. Rendered only while the trace is expanded. */
+export declare class ReasoningContentComponent implements OnChanges, OnInit, OnDestroy {
+    /**
+     * Angular writes a bound `class` input through its styling path, which does
+     * not mark an OnPush component dirty — without this hook the component keeps
+     * rendering the class it was born with.
+     */
+    ngOnChanges(): void;
+    /** Reasoning text to render; project your own markup instead when richer. @default '' */
+    text: string;
+    /** Extra Tailwind classes merged onto the content via `cn()` (last-wins). */
+    class: string;
+    private readonly service;
+    private readonly cdr;
+    private readonly subscriptions;
+    open: boolean;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    get computedClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReasoningContentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ReasoningContentComponent, "tolle-reasoning-content", never, { "text": { "alias": "text"; "required": false; }; "class": { "alias": "class"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+export {};

package/lib/resizable.component.d.ts

@@ -0,0 +1,43 @@
+import { EventEmitter, ElementRef, AfterViewInit, OnDestroy } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class ResizableComponent implements AfterViewInit, OnDestroy {
+    width: number;
+    height: number;
+    minWidth: number;
+    minHeight: number;
+    maxWidth?: number;
+    maxHeight?: number;
+    resizable: boolean;
+    directions: ('right' | 'bottom' | 'both')[];
+    class: string;
+    containerClass: string;
+    resizeStart: EventEmitter<void>;
+    resize: EventEmitter<{
+        width: number;
+        height: number;
+    }>;
+    resizeEnd: EventEmitter<{
+        width: number;
+        height: number;
+    }>;
+    container: ElementRef<HTMLDivElement>;
+    private isResizing;
+    private resizeDirection;
+    private startX;
+    private startY;
+    private startWidth;
+    private startHeight;
+    private mouseMoveListener?;
+    private mouseUpListener?;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    get computedContainerClass(): string;
+    onResizeStart(event: MouseEvent, direction: 'horizontal' | 'vertical' | 'both'): void;
+    private onMouseMove;
+    private onMouseUp;
+    private getResizeCursor;
+    private setupGlobalListeners;
+    private cleanupGlobalListeners;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ResizableComponent, "tolle-resizable", never, { "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "minWidth": { "alias": "minWidth"; "required": false; }; "minHeight": { "alias": "minHeight"; "required": false; }; "maxWidth": { "alias": "maxWidth"; "required": false; }; "maxHeight": { "alias": "maxHeight"; "required": false; }; "resizable": { "alias": "resizable"; "required": false; }; "directions": { "alias": "directions"; "required": false; }; "class": { "alias": "class"; "required": false; }; "containerClass": { "alias": "containerClass"; "required": false; }; }, { "resizeStart": "resizeStart"; "resize": "resize"; "resizeEnd": "resizeEnd"; }, never, ["*"], true, never>;
+}

package/lib/segment.component.d.ts

@@ -10,7 +10,7 @@ export type SegmentItem = {
     class?: string;
     data?: any;
 };
-export declare class SegmentedComponent implements ControlValueAccessor, AfterViewInit, OnChanges, OnDestroy {
+export declare class SegmentComponent implements ControlValueAccessor, AfterViewInit, OnChanges, OnDestroy {
     private cdr;
     items: SegmentItem[];
     class: string;
@@ -49,6 +49,16 @@ export declare class SegmentedComponent implements ControlValueAccessor, AfterVi
     registerOnTouched(fn: any): void;
     setDisabledState(isDisabled: boolean): void;
     protected cn: typeof cn;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SegmentedComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<SegmentedComponent, "tolle-segment", never, { "items": { "alias": "items"; "required": false; }; "class": { "alias": "class"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "itemTemplate": { "alias": "itemTemplate"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SegmentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SegmentComponent, "tolle-segment", never, { "items": { "alias": "items"; "required": false; }; "class": { "alias": "class"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "itemTemplate": { "alias": "itemTemplate"; "required": false; }; }, {}, never, never, true, never>;
 }
+/**
+ * Back-compat alias: the class was renamed to match its `tolle-segment` selector.
+ *
+ * A re-export binding rather than `const SegmentedComponent = SegmentComponent`,
+ * because Angular's AOT compiler resolves an aliased export straight back to the
+ * class declaration — so it still works in a consumer's `imports: []` array.
+ *
+ * @deprecated Use `SegmentComponent`. This alias will be removed in a future major.
+ */
+export { SegmentComponent as SegmentedComponent };

package/lib/select.component.d.ts

@@ -1,18 +1,42 @@
-import { ElementRef, OnDestroy, QueryList, AfterContentInit, ChangeDetectorRef } from '@angular/core';
+import { EventEmitter, ElementRef, OnDestroy, QueryList, AfterContentInit, OnChanges, ChangeDetectorRef } from '@angular/core';
 import { ControlValueAccessor } from '@angular/forms';
+import { type VariantProps } from 'class-variance-authority';
 import { cn } from './utils/cn';
 import { SelectItemComponent } from './select-item.component';
 import { SelectService } from './select.service';
 import * as i0 from "@angular/core";
-export declare class SelectComponent implements ControlValueAccessor, AfterContentInit, OnDestroy {
+declare const selectTriggerVariants: (props?: ({
+    size?: "default" | "xs" | "sm" | "lg" | null | undefined;
+    disabled?: boolean | null | undefined;
+    readonly?: boolean | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type SelectProps = VariantProps<typeof selectTriggerVariants>;
+/**
+ * A single-select listbox: a trigger that opens a floating panel of
+ * `tolle-select-item` options, with optional inline search. Implements
+ * `ControlValueAccessor`, so it works with `ngModel` and reactive forms.
+ */
+export declare class SelectComponent implements ControlValueAccessor, AfterContentInit, OnChanges, OnDestroy {
     private selectService;
     private cdr;
+    /** Text shown on the trigger when nothing is selected. @default 'Select an option' */
     placeholder: string;
+    /** Extra Tailwind classes merged onto the trigger via `cn()` (last-wins). @default '' */
     class: string;
+    /** Disables the control and blocks opening the panel. @default false */
     disabled: boolean;
+    /** Adds a search box that filters the projected options. @default false */
     searchable: boolean;
-    size: 'xs' | 'sm' | 'default' | 'lg';
+    /** Height and text size of the trigger. @default 'default' */
+    size: SelectProps['size'];
+    /** Shows the current value but blocks opening the panel. @default false */
     readonly: boolean;
+    /** Emitted with the chosen value whenever the selection changes. */
+    valueChange: EventEmitter<any>;
+    /** Emitted when the panel opens. */
+    opened: EventEmitter<void>;
+    /** Emitted when the panel closes. */
+    closed: EventEmitter<void>;
     trigger: ElementRef;
     popover: ElementRef;
     container: ElementRef;
@@ -37,10 +61,17 @@ export declare class SelectComponent implements ControlValueAccessor, AfterConte
     constructor(selectService: SelectService, cdr: ChangeDetectorRef);
     get computedTriggerClass(): string;
     get iconClass(): string;
+    /**
+     * Under OnPush a `[class]` binding is applied through Angular's *styling*
+     * path, which writes the input but — unlike a plain property binding — never
+     * marks the component dirty. Without this the trigger would keep rendering
+     * the class it was born with. Covering every input here is cheap and leaves
+     * no second instance of that trap.
+     */
+    ngOnChanges(): void;
     ngAfterContentInit(): void;
     private applyPendingValue;
     private updateItemSelection;
-    private syncSelectedLabel;
     private _outsideClickHandler;
     toggle(): void;
     open(): void;
@@ -68,5 +99,6 @@ export declare class SelectComponent implements ControlValueAccessor, AfterConte
     setDisabledState(isDisabled: boolean): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<SelectComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<SelectComponent, "tolle-select", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "class": { "alias": "class"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "searchable": { "alias": "searchable"; "required": false; }; "size": { "alias": "size"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; }, {}, ["items"], ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SelectComponent, "tolle-select", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "class": { "alias": "class"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "searchable": { "alias": "searchable"; "required": false; }; "size": { "alias": "size"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; }, { "valueChange": "valueChange"; "opened": "opened"; "closed": "closed"; }, ["items"], ["*"], true, never>;
 }
+export {};

package/lib/sheet.component.d.ts

@@ -8,10 +8,13 @@ export declare class SheetComponent {
     private viewContainerRef;
     private scrollStrategy;
     private overlayRef?;
+    /** Pending teardown scheduled by `hide()` for the exit animation. */
+    private disposeTimer?;
     /** Element focused before the sheet opened, restored on close. */
     private previouslyFocused?;
     contentComponent?: any;
     open(): void;
+    private cancelPendingDispose;
     close(): void;
     private show;
     private hide;

package/lib/shimmer.component.d.ts

@@ -0,0 +1,38 @@
+import { OnChanges } from '@angular/core';
+import { type VariantProps } from 'class-variance-authority';
+import * as i0 from "@angular/core";
+declare const shimmerVariants: (props?: ({
+    size?: "default" | "xs" | "sm" | "lg" | "xl" | null | undefined;
+    active?: boolean | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type ShimmerProps = VariantProps<typeof shimmerVariants>;
+/**
+ * Shimmering text for a live, in-progress status — "Thinking…", "Generating
+ * response…". While `active` the projected text sweeps with the `.shimmer`
+ * utility; when it is false the same text renders plain and static, so the
+ * label can stay mounted as the state settles.
+ *
+ * ```html
+ * <tolle-shimmer [active]="isStreaming" size="sm">Generating response…</tolle-shimmer>
+ * ```
+ * @new
+ */
+export declare class ShimmerComponent implements OnChanges {
+    private readonly cdr;
+    /**
+     * Angular writes a bound `class` input through its styling path, which does
+     * not mark an OnPush component dirty — without this hook the component keeps
+     * rendering the class it was born with.
+     */
+    ngOnChanges(): void;
+    /** Runs the shimmer animation; false renders plain static text. @default true */
+    active: boolean;
+    /** Text size of the label. @default 'default' */
+    size: ShimmerProps['size'];
+    /** Extra Tailwind classes merged onto the label via `cn()` (last-wins). */
+    class: string;
+    get computedClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ShimmerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ShimmerComponent, "tolle-shimmer", never, { "active": { "alias": "active"; "required": false; }; "size": { "alias": "size"; "required": false; }; "class": { "alias": "class"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+export {};

package/lib/sidebar.component.d.ts

@@ -11,6 +11,8 @@ export type SidebarItem = {
     expanded?: boolean;
     /** Render as a plain anchor to an external URL / static file (opens in a new tab) instead of a router link. */
     external?: boolean;
+    /** Short trailing pill, e.g. 'New' or 'Beta'. Hidden while the sidebar is collapsed. */
+    badge?: string;
 };
 export type SidebarGroup = {
     title: string;

package/lib/sources.component.d.ts

@@ -0,0 +1,156 @@
+import { EventEmitter, OnChanges, OnDestroy, OnInit, SimpleChanges } from '@angular/core';
+import { type VariantProps } from 'class-variance-authority';
+import * as i0 from "@angular/core";
+/**
+ * Coordinates a `tolle-sources` with its trigger, content and sources.
+ *
+ * The trigger has to report how many sources were projected into a sibling
+ * component, so every `tolle-source` registers here and the trigger renders
+ * from the resulting count.
+ *
+ * Provided on `SourcesComponent`, so each citation list gets its own instance.
+ */
+export declare class SourcesService {
+    private readonly openSource;
+    /** Emits whether the citation list is expanded. */
+    readonly open$: import("rxjs").Observable<boolean>;
+    private readonly idsSource;
+    /** Emits the ids of the registered sources, in registration (DOM) order. */
+    readonly ids$: import("rxjs").Observable<string[]>;
+    /** True while the citation list is expanded. */
+    get open(): boolean;
+    /** How many sources are currently registered. */
+    get count(): number;
+    setOpen(value: boolean): void;
+    toggle(): void;
+    register(id: string): void;
+    unregister(id: string): void;
+    /** Zero-based position of a source, or -1 when it is not registered. */
+    indexOf(id: string): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SourcesService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SourcesService>;
+}
+declare const sourcesVariants: (props?: ({
+    variant?: "default" | "muted" | "card" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type SourcesProps = VariantProps<typeof sourcesVariants>;
+/**
+ * A collapsible list of the citations behind a response.
+ *
+ * Compose it from `tolle-sources-trigger`, `tolle-sources-content` and one
+ * `tolle-source` per citation — the trigger counts the sources for you.
+ * @new
+ */
+export declare class SourcesComponent implements OnInit, OnChanges, OnDestroy {
+    /** Whether the citation list is expanded. @default false */
+    open: boolean;
+    /** Visual treatment of the list container. @default 'default' */
+    variant: SourcesProps['variant'];
+    /** Extra Tailwind classes merged onto the list via `cn()` (last-wins). */
+    class: string;
+    /** Emitted with the new state whenever the list is expanded or collapsed. */
+    openChange: EventEmitter<boolean>;
+    private readonly service;
+    private readonly cdr;
+    private readonly subscriptions;
+    /** True while an `open` input is being pushed into the service. */
+    private applyingInput;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private applyInput;
+    ngOnDestroy(): void;
+    get computedClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SourcesComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SourcesComponent, "tolle-sources", never, { "open": { "alias": "open"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "class": { "alias": "class"; "required": false; }; }, { "openChange": "openChange"; }, never, ["*"], true, never>;
+}
+/** Toggle for a `tolle-sources`, labelled with how many sources there are. */
+export declare class SourcesTriggerComponent implements OnChanges, OnInit, OnDestroy {
+    /**
+     * Angular writes a bound `class` input through its styling path, which does
+     * not mark an OnPush component dirty — without this hook the component keeps
+     * rendering the class it was born with.
+     */
+    ngOnChanges(): void;
+    /** Overrides the counted number of sources. @default null */
+    count: number | null;
+    /** Extra Tailwind classes merged onto the trigger via `cn()` (last-wins). */
+    class: string;
+    private readonly service;
+    private readonly cdr;
+    private readonly subscriptions;
+    open: boolean;
+    registered: number;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /** How many sources the trigger reports. */
+    get total(): number;
+    get label(): string;
+    get computedClass(): string;
+    onToggle(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SourcesTriggerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SourcesTriggerComponent, "tolle-sources-trigger", never, { "count": { "alias": "count"; "required": false; }; "class": { "alias": "class"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+/**
+ * Holds the `tolle-source` entries of a `tolle-sources`.
+ *
+ * Stays in the DOM while collapsed — hidden and `inert` rather than removed —
+ * so the sources inside it stay registered and the trigger's count is right
+ * before the list has ever been opened.
+ */
+export declare class SourcesContentComponent implements OnChanges, OnInit, OnDestroy {
+    /**
+     * Angular writes a bound `class` input through its styling path, which does
+     * not mark an OnPush component dirty — without this hook the component keeps
+     * rendering the class it was born with.
+     */
+    ngOnChanges(): void;
+    /** Extra Tailwind classes merged onto the content via `cn()` (last-wins). */
+    class: string;
+    private readonly service;
+    private readonly cdr;
+    private readonly subscriptions;
+    open: boolean;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    get computedClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SourcesContentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SourcesContentComponent, "tolle-sources-content", never, { "class": { "alias": "class"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+declare const sourceVariants: (props?: ({
+    size?: "default" | "sm" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type SourceProps = VariantProps<typeof sourceVariants>;
+/** A single citation inside a `tolle-sources-content`. */
+export declare class SourceComponent implements OnChanges, OnInit, OnDestroy {
+    /**
+     * Angular writes a bound `class` input through its styling path, which does
+     * not mark an OnPush component dirty — without this hook the component keeps
+     * rendering the class it was born with.
+     */
+    ngOnChanges(): void;
+    /** URL the citation points at. @default '' */
+    href: string;
+    /** Human-readable title; falls back to the href when empty. @default '' */
+    title: string;
+    /** URL of a favicon shown instead of the numbered chip. @default '' */
+    favicon: string;
+    /** Overrides the auto-numbered position chip. @default null */
+    index: number | null;
+    /** Text scale of the citation. @default 'default' */
+    size: SourceProps['size'];
+    /** Extra Tailwind classes merged onto the citation via `cn()` (last-wins). */
+    class: string;
+    private readonly service;
+    private readonly cdr;
+    private readonly subscriptions;
+    private readonly id;
+    order: number;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /** One-based number shown in the chip. */
+    get position(): number;
+    get computedClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SourceComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SourceComponent, "tolle-source", never, { "href": { "alias": "href"; "required": false; }; "title": { "alias": "title"; "required": false; }; "favicon": { "alias": "favicon"; "required": false; }; "index": { "alias": "index"; "required": false; }; "size": { "alias": "size"; "required": false; }; "class": { "alias": "class"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+export {};

package/lib/spinner.component.d.ts

@@ -0,0 +1,29 @@
+import { OnChanges } from '@angular/core';
+import { type VariantProps } from 'class-variance-authority';
+import * as i0 from "@angular/core";
+declare const spinnerVariants: (props?: ({
+    size?: "default" | "xs" | "sm" | "lg" | "xl" | null | undefined;
+    variant?: "default" | "destructive" | "muted" | "primary" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type SpinnerProps = VariantProps<typeof spinnerVariants>;
+/**
+ * An indeterminate loading indicator. Renders as `role="status"` with a
+ * visually-hidden label so screen readers announce the loading state.
+ * @new
+ */
+export declare class SpinnerComponent implements OnChanges {
+    private readonly cdr;
+    ngOnChanges(): void;
+    /** Diameter of the spinner. @default 'default' */
+    size: SpinnerProps['size'];
+    /** Colour of the spinner, inherited from the theme tokens. @default 'default' */
+    variant: SpinnerProps['variant'];
+    /** Accessible label announced while the spinner is visible. @default 'Loading' */
+    label: string;
+    /** Extra Tailwind classes merged onto the spinner via `cn()` (last-wins). */
+    class: string;
+    get computedClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpinnerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SpinnerComponent, "tolle-spinner", never, { "size": { "alias": "size"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "label": { "alias": "label"; "required": false; }; "class": { "alias": "class"; "required": false; }; }, {}, never, never, true, never>;
+}
+export {};

package/lib/suggestion.component.d.ts

@@ -0,0 +1,96 @@
+import { EventEmitter, OnDestroy, OnInit, OnChanges } from '@angular/core';
+import { type VariantProps } from 'class-variance-authority';
+import * as i0 from "@angular/core";
+/**
+ * Relays a chosen suggestion from a `tolle-suggestion` up to the
+ * `tolle-suggestions` row that contains it, so consumers can listen in one
+ * place instead of binding every pill.
+ *
+ * Provided on `SuggestionsComponent`; injected optionally, since a pill is
+ * perfectly usable on its own.
+ */
+export declare class SuggestionsService {
+    private readonly selectedSource;
+    /** Emits the value of whichever suggestion the user picked. */
+    readonly selected$: import("rxjs").Observable<string>;
+    select(value: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SuggestionsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SuggestionsService>;
+}
+declare const suggestionsVariants: (props?: ({
+    gap?: "default" | "sm" | "lg" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type SuggestionsProps = VariantProps<typeof suggestionsVariants>;
+/**
+ * A horizontally scrollable row of suggested follow-up prompts.
+ *
+ * Fill it with `tolle-suggestion` pills and listen to this component's
+ * `selected` output to react to any of them.
+ */
+export declare class SuggestionsComponent implements OnChanges, OnInit, OnDestroy {
+    private readonly cdr;
+    /**
+     * Angular writes a bound `class` input through its styling path, which does
+     * not mark an OnPush component dirty — without this hook the component keeps
+     * rendering the class it was born with.
+     */
+    ngOnChanges(): void;
+    /** Spacing between the pills. @default 'default' */
+    gap: SuggestionsProps['gap'];
+    /** Accessible name for the row. @default 'Suggestions' */
+    ariaLabel: string;
+    /** Extra Tailwind classes merged onto the row via `cn()` (last-wins). */
+    class: string;
+    /** Emitted with the `value` of whichever suggestion in the row was picked. */
+    selected: EventEmitter<string>;
+    private readonly service;
+    private readonly subscriptions;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    get computedClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SuggestionsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SuggestionsComponent, "tolle-suggestions", never, { "gap": { "alias": "gap"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "class": { "alias": "class"; "required": false; }; }, { "selected": "selected"; }, never, ["*"], true, never>;
+}
+declare const suggestionVariants: (props?: ({
+    variant?: "outline" | "secondary" | "ghost" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type SuggestionProps = VariantProps<typeof suggestionVariants>;
+/**
+ * A single suggested follow-up prompt, rendered as a pill button.
+ *
+ * Projected content is the label; `value` is what gets emitted when it is
+ * picked, so the two can differ.
+ * @new
+ */
+export declare class SuggestionComponent implements OnChanges {
+    private readonly cdr;
+    /**
+     * Angular writes a bound `class` input through its styling path, which does
+     * not mark an OnPush component dirty — without this hook the component keeps
+     * rendering the class it was born with.
+     */
+    ngOnChanges(): void;
+    /** Value emitted when the pill is picked. @default '' */
+    value: string;
+    /** Visual style of the pill. @default 'outline' */
+    variant: SuggestionProps['variant'];
+    /** Size of the pill. @default 'default' */
+    size: SuggestionProps['size'];
+    /** Remixicon class shown before the label. @default '' */
+    icon: string;
+    /** Blocks interaction with the pill. @default false */
+    disabled: boolean;
+    /** Accessible name, when the projected label is not descriptive enough. @default '' */
+    ariaLabel: string;
+    /** Extra Tailwind classes merged onto the pill via `cn()` (last-wins). */
+    class: string;
+    /** Emitted with this pill's `value` when it is picked. */
+    selected: EventEmitter<string>;
+    private readonly parent;
+    get computedClass(): string;
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SuggestionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SuggestionComponent, "tolle-suggestion", never, { "value": { "alias": "value"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "size": { "alias": "size"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "class": { "alias": "class"; "required": false; }; }, { "selected": "selected"; }, never, ["*"], true, never>;
+}
+export {};