@forgeroute/ui 0.4.69 → 0.4.71

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forgeroute/ui",
-  "version": "0.4.69",
+  "version": "0.4.71",
   "peerDependencies": {
     "@angular/common": ">=22.0.0",
     "@angular/core": ">=22.0.0",

package/src/_animations.scss

@@ -7,8 +7,11 @@
   to { opacity: 1; }
 }
 
-@keyframes rowFadeUp {
-  from { opacity: 0; transform: translateY(6px); }
+// Entrance of the table header and rows: slides up only, it never fades. The header holds the tabs, search and buttons and the rows hold the
+// cell text, so while they fade in (opacity 0 to 1) an accessibility audit run right after render measures half-transparent text and reports a
+// colour-contrast failure that is gone 300ms later. Moving without changing opacity keeps every pixel of text at full contrast at all times.
+@keyframes slideUp {
+  from { transform: translateY(6px); }
 }
 
 @keyframes dotPulse {
@@ -25,13 +28,13 @@
 // Applied automatically by ui-data-table (rows and cards).
 // The stagger is capped at 8 steps (240ms) so a 50-row page never starts its last row ~1.5s late.
 .alive-row {
-  animation: rowFadeUp .3s ease backwards;
+  animation: slideUp .3s ease backwards;
   animation-delay: calc(min(var(--i, 0), 8) * 30ms);
 }
 
 // ── Page/toolbar header ──
 .alive-header {
-  animation: fadeUp .3s ease both;
+  animation: slideUp .3s ease both;
 }
 
 // ── Detail page cards ──

package/types/forgeroute-ui-messaging.d.ts

@@ -115,7 +115,7 @@ export declare class TemplatePickerComponent {
   private readonly host;
   private readonly search$;
   /** Filter results to a specific channel: 'email', 'text', or omit for all. */
-  readonly channel: import("@angular/core").InputSignal<"" | "text" | "email">;
+  readonly channel: import("@angular/core").InputSignal<"" | "email" | "text">;
   readonly selectedId: import("@angular/core").InputSignal<string | null>;
   readonly label: import("@angular/core").InputSignal<string>;
   /** Shows the red required asterisk (same as the library inputs) — e.g. when a template must be picked to send. */
@@ -543,7 +543,7 @@ export declare class DocumentSendOptionsComponent implements UiFieldValidity {
   /** API root from FORGEROUTE_CONFIG (e.g. a cross-origin prod API); falls back to same-origin `/api`. */
   private readonly apiBase;
   /** `email` → purpose select + attachment allowed; `text` → link only (purpose fixed to e-signature). */
-  readonly channel: import("@angular/core").InputSignal<"text" | "email">;
+  readonly channel: import("@angular/core").InputSignal<"email" | "text">;
   readonly label: import("@angular/core").InputSignal<string>;
   /** When true, at least one document must be chosen. The message forms leave it false: documents are optional there. */
   readonly required: import("@angular/core").InputSignal<boolean>;
@@ -608,7 +608,7 @@ export declare class DocumentSendOptionsComponent implements UiFieldValidity {
   /** Roles of documents whose row had no `signerRoles` and that the host resolves (`signers().resolveRoles`). */
   readonly roleStates: import("@angular/core").WritableSignal<Record<string, RoleState>>;
   /** The envelope's documents: `loading` / `error` while the panel reads them (`loadDocuments`), `ready` once known. */
-  readonly envelopeStatus: import("@angular/core").WritableSignal<"error" | "loading" | "ready" | "idle">;
+  readonly envelopeStatus: import("@angular/core").WritableSignal<"idle" | "loading" | "ready" | "error">;
   private envelopeSub;
   private readonly roleSubs;
   /** The sender opened the collapsed "Signing options" line. */
@@ -1997,7 +1997,7 @@ export declare class SendMessagePanelComponent {
   readonly activeContact: import("@angular/core").WritableSignal<MessageContact | null>;
   /** What the sender should know about the picked contact before sending (why a channel is missing, what to add). */
   readonly contactNotices: import("@angular/core").Signal<string[]>;
-  readonly channel: import("@angular/core").WritableSignal<"text" | "email">;
+  readonly channel: import("@angular/core").WritableSignal<"email" | "text">;
   readonly valid: import("@angular/core").WritableSignal<boolean>;
   /** Bumped on every fresh open / new contact — re-creates the email and text forms so no draft carries over. */
   readonly formEpoch: import("@angular/core").WritableSignal<number>;

package/types/forgeroute-ui-stripe.d.ts

@@ -1300,7 +1300,7 @@ export declare class StripeConnectComponent {
   readonly navigateTab: import("@angular/core").InputSignal<((url: string) => void) | null>;
   protected readonly visible: import("@angular/core").Signal<boolean>;
   /** Which screen the card shows. */
-  protected readonly state: import("@angular/core").Signal<"complete" | "verifying" | "incomplete" | "none">;
+  protected readonly state: import("@angular/core").Signal<"none" | "complete" | "verifying" | "incomplete">;
   /** What the persistent status region says: the current state, plus "Loading." while a request runs. Empty while nothing is shown. */
   protected readonly liveText: import("@angular/core").Signal<string>;
   /** The user pressed a button that started a request: when the screen then changes, focus moves to the new screen (the pressed button is gone). */

package/types/forgeroute-ui.d.ts

@@ -1,7 +1,7 @@
 import * as i0 from "@angular/core";
 import { EnvironmentProviders, InjectionToken, OnDestroy, OnInit, Signal, TemplateRef, WritableSignal } from "@angular/core";
 import { UrlTree } from "@angular/router";
-import { Observable } from "rxjs";
+import { Observable, Subject } from "rxjs";
 import { AbstractControl, ControlValueAccessor, FormControl, ValidationErrors, Validator, ValidatorFn } from "@angular/forms";
 import { HttpInterceptorFn } from "@angular/common/http";
 import { SafeHtml } from "@angular/platform-browser";
@@ -1801,6 +1801,10 @@ export declare class DataTableComponent<T extends Record<string, any>> implement
   /** State for the built-in single-row delete confirmation modal. */
   protected readonly _rowDeleteTarget: import("@angular/core").WritableSignal<T | null>;
   protected readonly _rowDeleting: import("@angular/core").WritableSignal<boolean>;
+  /** Ids the built-in delete confirm dialog is described by (aria-describedby): its message and the "what will happen" list. */
+  private readonly _confirmUid;
+  protected readonly _confirmMsgId: string;
+  protected readonly _confirmDetailsId: string;
   protected readonly _rowDeleteConfig: import("@angular/core").WritableSignal<{
     title: string;
     message: string;
@@ -2261,6 +2265,12 @@ export declare class ModalComponent implements OnInit, OnDestroy {
   readonly open: import("@angular/core").InputSignal<boolean>;
   readonly title: import("@angular/core").InputSignal<string>;
   readonly description: import("@angular/core").InputSignal<string>;
+  /**
+   * Id(s) of the element(s) inside the dialog that describe it (space-separated, as `aria-describedby` takes them), e.g. the confirm message
+   * paragraph. Screen readers read them after the title when the dialog opens. When it is not set and `description` is, the dialog is described
+   * by that description line; with neither, no `aria-describedby` is rendered (the body of a form dialog is not a description).
+   */
+  readonly describedBy: import("@angular/core").InputSignal<string | null>;
   readonly maxWidth: import("@angular/core").InputSignal<string>;
   readonly bodyOverflow: import("@angular/core").InputSignal<"hidden" | "auto" | "visible">;
   /** `data-testid` of the dialog element itself (the host `<ui-modal>` is always in the page, the dialog only while open). None when empty. */
@@ -2295,6 +2305,8 @@ export declare class ModalComponent implements OnInit, OnDestroy {
   readonly returnFocusTo: import("@angular/core").InputSignal<HTMLElement | null>;
   protected readonly kiosk: import("@angular/core").Signal<boolean>;
   protected readonly titleId: string;
+  protected readonly descId: string;
+  protected readonly describedById: import("@angular/core").Signal<string | null>;
   private readonly el;
   private readonly ren;
   private readonly doc;
@@ -2332,6 +2344,11 @@ export declare class ModalComponent implements OnInit, OnDestroy {
       "required": false;
       "isSignal": true;
     };
+    "describedBy": {
+      "alias": "describedBy";
+      "required": false;
+      "isSignal": true;
+    };
     "maxWidth": {
       "alias": "maxWidth";
       "required": false;
@@ -2387,6 +2404,54 @@ export declare class ModalComponent implements OnInit, OnDestroy {
   }, never, ["[modal-header-end]", "*", "[modal-footer-left]", "[modal-footer-center]", "[modal-footer-right]"], true, never>;
 }
 export type ToastType = 'success' | 'error' | 'info';
+/** A button on a toast (e.g. "View Contact", "Call Back"). */
+export interface ToastAction {
+  /** Identifies the button in `onAction` and in the `(action)` output; also the test id suffix (`toast-action-<id>`). */
+  id: string;
+  label: string;
+  /** Look of the button. Default `secondary`. */
+  variant?: 'primary' | 'secondary' | 'danger';
+  disabled?: boolean;
+  /** Keep the toast open after this button is used. Default `false`: using a button closes the toast. */
+  keepOpen?: boolean;
+}
+/** What `(action)` / `ToastService.action$` emit when a toast button is used. */
+export interface ToastActionEvent {
+  /** The `id` of the button. */
+  id: string;
+  /** The `key` of the toast it belongs to, when the toast had one. */
+  key?: string;
+}
+/**
+ * Per-message options for `show()` / `success()` / `info()` / `error()` / `notify()`. Every field is optional; a call without any of them is a plain
+ * toast exactly as before.
+ */
+export interface ToastOptions {
+  /** Only `notify()` reads this (`show` / `success` / `info` / `error` fix their own type). Default `success`. */
+  type?: ToastType;
+  /** How long it stays, in ms. Default: 3000 (4000 for errors). */
+  duration?: number;
+  /** A bold first line above the message. */
+  title?: string;
+  /** Buttons under the message. */
+  actions?: readonly ToastAction[];
+  /** Show "Dismissing in Ns" and a shrinking bar for this toast. Default: the outlet's / app's `countdown` setting (off). */
+  countdown?: boolean;
+  /** When another toast is showing, wait for it to finish instead of replacing it. Default: the outlet's / app's `queue` setting (off). */
+  queue?: boolean;
+  /** Identifies the toast: while one with the same key is showing or waiting, another one with that key is not added again (e.g. one per call id). */
+  key?: string;
+  /** Called with the `id` of a button when it is used (before the toast closes). */
+  onAction?: (actionId: string) => void;
+}
+/** What is known about the toast on screen beyond its message and type; `null` for a plain toast. */
+export interface ToastDetails {
+  title?: string;
+  actions: readonly ToastAction[];
+  countdown: boolean;
+  key?: string;
+  onAction?: (actionId: string) => void;
+}
 export declare class ToastService implements OnDestroy {
   readonly message: import("@angular/core").WritableSignal<string | null>;
   readonly type: import("@angular/core").WritableSignal<ToastType>;
@@ -2402,18 +2467,42 @@ export declare class ToastService implements OnDestroy {
    * Set once per app with `provideForgerouteToast({ persistentLiveRegion: true })`, or per outlet with `<ui-toast [persistentLiveRegion]="true" />`.
    */
   readonly persistentLiveRegion: import("@angular/core").WritableSignal<boolean>;
+  /** The title, buttons, countdown flag, key and callback of the toast on screen; `null` for a plain toast or none. */
+  readonly details: import("@angular/core").WritableSignal<ToastDetails | null>;
+  /** How many toasts are waiting behind the one on screen (queue mode). */
+  readonly queuedCount: import("@angular/core").WritableSignal<number>;
+  /** Default for `ToastOptions.queue`: new toasts wait for the one on screen instead of replacing it. Set with `provideForgerouteToast({ queue: true })` or `<ui-toast [queue]="true" />`. */
+  readonly queueDefault: import("@angular/core").WritableSignal<boolean>;
+  /** Default for `ToastOptions.countdown`. Set with `provideForgerouteToast({ countdown: true })` or `<ui-toast [countdown]="true" />`. */
+  readonly countdownDefault: import("@angular/core").WritableSignal<boolean>;
+  /** Most toasts that may wait; further ones are dropped. Default 20. Set with `provideForgerouteToast({ maxQueued })` or `<ui-toast [maxQueued]="n" />`. */
+  readonly maxQueued: import("@angular/core").WritableSignal<number>;
+  /** Time left of the toast on screen, in ms; only kept up to date for a toast with a countdown. */
+  readonly remainingMs: import("@angular/core").WritableSignal<number>;
+  /** The full time the toast on screen was given, in ms (the denominator of the countdown bar). */
+  readonly totalMs: import("@angular/core").WritableSignal<number>;
+  /** Emits when a toast button is used. */
+  readonly action$: Subject<ToastActionEvent>;
   private _timer;
+  private _ticker;
+  private _advanceTimer;
   private _deadline;
   private _remaining;
   private _paused;
-  show(msg: string, duration?: number): void;
+  private _queue;
+  /** Green success toast. `durationOrOptions` is the time in ms (default 3000) or a {@link ToastOptions} object. */
+  show(msg: string, durationOrOptions?: number | ToastOptions): void;
   /** Green success toast, the explicit name for `show()` (same type, same 3000ms default, same behaviour). */
-  success(msg: string, duration?: number): void;
+  success(msg: string, durationOrOptions?: number | ToastOptions): void;
   /** Neutral (blue) toast for a result that is neither a success nor a failure, e.g. "No changes to save.". */
-  info(msg: string, duration?: number): void;
-  error(msg: string, duration?: number): void;
-  /** Removes the current toast now (close button / Escape). Safe when nothing is showing. */
+  info(msg: string, durationOrOptions?: number | ToastOptions): void;
+  error(msg: string, durationOrOptions?: number | ToastOptions): void;
+  /** A toast whose type comes from `options.type` (default `success`); the same as the named methods otherwise. */
+  notify(msg: string, options?: ToastOptions): void;
+  /** Removes the current toast now (close button / Escape); the next waiting one, if any, follows. Safe when nothing is showing. */
   dismiss(): void;
+  /** Uses the button `id` of the toast on screen: calls its `onAction`, emits `action$`, and closes the toast unless the button has `keepOpen`. No-op for an unknown or disabled button. */
+  runAction(id: string): void;
   /** Holds the countdown while the pointer or keyboard focus is on the toast (WCAG 2.2.1). No-op when nothing is counting down. */
   pause(): void;
   /** Continues after `pause()`; the toast gets at least 1000ms more so it can be read. No-op when not paused. */
@@ -2421,8 +2510,14 @@ export declare class ToastService implements OnDestroy {
   /** The root injector is destroyed (app teardown, TestBed reset): no timer may outlive it. */
   ngOnDestroy(): void;
   private _clearTimer;
+  private _clearTicker;
+  private _clearAdvance;
+  /** Starts the expiry timer (and the countdown ticker for a toast with a countdown). `fresh` = a new toast, not a resume after a pause. */
   private _start;
-  private _display;
+  /** The toast on screen is over (expired, dismissed or its button used): clear it and bring in the next waiting one after a short gap. */
+  private _finish;
+  private _enter;
+  private _present;
   static ɵfac: i0.ɵɵFactoryDeclaration<ToastService, never>;
   static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
@@ -2448,6 +2543,28 @@ export declare class ToastComponent {
    */
   readonly persistentLiveRegion: import("@angular/core").InputSignal<boolean | null>;
   protected readonly persistent: import("@angular/core").Signal<boolean>;
+  /**
+   * Outlet-wide defaults for the optional parts of a toast (a message's own options win). `null` (default) leaves the app / service setting alone
+   * (`provideForgerouteToast`, itself off); a value is applied while this is the live outlet.
+   *
+   * - `queue`: a toast that arrives while another is showing waits for it instead of replacing it.
+   * - `countdown`: show "Dismissing in Ns" and a shrinking bar on every toast.
+   * - `maxQueued`: how many may wait (default 20).
+   */
+  readonly queue: import("@angular/core").InputSignal<boolean | null>;
+  readonly countdown: import("@angular/core").InputSignal<boolean | null>;
+  readonly maxQueued: import("@angular/core").InputSignal<number | null>;
+  /** Wording of the countdown line; `{n}` is the seconds left. */
+  readonly countdownLabel: import("@angular/core").InputSignal<string>;
+  /** Wording of the chip that says how many toasts are waiting; `{n}` is the count. */
+  readonly queueLabel: import("@angular/core").InputSignal<string>;
+  /** A toast button was used (also after its own `onAction`). */
+  readonly action: import("@angular/core").OutputEmitterRef<ToastActionEvent>;
+  protected readonly isRich: import("@angular/core").Signal<boolean>;
+  protected readonly countdownPct: import("@angular/core").Signal<number>;
+  protected readonly countdownText: import("@angular/core").Signal<string>;
+  protected readonly queueText: import("@angular/core").Signal<string>;
+  protected onAction(id: string): void;
   /**
    * Message that was already on screen when this instance took over from a destroyed host. While it is
    * unchanged the toast renders without the entry animation and without live-region roles, so the
@@ -2478,7 +2595,34 @@ export declare class ToastComponent {
       "required": false;
       "isSignal": true;
     };
-  }, {}, never, never, true, never>;
+    "queue": {
+      "alias": "queue";
+      "required": false;
+      "isSignal": true;
+    };
+    "countdown": {
+      "alias": "countdown";
+      "required": false;
+      "isSignal": true;
+    };
+    "maxQueued": {
+      "alias": "maxQueued";
+      "required": false;
+      "isSignal": true;
+    };
+    "countdownLabel": {
+      "alias": "countdownLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "queueLabel": {
+      "alias": "queueLabel";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "action": "action";
+  }, never, never, true, never>;
 }
 export type ProgressBarVariant = 'blue' | 'green' | 'amber' | 'red' | 'slate';
 /**
@@ -4816,6 +4960,11 @@ export declare class ConfirmService {
 export declare class ConfirmOutletComponent implements OnInit, OnDestroy {
   protected readonly svc: ConfirmService;
   protected readonly _isPrimary: import("@angular/core").Signal<boolean>;
+  /** Unique per outlet: the dialog is described by the message and, when there is one, the "what will happen" list (aria-describedby). */
+  private readonly _uid;
+  protected readonly msgId: string;
+  protected readonly detailsId: string;
+  protected readonly _describedBy: import("@angular/core").Signal<string>;
   ngOnInit(): void;
   ngOnDestroy(): void;
   static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmOutletComponent, never>;
@@ -7344,6 +7493,7 @@ export declare class NotesComponent {
  *   providers: [provideForgerouteToast()]
  *   providers: [provideForgerouteToast({ dismissible: true })]   // every toast also gets a close button (default: none)
  *   providers: [provideForgerouteToast({ persistentLiveRegion: true })]   // always-present live regions: reliable announcements in VoiceOver / Safari
+ *   providers: [provideForgerouteToast({ queue: true, countdown: true, maxQueued: 10 })]   // toasts wait for each other and show a countdown (defaults; a message's own options win)
  *
  * It is created first, so it is the registry's host and any other `<ui-toast>` (a table's own, a shell's) stays silent: each
  * message renders and is announced once. Nothing happens on the server. The outlet is destroyed with the app.
@@ -7351,6 +7501,9 @@ export declare class NotesComponent {
 export declare function provideForgerouteToast(options?: {
   dismissible?: boolean;
   persistentLiveRegion?: boolean;
+  queue?: boolean;
+  countdown?: boolean;
+  maxQueued?: number;
 }): EnvironmentProviders;
 /** Payload of `(reorder)`. Apply it with `reorderItems(items, order)` or take the ready-made `items`. */
 export interface ListReorderEvent<T = unknown> {
@@ -13562,6 +13715,30 @@ export interface ConversationMessage {
   sender?: string | null;
   /** A link-style button under the text, e.g. "View transaction"; clicking it emits `(messageAction)` with this message. */
   action?: ConversationMessageAction | null;
+  /** A record the message points at (a job, an estimate…), shown as a chip under the text; a chip with a `url` is a link. */
+  link?: ConversationLink | null;
+}
+/** A record linked to a message (see `ConversationMessage.link`, `[(link)]` and `ConversationSendEvent.link`). */
+export interface ConversationLink {
+  /** What kind of record it is (`JOB`, `ESTIMATE`…): the host's own code, handed back unchanged. */
+  type: string;
+  /** The record's id. */
+  id: string;
+  /** What the chip says, e.g. "Johnson Roof — Alice". */
+  label: string;
+  /** Where the chip goes when it is clicked; none = a plain chip. Only used on messages, not in the composer. */
+  url?: string | null;
+}
+/** One section of the "Link a record" picker: the records of one kind. */
+export interface ConversationLinkGroup {
+  /** The kind, copied to `ConversationLink.type` of every pick from this section. */
+  type: string;
+  /** The section heading, e.g. "Jobs". */
+  label: string;
+  items: ReadonlyArray<{
+    id: string;
+    label: string;
+  }>;
 }
 /** The button a message can carry (see `ConversationMessage.action`). */
 export interface ConversationMessageAction {
@@ -13579,6 +13756,8 @@ export interface ConversationSendEvent {
   text: string;
   /** Only with `[richText]="true"`: the formatted message as sanitised HTML (bold, italic, underline, links, lists). */
   html?: string;
+  /** Only when a record is linked (`[(link)]`): the chosen record. The key is absent otherwise. */
+  link?: ConversationLink;
 }
 /** A message with the date separator that goes above it ('' when it shares the day of the previous message). */
 export interface ConversationMessageRow {
@@ -13790,6 +13969,24 @@ export declare class ConversationsComponent {
   /** Files accepted by the attach picker (type and size already checked against `acceptedFiles` / `maxFileSize`). */
   readonly filesSelected: import("@angular/core").OutputEmitterRef<File[]>;
   readonly attachmentRemove: import("@angular/core").OutputEmitterRef<void>;
+  /**
+   * Link a record to a message (opt-in): `null` (default) = no link button, no picker, nothing changes. A list (even an empty one) turns on a "Link a record"
+   * button in the composer that opens a searchable picker of these sections; the pick becomes `[(link)]`, shows as a removable chip above the composer, and
+   * goes out with `(send)` as `link`. Load the sections when `(linkPickerOpened)` fires and show `[linkLoading]` meanwhile.
+   */
+  readonly linkGroups: import("@angular/core").InputSignal<readonly ConversationLinkGroup[] | null>;
+  readonly linkLoading: import("@angular/core").InputSignal<boolean>;
+  /** The record linked to the message being written. Cleared by the host after a send, like `[(draft)]`; the chip's × clears it too. */
+  readonly link: import("@angular/core").ModelSignal<ConversationLink | null>;
+  readonly linkLabel: import("@angular/core").InputSignal<string>;
+  readonly linkPickerTitle: import("@angular/core").InputSignal<string>;
+  readonly linkSearchPlaceholder: import("@angular/core").InputSignal<string>;
+  readonly linkSearchLabel: import("@angular/core").InputSignal<string>;
+  readonly linkEmptyText: import("@angular/core").InputSignal<string>;
+  readonly linkLoadingText: import("@angular/core").InputSignal<string>;
+  readonly removeLinkLabel: import("@angular/core").InputSignal<string>;
+  /** The "Link a record" button opened the picker: load the sections now. */
+  readonly linkPickerOpened: import("@angular/core").OutputEmitterRef<void>;
   /** An image in a bubble was clicked: the host opens it (usually in a new tab). */
   readonly mediaOpen: import("@angular/core").OutputEmitterRef<string>;
   /** The link-style button of a message (`ConversationMessage.action`) was clicked. */
@@ -13818,8 +14015,12 @@ export declare class ConversationsComponent {
   protected readonly emptyText: import("@angular/core").Signal<string>;
   protected readonly messageRows: import("@angular/core").Signal<import("@forgeroute/ui").ConversationMessageRow[]>;
   protected readonly contextVisible: import("@angular/core").Signal<boolean>;
-  /** Something to send (text or a file), the composer is open and no request is running. */
+  /** Something to send (text, a file or a linked record), the composer is open and no request is running. */
   readonly canSend: import("@angular/core").Signal<boolean>;
+  protected readonly pickerOpen: import("@angular/core").WritableSignal<boolean>;
+  protected readonly linkQuery: import("@angular/core").WritableSignal<string>;
+  /** The picker's sections narrowed by the search (case-insensitive, on the record label); a section with no match is left out. */
+  protected readonly visibleLinkGroups: import("@angular/core").Signal<ConversationLinkGroup[]>;
   /** The composer's formatted content. `draft` is always its plain text, so a host that reads or sets `[(draft)]` never sees markup. */
   protected readonly editorHtml: import("@angular/core").WritableSignal<string>;
   protected readonly richHide: RichTextOption[];
@@ -13838,6 +14039,12 @@ export declare class ConversationsComponent {
   protected onComposeKeydown(event: KeyboardEvent): void;
   protected onEditorChange(html: string): void;
   protected sendMessage(): void;
+  protected openLinkPicker(): void;
+  protected closeLinkPicker(): void;
+  protected pickLink(group: ConversationLinkGroup, item: {
+    id: string;
+    label: string;
+  }): void;
   private clock;
   private singleColumn;
   private scrollToBottom;
@@ -14268,6 +14475,56 @@ export declare class ConversationsComponent {
       "required": false;
       "isSignal": true;
     };
+    "linkGroups": {
+      "alias": "linkGroups";
+      "required": false;
+      "isSignal": true;
+    };
+    "linkLoading": {
+      "alias": "linkLoading";
+      "required": false;
+      "isSignal": true;
+    };
+    "link": {
+      "alias": "link";
+      "required": false;
+      "isSignal": true;
+    };
+    "linkLabel": {
+      "alias": "linkLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "linkPickerTitle": {
+      "alias": "linkPickerTitle";
+      "required": false;
+      "isSignal": true;
+    };
+    "linkSearchPlaceholder": {
+      "alias": "linkSearchPlaceholder";
+      "required": false;
+      "isSignal": true;
+    };
+    "linkSearchLabel": {
+      "alias": "linkSearchLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "linkEmptyText": {
+      "alias": "linkEmptyText";
+      "required": false;
+      "isSignal": true;
+    };
+    "linkLoadingText": {
+      "alias": "linkLoadingText";
+      "required": false;
+      "isSignal": true;
+    };
+    "removeLinkLabel": {
+      "alias": "removeLinkLabel";
+      "required": false;
+      "isSignal": true;
+    };
   }, {
     "searchText": "searchTextChange";
     "contextOpen": "contextOpenChange";
@@ -14285,6 +14542,8 @@ export declare class ConversationsComponent {
     "send": "send";
     "filesSelected": "filesSelected";
     "attachmentRemove": "attachmentRemove";
+    "link": "linkChange";
+    "linkPickerOpened": "linkPickerOpened";
     "mediaOpen": "mediaOpen";
     "messageAction": "messageAction";
     "loadEarlier": "loadEarlier";