@sinequa/atomic-angular 1.17.0 → 2.0.0

package/types/sinequa-atomic-angular-document-workspaces.d.ts

@@ -0,0 +1,2527 @@
+import { SecurityPrincipal, UpdateContainerInput, UploadJobStatus } from "@sinequa/atomic";
+import * as i0 from "@angular/core";
+import { InjectionToken, PipeTransform, Signal } from "@angular/core";
+import { DetailedError } from "tus-js-client";
+import { DialogResult } from "@sinequa/galactik";
+import { SafeResourceUrl } from "@angular/platform-browser";
+import { FieldTree } from "@angular/forms/signals";
+/** What the current user may do in a workspace. A reader can only look. */
+type WorkspaceRole = "creator" | "owner" | "reader";
+/** Accent a workspace's folder is drawn with — derived from its id, see `workspaceColorFor()`. */
+type WorkspaceColor = "default" | "teal" | "pink" | "blue" | "orange" | "indigo" | "green";
+/** A set of documents, stored server-side as a "container". */
+interface Workspace {
+  id: string;
+  name: string;
+  color: WorkspaceColor;
+  description: string;
+  tags: string[];
+  documentCount: number;
+  creatorId: string;
+  ownerIds: string[];
+  readerIds: string[];
+  currentUserRole: WorkspaceRole;
+}
+/** Lifecycle of a document being added: `null` (or absent) once it is indexed. */
+type DocumentStatus = "uploading" | "indexing" | "error";
+type DocumentType = "pdf" | "csv" | "doc";
+interface WorkspaceDocument {
+  id: string;
+  name: string;
+  workspaceId?: string;
+  type: DocumentType;
+  /**
+   * UTC ISO 8601; `undefined` when the server does not know it. The listing only
+   * carries the creation date — how it is displayed is the view's business.
+   */
+  createdAt?: string;
+  /**
+   * Bytes. Neither the documents listing nor the upload-status endpoint serves a
+   * size (swagger `ContainerDocumentViewModel`, checked 2026-09-30): unset for now.
+   */
+  size?: number;
+  /** Not served by the listing either; kept for a "source" column when a backend provides one. */
+  source?: string;
+  status?: DocumentStatus | null;
+  uploadedBy?: string;
+  /**
+   * Upload progress, 0..100 (100 once the document is fully received) — not
+   * indexing progress. From the documents listing, which reads the server's
+   * status store: a document shows up there from the moment it starts
+   * uploading, not only once indexed.
+   */
+  percent?: number;
+  /** Ties a document back to a job of the upload-status endpoint. */
+  jobId?: string;
+}
+/** The two roles a member can be given; `creator` is immutable and never assigned. */
+type AssignableRole = "owner" | "reader";
+/** One person picked in the principal picker — a chip, and one entry of the owners/readers arrays. */
+interface PickedPrincipal {
+  /** The principal's `userId` (`domain|id`): what a workspace's owners/readers hold. */
+  id: string;
+  name: string;
+  isGroup: boolean;
+  role: AssignableRole;
+}
+/** One row of the access list. */
+interface Member {
+  id: string;
+  name: string;
+  /** Secondary line under the name, when the directory gave one. */
+  email?: string;
+  isGroup: boolean;
+  /** The logged-in user's own row: marked "(you)", and without a role menu. */
+  isSelf: boolean;
+  role: "creator" | AssignableRole;
+  /** False when the id has no cached name and `name` is the raw id. */
+  resolved: boolean;
+}
+/**
+ * Where a file stands in the tracker.
+ *
+ * `rejected` is terminal like `done` and `error`: the server will never index
+ * the file (a type outside the workspace's conversion plan). Without a state of
+ * its own such a file would sit under "Indexing" for ever.
+ */
+type UploadStatus = "uploading" | "indexing" | "done" | "error" | "rejected";
+/** A file the tracker follows, from the first byte sent to the end of indexing. */
+interface TrackedUpload {
+  /** `<jobId>/<fileName>`: the job and file name the status API reports errors under. Not the server's document id. */
+  id: string;
+  name: string;
+  type: DocumentType;
+  workspaceId: string;
+  status: UploadStatus;
+  /** Upload progress while `uploading`, indexing progress while `indexing`; 0..100. */
+  percent: number;
+  /** The server's explanation of an `error` (job `errors[].error`) or a `rejected` (`rejected[].reason`). */
+  message?: string;
+  /** An `error` that sending the file again could fix (a lost connection), as opposed to one the server will keep refusing. */
+  retryable: boolean;
+  /**
+   * Set on a row that does not come from this client's own transfers but from the
+   * status API: a job (or one of its failed files) started elsewhere. A job row is
+   * the whole job — the API gives no list of its files — so it has no `name`, and
+   * nothing here can cancel or retry it.
+   */
+  remote?: RemoteUpload;
+}
+/** What the tracker knows about a row it only learned from the status API. */
+interface RemoteUpload {
+  /** The current user started this job (from another tab, or before a page reload). */
+  mine: boolean;
+}
+/** What to tell the tracker when files start. */
+interface TrackFileInput {
+  id: string;
+  name: string;
+  type: DocumentType;
+}
+/**
+ * What the tracker's connection banner is currently saying. Published whenever
+ * the situation changes, and `null` once everything is healthy again.
+ */
+interface ConnectionNotice {
+  /**
+   * - `retrying` - a transfer is waiting out `retryAtMs` before its next attempt;
+   * - `reconnecting` - a session recovery is in flight;
+   * - `signed-out` - recovery came back negative; nothing moves until the user
+   *   signs in again.
+   */
+  phase: "retrying" | "reconnecting" | "signed-out";
+  /** Transfers held up by this. 0 when only the status poll is affected. */
+  uploads: number;
+  /** 1-based number of the attempt about to be made, and the budget it comes from. */
+  attempt: number;
+  maxAttempts: number;
+  /** Epoch ms of the next attempt - the countdown's target (`retrying` only). */
+  retryAtMs?: number;
+  /** Epoch ms at which the retry budget runs out (`retrying` only). */
+  budgetEndsAtMs?: number;
+  /** Epoch ms the connection was first reported lost - drives "lost N ago". */
+  sinceMs: number;
+  /**
+   * Re-runs the recovery, for the banner's Retry button. Carried on the notice
+   * because it is the one thing the banner can DO, and it is meaningless without
+   * the notice it belongs to. Absent when there is nothing useful to retry.
+   */
+  retry?(): void;
+}
+/**
+ * Most workspaces the list keeps loaded: "load more" stops there, so the list never puts an
+ * unbounded number of cards in the DOM. Past it, {@link WorkspacesStore.truncated} is true.
+ */
+declare const MAX_LOADED_WORKSPACES: number;
+interface Pagination {
+  page: number;
+  total: number;
+}
+interface WorkspacesState {
+  workspaces: Workspace[];
+  /** True once the first page of workspaces has been read from the server. */
+  loaded: boolean;
+  /** True while a (re)load is in flight. */
+  loading: boolean;
+  pagination: Pagination;
+  documents: Record<string, WorkspaceDocument[]>;
+  documentPagination: Record<string, Pagination>;
+  /** Ids ticked in the "+"/"@" mention pickers — shared between every picker instance. */
+  selectedIds: string[];
+}
+interface CreateWorkspaceInput {
+  name: string;
+  description?: string;
+  tags?: string[];
+  /** Optional: they go out on the same POST as the metadata, so sharing at creation costs no extra round trip. */
+  owners?: string[];
+  readers?: string[];
+}
+interface RemoveWorkspacesResult {
+  succeeded: string[];
+  failed: {
+    id: string;
+    error: string;
+  }[];
+}
+/**
+ * Workspaces and their documents, backed by the container-management API
+ * (`@sinequa/atomic`'s `*Container*` functions).
+ *
+ * Root-scoped on purpose: the workspace list, the mention picker and the
+ * save/move picker are separate components that have to see the same cache and
+ * the same selection.
+ *
+ * Every write method resolves or rejects around the matching endpoint and only
+ * touches the cache once the server has answered, so a rejected call leaves
+ * the state as it was — the call site reports the error.
+ *
+ * `addDocuments`, `discardDocuments` and `patchDocument` stay purely local. The upload
+ * flow no longer uses them: the list is the index, and only the listing writes to it.
+ */
+export declare const WorkspacesStore: import("@angular/core").Type<{
+  workspaces: import("@angular/core").Signal<Workspace[]>;
+  loaded: import("@angular/core").Signal<boolean>;
+  loading: import("@angular/core").Signal<boolean>;
+  pagination: import("@ngrx/signals").DeepSignal<Pagination>;
+  documents: import("@angular/core").Signal<Record<string, WorkspaceDocument[]>>;
+  documentPagination: import("@angular/core").Signal<Record<string, Pagination>>;
+  selectedIds: import("@angular/core").Signal<string[]>;
+  hasMore: import("@angular/core").Signal<boolean>;
+  truncated: import("@angular/core").Signal<boolean>;
+  selectedCount: import("@angular/core").Signal<number>;
+  selectedIdSet: import("@angular/core").Signal<Set<string>>;
+  workspace: (id: string) => Workspace | undefined;
+  documentsOf: (workspaceId: string) => WorkspaceDocument[];
+  hasMoreDocuments: (workspaceId: string) => boolean;
+  ensureLoaded: () => Promise<Workspace[]>;
+  reload: () => Promise<Workspace[]>;
+  loadMore: () => Promise<Workspace[]>;
+  fetch: (id: string) => Promise<Workspace>;
+  create: ({ name, description, tags, owners, readers }: CreateWorkspaceInput) => Promise<Workspace>;
+  update: (id: string, patch: UpdateContainerInput) => Promise<Workspace | null>;
+  remove: (ids: string[]) => Promise<RemoveWorkspacesResult>;
+  forget: (id: string) => void;
+  loadDocuments: (workspaceId: string, signal?: AbortSignal) => Promise<WorkspaceDocument[]>;
+  loadMoreDocuments: (workspaceId: string) => Promise<WorkspaceDocument[]>;
+  addDocuments: (workspaceId: string, documents: WorkspaceDocument[]) => void;
+  discardDocuments: (workspaceId: string, documentIds: string[]) => void;
+  patchDocument: (workspaceId: string, documentId: string, patch: Partial<WorkspaceDocument>) => void;
+  saveDocuments: (workspaceId: string, documents: Pick<WorkspaceDocument, "name">[]) => Promise<WorkspaceDocument[]>;
+  removeDocuments: (workspaceId: string, documentIds: string[]) => Promise<void>;
+  moveDocuments: (fromWorkspaceId: string, toWorkspaceId: string, documentIds: string[]) => Promise<void>;
+  toggleSelected: (id: string, checked: boolean) => void;
+  clearSelection: () => void;
+} & import("@ngrx/signals").StateSource<{
+  workspaces: Workspace[];
+  loaded: boolean;
+  loading: boolean;
+  pagination: Pagination;
+  documents: Record<string, WorkspaceDocument[]>;
+  documentPagination: Record<string, Pagination>;
+  selectedIds: string[];
+}>>;
+interface TrackerWorkspace {
+  id: string;
+  name: string;
+}
+interface UploadTrackerState {
+  uploads: TrackedUpload[];
+  /** The workspaces being uploaded to, in the order they were first seen. */
+  workspaces: TrackerWorkspace[];
+  connection: ConnectionNotice | null;
+  /** Files dropped from the tracker because their whole workspace finished — they still count as indexed. */
+  clearedCount: number;
+  /** What the server last said about each job's indexing, 0-100: indexed files / files of the job. */
+  jobIndexing: Record<string, number>;
+  /**
+   * Jobs the user got rid of — closed, cancelled, cleared. The status API keeps listing a
+   * job for a while after it ends, so without this a job closed by hand would come
+   * straight back as an upload started elsewhere. Survives `reset()`, on purpose.
+   */
+  ignoredJobs: Record<string, true>;
+}
+/** A job the status API reports that this client did not start — or no longer remembers starting. */
+interface RemoteJobEntry {
+  job: UploadJobStatus;
+  workspaceId: string;
+  workspaceName: string;
+  /** The current user started the job (`initiatedBy` is the current user's id). */
+  mine: boolean;
+}
+export declare const isFinished: (upload: TrackedUpload) => boolean;
+export declare const isFailed: (upload: TrackedUpload) => boolean;
+interface PhaseProgress {
+  uploading: number;
+  indexing: number;
+}
+/**
+ * How far along a set of uploads is, for each of the two phases, as one 0-100 number.
+ *
+ * Measured over the files of every job that still has something moving in the phase —
+ * and over ALL of that job's files (a failed or refused one aside), not just the ones
+ * currently listed in the phase. A file that moved on is a file that finished the phase:
+ * counting only the ones left would make the bar drop, or stall, each time one finishes.
+ * That is also how the server counts (`indexed files / files of the job`), so the two agree.
+ *
+ * - uploading: the files still sending count their own percentage, the others are at 100;
+ * - indexing: the API has no per-file percentage, only the job's aggregate. What the
+ *   server last said and what is already known locally (files done / files) are both
+ *   lower bounds of the truth: the larger one wins, so the bar never falls back.
+ */
+declare function phaseProgress(uploads: readonly TrackedUpload[], jobIndexing: Record<string, number>): PhaseProgress;
+/**
+ * The state of every upload the tracker follows — pure state, no I/O.
+ *
+ * `UploadService` writes to it as bytes move and as the server reports; the
+ * tracker panel only reads it. Because nothing here talks to the network, a
+ * test or a demo page can drive the panel by injecting this store and calling
+ * `track()` / `setProgress()` / `setDone()`… directly.
+ *
+ * Root-scoped: an upload must outlive the page that started it.
+ */
+export declare const UploadTrackerStore: import("@angular/core").Type<{
+  uploads: import("@angular/core").Signal<TrackedUpload[]>;
+  workspaces: import("@angular/core").Signal<TrackerWorkspace[]>;
+  connection: import("@ngrx/signals").DeepSignal<ConnectionNotice> | import("@angular/core").Signal<null>;
+  clearedCount: import("@angular/core").Signal<number>;
+  jobIndexing: import("@angular/core").Signal<Record<string, number>>;
+  ignoredJobs: import("@angular/core").Signal<Record<string, true>>;
+  active: import("@angular/core").Signal<boolean>;
+  failed: import("@angular/core").Signal<TrackedUpload[]>;
+  byStatus: import("@angular/core").Signal<Record<UploadStatus, TrackedUpload[]>>;
+  allDone: import("@angular/core").Signal<boolean>;
+  settled: import("@angular/core").Signal<boolean>;
+  authorFailed: import("@angular/core").Signal<boolean>;
+  progress: import("@angular/core").Signal<Record<string, PhaseProgress>>;
+  indexedCount: import("@angular/core").Signal<number>;
+  track: (files: TrackFileInput[], workspaceId: string, workspaceName: string) => void;
+  setProgress: (id: string, percent: number) => void;
+  setIndexing: (id: string) => void;
+  setDone: (id: string) => void;
+  setError: (id: string, options?: {
+    message?: string;
+    retryable?: boolean;
+  }) => void;
+  restart: (id: string) => void;
+  applyJobs: (jobs: UploadJobStatus[]) => boolean;
+  applyRemoteJobs: (entries: RemoteJobEntry[]) => boolean;
+  setConnection: (connection: ConnectionNotice | null) => void;
+  remove: (id: string) => void;
+  removeWorkspace: (workspaceId: string) => void;
+  reset: () => void;
+} & import("@ngrx/signals").StateSource<{
+  uploads: TrackedUpload[];
+  workspaces: TrackerWorkspace[];
+  connection: ConnectionNotice | null;
+  clearedCount: number;
+  jobIndexing: Record<string, number>;
+  ignoredJobs: Record<string, true>;
+}>>;
+interface UploadTarget {
+  id: string;
+  name: string;
+}
+interface AddFilesOptions {
+  /** The tus endpoint — the `upload-endpoint` of the host. Relative paths resolve against the configured backend. */
+  endpoint: string;
+}
+/**
+ * Sends files to a workspace and follows them until they are indexed.
+ *
+ * Two independent things happen after a file is handed over, and both can stall
+ * on the same cause (a lost connection, a lapsed session):
+ *
+ * - the byte transfer, by tus, which retries on its own schedule;
+ * - indexing, a server-side job tus knows nothing about, observed by polling
+ *   the Document Upload status API.
+ *
+ * One small state machine here owns both, and the tracker's connection banner
+ * speaks for both. What the user sees lives in `UploadTrackerStore`; this
+ * service only writes to it.
+ *
+ * It never writes a file into a workspace's list: the list is the index, and a file
+ * enters it only once the container listing returns it. What the service does for the
+ * list is re-read that listing while something is in progress.
+ *
+ * Root-scoped: an upload must outlive the view that started it. It registers its
+ * window and auth listeners once, and removes them when the application is destroyed.
+ */
+export declare class UploadService {
+  private readonly tracker;
+  private readonly workspaces;
+  private readonly currentUser;
+  private readonly createUpload;
+  private readonly uploads;
+  /**
+   * Documents this client is still transferring or waiting on. The server's
+   * status store can lag a job by a tick or two, so this is what keeps the
+   * polling loop alive until it catches up — and emptying it lets it stop.
+   */
+  private readonly inFlight;
+  private readonly poller;
+  private focusedWorkspaceId;
+  /** Document id -> the retry tus has scheduled for it. Empty means nothing is waiting. */
+  private readonly retrying;
+  /** A recovery is in flight. Distinct from `signedOut`: one is "asking", the other is the answer. */
+  private recovering;
+  /** The last recovery said the user is genuinely signed out. Reset the moment anything re-authenticates. */
+  private signedOut;
+  /** When the trouble started, so the banner can say for how long. 0 while healthy. */
+  private lostSinceMs;
+  private recovery;
+  constructor();
+  /**
+   * Stages the files as one ingest job and starts sending them. Everything the
+   * user picked goes out as ONE batch (one job id).
+   *
+   * No client-side gatekeeping: no type allow-list, no count or size cap. What
+   * can be indexed is the server's call (the workspace's conversion plan); the
+   * files it will not take come back in the job's `rejected[]`. The server does
+   * cap a job at 1 GiB on the declared total and answers 413 past it.
+   *
+   * @returns The tracked id of each file, in order.
+   */
+  addFiles(workspace: UploadTarget, files: File[], options: AddFilesOptions): string[];
+  /**
+   * Abandons a transfer and forgets it: stops it, and drops the file from the
+   * tracker. Works while it is sending
+   * and once it has failed; once the bytes are in, indexing is the server's and
+   * there is nothing left to cancel.
+   *
+   * The server is asked to discard what it received (tus termination extension).
+   * It may not support that, in which case the transfer is only stopped and the
+   * leftover is reclaimed by the server's own retention.
+   */
+  cancel(id: string): Promise<void>;
+  /** Sends a failed transfer again, from where the server left off. Only a transfer the server did not refuse. */
+  retry(id: string): void;
+  /**
+   * Picks up every transfer whose retry budget ran out while the connection was
+   * down. Safe to call at any time: a transfer still retrying is left alone.
+   * The `File` is held by tus for as long as the tab is open, which is what makes
+   * this recovery automatic — an upload does not survive the tab closing.
+   */
+  resumeStalled(): void;
+  /**
+   * Tells the service which workspace is open, so the status polling can be
+   * scoped to it (the API documents that as the cheaper lookup) and re-read its
+   * listing. `null` when none is. Starts the polling: a page reload loses every
+   * local tus handle and the listing no longer says what is in progress, so the
+   * status API is the only way to know. The loop stops by itself after one tick
+   * when nothing is.
+   */
+  watch(workspaceId: string | null): void;
+  startPolling(): void;
+  stopPolling(): void;
+  private startUpload;
+  private markIndexing;
+  private markError;
+  private pollUploadStatus;
+  private runPollTick;
+  /**
+   * The jobs of the response the panel should show although this client did not send
+   * them. The server decides which ones the response holds — those in progress or just
+   * ended, on the workspaces the user can write to — so none is filtered by role or date
+   * here; only, with a workspace open, those that belong to it are kept. Whether the user
+   * started one is read from `initiatedBy`, which is their `userId`, so it holds after a
+   * page reload too.
+   */
+  private remoteJobs;
+  /** Re-reads the workspace's listing. @returns Whether it differs from what was shown. */
+  private refreshListing;
+  /** The job-level status can finish a file this client was still holding the poller for: release it. */
+  private settleFinishedUploads;
+  /** Transfers that spent their whole budget and are parked in the error state: what "N uploads paused" counts once retrying has stopped. */
+  private stalledUploadCount;
+  private publishConnection;
+  private noteRetryScheduled;
+  /** Drops a scheduled retry — the attempt happened, or will never happen. */
+  private clearRetryNotice;
+  /**
+   * Something came back cleanly, so the session demonstrably works — whatever the
+   * last recovery concluded. Without this, one `signed-out` verdict would outlive
+   * the sign-in that fixed it and make the NEXT 401, on a healthy session, refuse
+   * to retry.
+   */
+  private noteHealthy;
+  /**
+   * Recovers the session and picks up whatever was waiting on it. Single-flight:
+   * every stalled upload and the status poll hit 401 within the same instant, and
+   * one probe answers for all of them.
+   */
+  private recoverSessionAndResume;
+  private runRecovery;
+  static ɵfac: i0.ɵɵFactoryDeclaration<UploadService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * Retry schedule for a tus chunk, in ms. tus caps the number of attempts at this
+ * array's LENGTH, so surviving an outage is a matter of how many entries there
+ * are, not just how long they are. The total (~5 min) is deliberately sized on
+ * the server's own retention: its cleanup reclaims an incomplete upload idle for
+ * 5 minutes and then answers 410 Gone, so retrying past that cannot succeed — at
+ * which point the upload is recovered by the `online` handler instead.
+ */
+declare const UPLOAD_RETRY_DELAYS: number[];
+/**
+ * Statuses the ingest endpoint uses to say "this upload will never be accepted":
+ * retrying them only burns requests. Everything else — a network error (status
+ * 0), a 5xx, a 429 — is transient and worth another attempt.
+ *
+ * 401 is deliberately NOT in here even though it is a 4xx. An upload that
+ * outlives a connection drop comes back holding a CSRF token the server has
+ * since forgotten, so every attempt 401s and the whole retry budget burns
+ * without a byte moving — which is exactly the failure this list would make
+ * permanent. It is handled on its own by the service: recover the session, then
+ * let the same retry carry the fresh token.
+ */
+declare const FATAL_UPLOAD_STATUSES: ReadonlySet<number>;
+/** What an upload tells whoever drives it. */
+interface UploadEvents {
+  /**
+   * Whether tus should try again after a failed attempt. `status` is the HTTP
+   * status of the failure, 0 for a network error; `attempt` is 0-based and is
+   * the index into {@link UPLOAD_RETRY_DELAYS} of the delay tus waited before it.
+   */
+  shouldRetry(status: number, attempt: number): boolean;
+  /** Any response came back — `status` tells whether the connection is working again. */
+  responded(status: number): void;
+  /** Resolves once the request may go out: a session recovery in flight has to finish first, it is what the retry is for. */
+  beforeRequest(): Promise<void>;
+  progress(bytesUploaded: number, bytesTotal: number | null): void;
+  /** The server holds every byte. Indexing is a separate server-side job with no tus equivalent. */
+  success(): void;
+  /** The retry budget is spent, or the server refused for good. */
+  failed(error: Error): void;
+}
+interface UploadOptions {
+  /** Absolute: tus must not resolve a relative endpoint against the host page instead of the configured backend. */
+  endpoint: string;
+  /** The ingest endpoint validates these keys and answers 400 if one is missing. */
+  metadata: Record<string, string>;
+  events: UploadEvents;
+}
+/** An upload in flight, whatever moves its bytes. */
+interface UploadHandle {
+  /** Starts it — resuming a previous attempt at the same file when tus recognises it (same name, size, type, date). */
+  begin(): void;
+  /** Sends it again after a failure; tus re-reads the server's offset first, so only the missing bytes go out. */
+  resume(): void;
+  /**
+   * Stops it. With `terminate`, the server is asked to drop what it received
+   * (tus termination extension) — which it may not support, in which case this rejects.
+   */
+  abort(terminate: boolean): Promise<void>;
+}
+type UploadFactory = (file: File, options: UploadOptions) => UploadHandle;
+/** The HTTP status behind a tus error: 0 when there was no response (a network error). */
+declare function tusErrorStatus(error: DetailedError): number;
+/** Sends `file` with tus. */
+declare const createTusUpload: UploadFactory;
+/** Overridable so the service can be driven without a network. */
+export declare const UPLOAD_FACTORY: InjectionToken<UploadFactory>;
+interface CurrentUser {
+  /** The principal's `userId` (`domain|id`) — the id space a workspace's owners/readers use. */
+  id: string;
+  name: string;
+}
+/**
+ * The logged-in user's identity — the one thing @sinequa/atomic has no
+ * synchronous notion of. Resolved once, on first injection, through
+ * `fetchPrincipal()`; `user()` is `undefined` until it settles (and stays so
+ * if the request fails).
+ *
+ * Callers render off `user()` straight away and treat "unknown" as a valid
+ * fallback (a raw-id badge, the generic "You" label) rather than an error.
+ * Those that must not act on "unknown" as if it were an answer — the
+ * "you can't remove yourself" rule needs to know which row is yours —
+ * await {@link whenReady}.
+ */
+export declare class CurrentUserService {
+  private readonly _user;
+  private readonly ready;
+  readonly user: import("@angular/core").Signal<CurrentUser | undefined>;
+  constructor();
+  /** The same identity as `user()`, but awaitable. Resolves `undefined` if the principal request failed. */
+  whenReady(): Promise<CurrentUser | undefined>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<CurrentUserService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+interface PrincipalSummary {
+  name: string;
+  isGroup: boolean;
+  /** Users only, and only when the directory has one — the access list's secondary line. */
+  email?: string;
+}
+/** A principal id turned into something renderable. */
+interface ResolvedPrincipal {
+  /** Display label — the cached name, or the raw id when it isn't cached. Never decorated: see `isSelf`. */
+  name: string;
+  /** Secondary line under the name, when the directory gave one. */
+  email?: string;
+  isGroup: boolean;
+  /** False when the id has no cached name and `name` is the raw id. */
+  resolved: boolean;
+  /** True when this id is the logged-in user's. */
+  isSelf: boolean;
+}
+/**
+ * The label to show for a principal: a user's full name where it has one,
+ * otherwise the account name. Groups only ever have `name`.
+ */
+export declare function principalDisplayName(principal: SecurityPrincipal): string;
+/**
+ * Names for the principal ids a workspace's owners/readers hold, which are
+ * opaque `domain|id` strings the API never resolves for us.
+ *
+ * Persisted in `sessionStorage` per the product decision — it survives
+ * navigation within the tab and is cleared when the tab closes — so an access
+ * list doesn't flash raw ids on every open.
+ *
+ * `resolve()` is synchronous and reads signals, so a template or `computed`
+ * that calls it re-renders by itself once {@link ensureResolved} fills a gap.
+ * An id that is not cached shows up as the raw id, which is also what an id
+ * the server can't resolve at all (a deleted account) keeps showing — still
+ * enough to keep it in the owners/readers arrays on the next save rather than
+ * silently revoking it.
+ */
+export declare class PrincipalDirectory {
+  private readonly currentUser;
+  private readonly cache;
+  /**
+   * Resolves a principal id for display, identically wherever an owners/readers
+   * id is rendered — the access list and the add/edit dialog's "Share with" chips.
+   *
+   * "(you)" is deliberately NOT folded into the name: it would end up in the
+   * avatar's initials and in every message that interpolates a name. Views
+   * render it as its own element off `isSelf`.
+   */
+  resolve(id: string): ResolvedPrincipal;
+  /** Records a name learned elsewhere (e.g. a person just picked in the principal picker). */
+  remember(id: string, summary: PrincipalSummary): void;
+  /**
+   * Searches the directory by free text and remembers every name it learns, so a
+   * person just picked already has one when the access list shows them.
+   *
+   * @param query - What the user typed.
+   * @param signal - Cancels the request when a newer keystroke supersedes it.
+   * @returns Users and groups alike; the caller decides which it can use.
+   */
+  search(query: string, signal?: AbortSignal): Promise<SecurityPrincipal[]>;
+  /**
+   * Fetches and caches the names for any of `ids` not already known.
+   *
+   * @param ids - Principal identities, typically a workspace's owners/readers.
+   *
+   * @returns Resolves once the cache has been updated. A failed lookup resolves
+   *   rather than rejecting: the UI already renders unresolved ids, and a name
+   *   is not worth failing an access dialog over.
+   */
+  ensureResolved(ids: string[]): Promise<void>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<PrincipalDirectory, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * Turns an element into a place to drop files on, or to click to pick some.
+ *
+ * ```html
+ * <div dropzone (filesSelected)="stage($event)">Drop your files here</div>
+ * ```
+ *
+ * Both ways end in the same `filesSelected` output. While files are dragged over
+ * it the host gets a `data-dragover` attribute to style. It is a button for
+ * assistive technology and the keyboard (Enter or Space opens the file picker).
+ *
+ * It does no gatekeeping — no type, count or size check: whatever is dropped
+ * or picked is emitted, and what can be handled is the server's call.
+ */
+export declare class Dropzone {
+  /** Files dropped or picked, in the order the browser gave them. */
+  readonly filesSelected: import("@angular/core").OutputEmitterRef<File[]>;
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  protected readonly dragging: import("@angular/core").WritableSignal<boolean>;
+  private depth;
+  protected browse(): void;
+  protected onKey(event: Event): void;
+  protected onDragEnter(event: DragEvent): void;
+  protected onDragOver(event: DragEvent): void;
+  protected onDragLeave(event: DragEvent): void;
+  protected onDrop(event: DragEvent): void;
+  /** A text or a link being dragged around the page is none of our business. */
+  private carriesFiles;
+  private emit;
+  static ɵfac: i0.ɵɵFactoryDeclaration<Dropzone, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<Dropzone, "[dropzone]", never, {
+    "disabled": {
+      "alias": "dropzoneDisabled";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "filesSelected": "filesSelected";
+  }, never, never, true, never>;
+}
+/**
+ * Turns an element into the drag handle of a resizable panel.
+ *
+ * The panel's width is two-way bound through the directive's own name:
+ *
+ * ```html
+ * <aside [style.width.px]="width()">
+ *   <div [(resizeHandle)]="width" resizeMin="280" [resizeMax]="maxWidth()"></div>
+ * </aside>
+ * ```
+ *
+ * It follows the WAI-ARIA separator pattern: the handle is focusable and the
+ * arrow keys resize it, so the panel stays usable without a pointer. The pointer
+ * is captured on `pointerdown`, so a drag keeps going when the cursor leaves the
+ * handle or crosses an iframe (which would otherwise swallow the events).
+ */
+export declare class ResizeHandle {
+  /** The panel's width in px. */
+  readonly width: import("@angular/core").ModelSignal<number>;
+  readonly resizeMin: import("@angular/core").InputSignalWithTransform<number, any>;
+  /** Upper bound in px; unbounded when absent. */
+  readonly resizeMax: import("@angular/core").InputSignal<number | undefined>;
+  /** px moved per arrow key press. */
+  readonly resizeStep: import("@angular/core").InputSignalWithTransform<number, any>;
+  /**
+   * Which edge of the panel the handle sits on — and therefore which way a drag
+   * widens it: dragging a `left` handle to the left widens the panel.
+   */
+  readonly resizeEdge: import("@angular/core").InputSignal<"left" | "right">;
+  /** Whether the handle is being dragged. */
+  readonly resizing: import("@angular/core").WritableSignal<boolean>;
+  private readonly direction;
+  private startX;
+  private startWidth;
+  protected onPointerDown(event: PointerEvent): void;
+  protected onPointerMove(event: PointerEvent): void;
+  protected onPointerEnd(event: PointerEvent): void;
+  protected onKeydown(event: KeyboardEvent): void;
+  private clamp;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ResizeHandle, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<ResizeHandle, "[resizeHandle]", ["resizeHandle"], {
+    "width": {
+      "alias": "resizeHandle";
+      "required": true;
+      "isSignal": true;
+    };
+    "resizeMin": {
+      "alias": "resizeMin";
+      "required": false;
+      "isSignal": true;
+    };
+    "resizeMax": {
+      "alias": "resizeMax";
+      "required": false;
+      "isSignal": true;
+    };
+    "resizeStep": {
+      "alias": "resizeStep";
+      "required": false;
+      "isSignal": true;
+    };
+    "resizeEdge": {
+      "alias": "resizeEdge";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "width": "resizeHandleChange";
+  }, never, never, true, never>;
+}
+/**
+ * Hides an element from anyone who cannot change the workspace — a reader, or
+ * whoever the role is not known for yet. One rule for every edit / share /
+ * delete / upload control, instead of the check being repeated on each.
+ *
+ * ```html
+ * <button [writerOnly]="workspace().currentUserRole" (click)="edit()">Edit</button>
+ * ```
+ *
+ * It sets `hidden`, which also drops the element from the accessibility tree
+ * and the tab order; a layout class that sets `display` must not override it.
+ */
+export declare class WriterOnly {
+  readonly writerOnly: import("@angular/core").InputSignal<WorkspaceRole | null | undefined>;
+  protected readonly writable: import("@angular/core").Signal<boolean>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<WriterOnly, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<WriterOnly, "[writerOnly]", never, {
+    "writerOnly": {
+      "alias": "writerOnly";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/** A slice of a text, flagged when it is what a search matched. */
+interface TextChunk {
+  text: string;
+  match: boolean;
+}
+/** Lower-cases and strips accents, so "Resume" finds "Résumé". */
+declare function fold(text: string): string;
+/**
+ * Folds `text` while remembering, for each folded code unit, which slice of the
+ * original it came from — folding can change the length (a combining mark
+ * vanishes, `İ` becomes two units), so a match position in the folded text is
+ * not a position in the original.
+ */
+declare function foldWithOffsets(text: string): {
+  folded: string;
+  starts: number[];
+  ends: number[];
+};
+/**
+ * Whether `text` contains `query`, ignoring case and accents. An empty query
+ * matches everything.
+ */
+declare function matchesText(text: string, query: string): boolean;
+/**
+ * Splits `text` around every occurrence of `query` (case- and accent-insensitive),
+ * keeping the original characters — the accents a user typed or stored are not
+ * lost to the matching.
+ *
+ * It returns data rather than markup on purpose: the text is user-supplied
+ * (a workspace or document name) and the view renders the chunks through Angular's
+ * own escaping instead of interpolating them into HTML.
+ */
+declare function splitByMatch(text: string, query: string): TextChunk[];
+/**
+ * Splits a text around what a search matched, ignoring case and accents.
+ *
+ * Unlike `highlightWord`, it keeps the original characters (that pipe returns
+ * chunks of the accent-stripped text, which would display "Donnees" for
+ * "Données") and is meant to be rendered, never bound to `innerHTML`:
+ *
+ * ```html
+ * @for (chunk of workspace.name | highlightMatch: query(); track $index) {
+ *   @if (chunk.match) { <mark>{{ chunk.text }}</mark> } @else { {{ chunk.text }} }
+ * }
+ * ```
+ */
+export declare class HighlightMatchPipe implements PipeTransform {
+  transform(text: string | null | undefined, query: string | null | undefined): TextChunk[];
+  static ɵfac: i0.ɵɵFactoryDeclaration<HighlightMatchPipe, never>;
+  static ɵpipe: i0.ɵɵPipeDeclaration<HighlightMatchPipe, "highlightMatch", true>;
+}
+/**
+ * Text to print as is, or a key of the `documentWorkspaces` scope (with its
+ * parameters) to translate. Lets a class decide *what* to say and leave *saying
+ * it* to the template, which has the translation pipe.
+ */
+type Message = {
+  text: string;
+} | {
+  key: string;
+  params?: Record<string, unknown>;
+};
+/** A message from the `tracker` namespace. */
+declare function trackerMessage(key: string, params?: Record<string, unknown>): Message;
+/** Shortens a file name to `max` characters, keeping its extension: `long-na….pdf`. */
+declare function truncateName(name: string, max: number): string;
+/**
+ * What to call a tracked row: the file's name — or, for a job started elsewhere whose files
+ * the status API does not list, whose job it is.
+ */
+declare function uploadLabel(upload: Pick<TrackedUpload, "name" | "remote">, max: number): Message;
+/** `m:ss` for a duration in ms, clamped at 0 so a late tick cannot go negative. */
+declare function formatClock(ms: number): string;
+interface DocumentLabels {
+  /** "1.2 MB", or `null` when the size is not known — the API does not serve one, only a file uploaded in this session has it. */
+  size: Signal<string | null>;
+  /** "Added 3 hours ago", or `null` when the creation date is not known. */
+  added: Signal<Message | null>;
+}
+/**
+ * The size and date labels a document card and a document row both show,
+ * following the active language.
+ *
+ * Must be called from an injection context (a component field initializer).
+ */
+export declare function injectDocumentLabels(document: Signal<WorkspaceDocument>): DocumentLabels;
+/**
+ * Whether the browser reports a network connection, kept up to date from the
+ * window's `online` / `offline` events. `true` where there is no `navigator`
+ * (server-side rendering).
+ *
+ * `navigator.onLine` only knows about the network interface, not whether the
+ * server is reachable: treat `false` as certain and `true` as likely.
+ *
+ * Must be called from an injection context; the listeners are removed when it is destroyed.
+ */
+export declare function injectOnlineStatus(): Signal<boolean>;
+interface SelectionOptions<T> {
+  /** What can currently be selected — pass the list as it is displayed (filtered), not the full one. */
+  items: Signal<readonly T[]>;
+  /** A stable id per item. */
+  key: (item: T) => string;
+  /**
+   * Whether an item may be ticked at all — a workspace shared read-only cannot be
+   * deleted, so it should not count towards "3 selected" nor be ticked by "select all".
+   * Every item is selectable when absent. Read reactively: it may depend on signals.
+   */
+  selectable?: (item: T) => boolean;
+}
+interface Selection<T> {
+  /** Whether the selection mode (checkboxes, selection bar) is on. */
+  readonly active: Signal<boolean>;
+  /** The displayed items that can be ticked — empty when there is nothing to offer the selection mode for. */
+  readonly selectableItems: Signal<T[]>;
+  /** The displayed, selectable items that are ticked. An item filtered out of `items` is not counted. */
+  readonly selectedItems: Signal<T[]>;
+  readonly count: Signal<number>;
+  /** Every selectable displayed item is ticked (never true when there is none). */
+  readonly allSelected: Signal<boolean>;
+  /** Some, but not all, are ticked — the "indeterminate" state of a select-all checkbox. */
+  readonly partiallySelected: Signal<boolean>;
+  /** Whether the item may be ticked. Reactive when read from a template or a `computed`. */
+  canSelect(item: T): boolean;
+  /** Reactive when read from a template or a `computed`. An item that cannot be selected is never selected. */
+  isSelected(item: T): boolean;
+  /** Does nothing for an item that cannot be selected. */
+  toggle(item: T, selected?: boolean): void;
+  /** Ticks every selectable displayed item, or unticks them all when they already are. */
+  toggleAll(): void;
+  /** Turns the selection mode on or off; leaving it clears the selection. */
+  toggleMode(): void;
+  start(): void;
+  /** Leaves the selection mode and clears the selection. */
+  exit(): void;
+  clear(): void;
+}
+/**
+ * Multi-selection over a displayed list — the selection mode, the ticked
+ * items, and the state of a select-all checkbox — shared by the workspace list
+ * and the document list.
+ *
+ * Ticks are kept by key, so they survive the list being filtered or switched
+ * between grid and list views: a tick on an item that is filtered out stays
+ * until it comes back, but only displayed items are counted and returned.
+ *
+ * Must be called from an injection context (a component field initializer).
+ */
+export declare function injectSelection<T>(options: SelectionOptions<T>): Selection<T>;
+declare const SEARCH_HIGHLIGHT = "workspace-search";
+declare const ACTIVE_HIGHLIGHT = "workspace-search-active";
+interface TextSearchOptions {
+  /** The node whose text is searched — the body of a same-origin iframe, say. `null` when there is nothing to search. */
+  root: Signal<Node | null>;
+  query: Signal<string>;
+  /** How long the query must stay unchanged before the text is searched, in ms. */
+  debounce?: number;
+}
+interface TextSearch {
+  /** How many occurrences there are. */
+  readonly matches: Signal<number>;
+  /** The occurrence in focus (0-based), or -1 when there is none. */
+  readonly activeIndex: Signal<number>;
+  /** Whether the browser can paint the matches (the CSS Custom Highlight API); when it cannot, they are still counted and scrolled to. */
+  readonly highlighting: Signal<boolean>;
+  /** Moves to the next occurrence, wrapping round. */
+  next(): void;
+  previous(): void;
+}
+/**
+ * Find-in-text over a document you do not render through Angular, painted with the
+ * CSS Custom Highlight API: the text is never touched, the matches are ranges the
+ * browser draws.
+ *
+ * It follows the query (debounced) and the root: a new root is searched again, and
+ * whatever was painted on the old one is taken back. Without the API (older
+ * browsers) the occurrences are still counted and scrolled to.
+ *
+ * Must be called from an injection context (a component field initializer).
+ */
+export declare function injectTextSearch({ root, query, debounce }: TextSearchOptions): TextSearch;
+/** `editor`: the workspaces you can change (creator or owner); `reader`: those shared with you read-only. */
+type WorkspaceTab = "all" | "editor" | "reader";
+interface WorkspaceTabCounts {
+  all: number;
+  editor: number;
+  reader: number;
+}
+/**
+ * The workspace list's tab and search box, and the list they produce.
+ *
+ * The tab badges count the whole list: typing in the search box narrows what is
+ * shown, not the numbers next to the tabs.
+ *
+ * Must be called from an injection context (a component field initializer).
+ */
+export declare function injectWorkspaceFilter(workspaces: Signal<readonly Workspace[]>): {
+  tab: import("@angular/core").WritableSignal<WorkspaceTab>;
+  query: import("@angular/core").WritableSignal<string>;
+  counts: Signal<WorkspaceTabCounts>;
+  filtered: Signal<Workspace[]>;
+  clearQuery: () => void;
+};
+/**
+ * A text with what a search matched marked, ignoring case and accents.
+ *
+ * Rendered chunk by chunk through Angular's own escaping: the text is a user's
+ * workspace or document name, and interpolating it into markup would execute
+ * anything HTML-ish it contains. The template is on one line on purpose, so no
+ * whitespace sneaks in between the chunks.
+ */
+export declare class HighlightedText {
+  readonly text: import("@angular/core").InputSignal<string>;
+  readonly query: import("@angular/core").InputSignal<string>;
+  protected readonly chunks: import("@angular/core").Signal<TextChunk[]>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HighlightedText, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HighlightedText, "highlighted-text", never, {
+    "text": {
+      "alias": "text";
+      "required": true;
+      "isSignal": true;
+    };
+    "query": {
+      "alias": "query";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/** What the workspace is to you: yours ("Owner", for a creator or owner) or shared with you ("Shared"). */
+export declare class WorkspaceRoleTag {
+  readonly role: import("@angular/core").InputSignal<WorkspaceRole>;
+  protected readonly owned: import("@angular/core").Signal<boolean>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<WorkspaceRoleTag, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<WorkspaceRoleTag, "workspace-role-tag", never, {
+    "role": {
+      "alias": "role";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Either a translation key (under the `documentWorkspaces` scope) or text to
+ * show verbatim. The split keeps this module free of any translation engine:
+ * the view passes `key` to the `transloco` pipe and prints `text` as is.
+ */
+type WorkspaceErrorMessage = {
+  key: string;
+} | {
+  text: string;
+};
+/**
+ * Maps a caught error to the message shown in an inline error banner.
+ *
+ * Only the statuses we recognise get a catalog entry. The default branch
+ * deliberately passes the server's own prose through untranslated (a 409
+ * `container_locked` has no dedicated error class and its message is already
+ * human-readable): localizing the rest would need the API to return stable
+ * error codes instead of English sentences.
+ *
+ * @param err - The caught value, of any type.
+ */
+declare function workspaceErrorMessage(err: unknown): WorkspaceErrorMessage;
+interface ConfirmDialogConfig {
+  /** Already translated. */
+  title: string;
+  /** Already translated, with the subject interpolated. */
+  description?: string;
+  /** A substring of `description` to emphasise — typically the name of what is about to be deleted. */
+  emphasis?: string;
+  /** Already translated. Defaults to "Delete" when `destructive`, "Save" otherwise. */
+  confirmLabel?: string;
+  /** Already translated; shown on the confirm button while `action` runs. Defaults to "Deleting…" when `destructive`. */
+  busyLabel?: string;
+  /** Already translated. Defaults to "Cancel". */
+  cancelLabel?: string;
+  /** Styles the confirm button as a destructive action. */
+  destructive?: boolean;
+  /**
+   * What confirming does. While it runs the dialog cannot be dismissed (Cancel,
+   * Escape), so a request cannot be abandoned half-way through; if it rejects,
+   * the dialog stays open with the error so it can be retried. Without it,
+   * confirming just closes the dialog with `dialog-confirm`.
+   */
+  action?: () => Promise<unknown>;
+}
+/** Text to print as is, or a key of the `documentWorkspaces` scope to translate. */
+type Label = {
+  key: string;
+} | {
+  text: string;
+};
+/**
+ * The one confirmation dialog — "delete these workspaces?", "delete this
+ * document?" — instead of a modal per use.
+ *
+ * ```ts
+ * const result = await ConfirmAction.call({
+ *   title, description, emphasis: name, destructive: true,
+ *   action: () => store.remove([id])
+ * });
+ * if (result === "dialog-confirm") …
+ * ```
+ *
+ * Resolves `dialog-confirm` once the action succeeded, `dialog-cancel` otherwise.
+ */
+export declare class ConfirmDialog {
+  protected readonly call: import("@sinequa/galactik").CallRef<ConfirmDialogConfig, DialogResult>;
+  private readonly dialog;
+  protected readonly config: import("@angular/core").Signal<ConfirmDialogConfig>;
+  protected readonly busy: import("@angular/core").WritableSignal<boolean>;
+  protected readonly error: import("@angular/core").WritableSignal<WorkspaceErrorMessage | null>;
+  protected readonly descriptionChunks: import("@angular/core").Signal<TextChunk[]>;
+  protected readonly cancelLabel: import("@angular/core").Signal<Label>;
+  protected readonly confirmLabel: import("@angular/core").Signal<Label>;
+  constructor();
+  protected confirm(): Promise<void>;
+  /** Escape on a native <dialog> closes it: refuse while the action is running. */
+  protected onNativeCancel(event: Event): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmDialog, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<ConfirmDialog, "workspace-confirm-dialog", never, {}, {}, never, never, true, never>;
+}
+/** Imperative entry point: `await ConfirmAction.call({ title, destructive: true, action })`. */
+export declare const ConfirmAction: import("@sinequa/galactik").Callable<ConfirmDialogConfig, DialogResult>;
+/**
+ * The badge of a document that is not finished: "1/2 Uploading", "2/2 Indexing"
+ * (with animated dots while it moves) or "Upload failed". Renders nothing for a
+ * document that is indexed, or whose state is not known: the card shows its date.
+ */
+export declare class DocumentStatusBadge {
+  /** `null` or absent once the document is indexed. */
+  readonly status: import("@angular/core").InputSignal<DocumentStatus | null | undefined>;
+  protected readonly message: import("@angular/core").Signal<Message | null>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<DocumentStatusBadge, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<DocumentStatusBadge, "document-status-badge", never, {
+    "status": {
+      "alias": "status";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/** The icon of a document, on a tile tinted by the family `getDocumentType()` puts its file name in. */
+export declare class DocumentTypeIcon {
+  readonly type: import("@angular/core").InputSignal<DocumentType>;
+  /** `lg` (36px) on a card, `md` (32px) in a row. */
+  readonly size: import("@angular/core").InputSignal<"md" | "lg">;
+  protected readonly classes: import("@angular/core").Signal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<DocumentTypeIcon, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<DocumentTypeIcon, "document-type-icon", never, {
+    "type": {
+      "alias": "type";
+      "required": true;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/** Prints a {@link Message}: its text as is, or its key translated. */
+export declare class WorkspaceMessage {
+  readonly message: import("@angular/core").InputSignal<Message>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<WorkspaceMessage, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<WorkspaceMessage, "workspace-message", never, {
+    "message": {
+      "alias": "message";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/** A workspace's folder on a tile tinted with the accent derived from its id (see `workspaceColorFor()`). */
+export declare class WorkspaceIcon {
+  readonly color: import("@angular/core").InputSignal<WorkspaceColor>;
+  /** `lg` (38px) on a card, `md` (32px) in a row. */
+  readonly size: import("@angular/core").InputSignal<"md" | "lg">;
+  protected readonly classes: import("@angular/core").Signal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<WorkspaceIcon, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<WorkspaceIcon, "workspace-icon", never, {
+    "color": {
+      "alias": "color";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+interface UploadDialogConfig {
+  /** The workspace the files go to. */
+  workspace: Pick<Workspace, "id" | "name" | "currentUserRole">;
+  /** The tus endpoint — the host's `upload-endpoint`. */
+  endpoint: string;
+}
+/**
+ * "Upload Documents": stage files by dropping or picking them, then send them all
+ * as one batch.
+ *
+ * Staging only — nothing leaves the browser until Upload is pressed, so the whole
+ * selection goes out as ONE ingest job instead of each drop starting its own.
+ * Dismissing the dialog any other way discards the selection: nothing was sent,
+ * so there is nothing to keep.
+ *
+ * ```ts
+ * await UploadDocuments.call({ workspace, endpoint });
+ * ```
+ *
+ * Refuses to open for someone who cannot write to the workspace: the Upload
+ * button is hidden for them, this is the belt to that braces.
+ */
+export declare class UploadDialog {
+  protected readonly call: import("@sinequa/galactik").CallRef<UploadDialogConfig, DialogResult>;
+  private readonly dialog;
+  private readonly uploads;
+  protected readonly files: import("@angular/core").WritableSignal<File[]>;
+  /** Whether there is anything to send. */
+  protected readonly ready: import("@angular/core").Signal<boolean>;
+  constructor();
+  /**
+   * Adds files to the staged selection. No gatekeeping here either: no type, count
+   * or size check. Same-name files are still collapsed, and for a hard reason: a
+   * document is addressed as `<jobId>/<fileName>`, so two files sharing a name
+   * inside one job would collide on the server, not just in the list.
+   */
+  protected stage(files: File[]): void;
+  protected upload(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<UploadDialog, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<UploadDialog, "upload-dialog", never, {}, {}, never, never, true, never>;
+}
+/** Imperative entry point: `await UploadDocuments.call({ workspace, endpoint })`. */
+export declare const UploadDocuments: import("@sinequa/galactik").Callable<UploadDialogConfig, DialogResult>;
+/** The files staged for upload, before anything is sent. */
+export declare class UploadFileList {
+  readonly files: import("@angular/core").InputSignal<readonly File[]>;
+  protected typeOf(file: File): import("@sinequa/atomic-angular/document-workspaces").DocumentType;
+  static ɵfac: i0.ɵɵFactoryDeclaration<UploadFileList, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<UploadFileList, "upload-file-list", never, {
+    "files": {
+      "alias": "files";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * What the tracker says when the connection or the session is in trouble: what
+ * happened, what is being done about it, and a countdown.
+ *
+ * It exists only while there is something to say, so its one-second clock only
+ * runs then.
+ */
+export declare class ConnectionBanner {
+  readonly notice: import("@angular/core").InputSignal<ConnectionNotice>;
+  /** The Retry button was pressed — offered once signed out, when the user can act. */
+  readonly retry: import("@angular/core").OutputEmitterRef<void>;
+  protected readonly retryLabel: Message;
+  private readonly now;
+  constructor();
+  protected readonly title: import("@angular/core").Signal<Message>;
+  protected readonly detail: import("@angular/core").Signal<Message>;
+  /** "Next try in 0:03 · lost 0:12 ago · gives up in 4:40", the parts that apply. */
+  protected readonly countdown: import("@angular/core").Signal<Message[]>;
+  protected readonly showRetry: import("@angular/core").Signal<boolean>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ConnectionBanner, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<ConnectionBanner, "connection-banner", never, {
+    "notice": {
+      "alias": "notice";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {
+    "retry": "retry";
+  }, never, never, true, never>;
+}
+/**
+ * - `inline`: a compact header and a line of counters;
+ * - `expanded`: the files, section by section, workspace by workspace;
+ * - `minimized`: slid down to the corner, only a strip showing; it still reports what happens, and slides back when hovered.
+ */
+type Mode = "inline" | "expanded" | "minimized";
+type Tone = "normal" | "flash" | "success";
+interface TrackedWorkspace {
+  id: string;
+  name: string;
+}
+/**
+ * The floating panel that follows files from the first byte sent to the end of
+ * indexing: what is moving, what is done, what failed and why, and what can be
+ * done about it (cancel a transfer, retry a failed one, dismiss a finished one).
+ *
+ * It only reads `UploadTrackerStore` — the state — and asks `UploadService` to
+ * act. It shows itself when files are tracked and, once every file is indexed
+ * without a failure, celebrates and dismisses itself.
+ *
+ * The moments that pass by themselves (a file just finished, a workspace just
+ * completed, a connection just dropped) are noticed from changes in the store,
+ * so they work the same whether `UploadService` or a demo page drives it.
+ */
+export declare class UploadTracker {
+  protected readonly store: {
+    uploads: import("@angular/core").Signal<TrackedUpload[]>;
+    workspaces: import("@angular/core").Signal<import("@sinequa/atomic-angular/document-workspaces").TrackerWorkspace[]>;
+    connection: import("@ngrx/signals").DeepSignal<import("@sinequa/atomic-angular/document-workspaces").ConnectionNotice> | import("@angular/core").Signal<null>;
+    clearedCount: import("@angular/core").Signal<number>;
+    jobIndexing: import("@angular/core").Signal<Record<string, number>>;
+    ignoredJobs: import("@angular/core").Signal<Record<string, true>>;
+    active: import("@angular/core").Signal<boolean>;
+    failed: import("@angular/core").Signal<TrackedUpload[]>;
+    byStatus: import("@angular/core").Signal<Record<UploadStatus, TrackedUpload[]>>;
+    allDone: import("@angular/core").Signal<boolean>;
+    settled: import("@angular/core").Signal<boolean>;
+    authorFailed: import("@angular/core").Signal<boolean>;
+    progress: import("@angular/core").Signal<Record<string, PhaseProgress>>;
+    indexedCount: import("@angular/core").Signal<number>;
+    track: (files: import("@sinequa/atomic-angular/document-workspaces").TrackFileInput[], workspaceId: string, workspaceName: string) => void;
+    setProgress: (id: string, percent: number) => void;
+    setIndexing: (id: string) => void;
+    setDone: (id: string) => void;
+    setError: (id: string, options?: {
+      message?: string;
+      retryable?: boolean;
+    }) => void;
+    restart: (id: string) => void;
+    applyJobs: (jobs: import("@sinequa/atomic").UploadJobStatus[]) => boolean;
+    applyRemoteJobs: (entries: RemoteJobEntry[]) => boolean;
+    setConnection: (connection: import("@sinequa/atomic-angular/document-workspaces").ConnectionNotice | null) => void;
+    remove: (id: string) => void;
+    removeWorkspace: (workspaceId: string) => void;
+    reset: () => void;
+  } & import("@ngrx/signals").StateSource<{
+    uploads: TrackedUpload[];
+    workspaces: import("@sinequa/atomic-angular/document-workspaces").TrackerWorkspace[];
+    connection: import("@sinequa/atomic-angular/document-workspaces").ConnectionNotice | null;
+    clearedCount: number;
+    jobIndexing: Record<string, number>;
+    ignoredJobs: Record<string, true>;
+  }>;
+  private readonly service;
+  protected readonly mode: import("@angular/core").WritableSignal<Mode>;
+  protected readonly workspaceIndex: import("@angular/core").WritableSignal<number>;
+  /** Sections the user folded, keyed `<workspaceId>:<status>`; open by default. */
+  private readonly folded;
+  /** What has just happened, shown for a moment where the file count usually is. */
+  private readonly flash;
+  /** The same for a minimized panel, which has nowhere else to say it. */
+  private readonly peek;
+  protected readonly completingWorkspace: import("@angular/core").WritableSignal<TrackedWorkspace | null>;
+  protected readonly dismissing: import("@angular/core").WritableSignal<boolean>;
+  /** The pointer is over a minimized panel: it slides back up, to be clicked open. */
+  private readonly hover;
+  /** The panel is on its way down to the corner: quicker than the way back. */
+  protected readonly minimizing: import("@angular/core").WritableSignal<boolean>;
+  /** What the strip of a minimized panel shows, which is not always what it should: a change swaps it. */
+  protected readonly peekShown: import("@angular/core").WritableSignal<Message>;
+  protected readonly peekTone: import("@angular/core").WritableSignal<"error" | "success" | null>;
+  protected readonly peekSwap: import("@angular/core").WritableSignal<"shown" | "hidden" | "below">;
+  private peekKey;
+  private hoverTimer;
+  private readonly timers;
+  private flashTimer;
+  private peekTimer;
+  private peekTimer2;
+  private dismissTimer;
+  private completeTimer;
+  /** Status of each file as of the last change, to tell what just finished from what already had. */
+  private previous;
+  private previousPhase;
+  protected readonly currentIndex: import("@angular/core").Signal<number>;
+  protected readonly currentWorkspace: import("@angular/core").Signal<TrackedWorkspace | null>;
+  protected readonly sections: import("@angular/core").Signal<{
+    status: UploadStatus;
+    uploads: TrackedUpload[];
+    progress: number | undefined;
+  }[]>;
+  protected readonly header: import("@angular/core").Signal<{
+    title: Message;
+    subtitle: Message;
+    tone: Tone;
+  }>;
+  /** The counters of the compact view: what moves, what finished, what failed. */
+  protected readonly chips: import("@angular/core").Signal<{
+    kind: string;
+    message: Message;
+    busy: boolean;
+  }[]>;
+  /** What the minimized pill says: a notification while there is one, otherwise a summary. */
+  protected readonly pillMessage: import("@angular/core").Signal<Message>;
+  protected readonly state: import("@angular/core").Signal<"minimized" | "normal" | "minimized-hover">;
+  /** The strip's own colour: the failure, or the success, that stands. */
+  protected readonly peekKind: import("@angular/core").Signal<"done" | "errors" | null>;
+  protected readonly canRetryAll: import("@angular/core").Signal<boolean>;
+  constructor();
+  protected restore(): void;
+  protected onPanelClick(): void;
+  protected onPointerEnter(): void;
+  protected onPointerLeave(): void;
+  protected onTransitionEnd(event: TransitionEvent): void;
+  private clearHover;
+  protected toggleExpanded(): void;
+  /** Minimizes while there is work going on; once everything is over (failures included), closes for good. */
+  protected dismiss(): void;
+  protected moveWorkspace(step: -1 | 1): void;
+  protected isOpen(status: UploadStatus): boolean;
+  protected toggleSection(status: UploadStatus): void;
+  /**
+   * Cancels a transfer in progress, or drops a row that is over. Only the
+   * service knows the transfers it can still act on; a row it does not know
+   * (finished, or failed on the server) is simply taken off the list.
+   */
+  protected discard(id: string): Promise<void>;
+  protected retry(id: string): void;
+  protected retryAll(): void;
+  private onUploadsChanged;
+  /**
+   * Puts `message` on the strip: the old text leaves upward, the new one comes up from below.
+   * The first text is simply there, and what is already shown is left alone.
+   */
+  private syncPeek;
+  private showFlash;
+  private notify;
+  private completeWorkspace;
+  private startAutoDismiss;
+  private cancelAutoDismiss;
+  private reset;
+  private sectionKey;
+  /** Replaces a pending timer with a new one, all cleared together when the panel is destroyed. */
+  private replaceTimer;
+  static ɵfac: i0.ɵɵFactoryDeclaration<UploadTracker, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<UploadTracker, "upload-tracker", never, {}, {}, never, never, true, never>;
+}
+interface SectionConfig {
+  titleKey: string;
+  /** Shows the average progress as a bar, and animated dots next to the title. */
+  progress: boolean;
+  /** Can be folded away — only the two sections that move. */
+  foldable: boolean;
+}
+/**
+ * The files of one status, for one workspace, in the tracker's expanded body:
+ * a title, an average progress bar while they move, and a row per file with what
+ * can be done to it.
+ *
+ * The files fold away and open again, and the bar follows the progress, with a
+ * transition rather than a jump.
+ *
+ * It only reports what the user asked for; `UploadTracker` does it.
+ */
+export declare class UploadTrackerSection {
+  readonly status: import("@angular/core").InputSignal<UploadStatus>;
+  readonly uploads: import("@angular/core").InputSignal<readonly TrackedUpload[]>;
+  readonly open: import("@angular/core").InputSignal<boolean>;
+  /** The phase's overall progress, when the tracker knows better than the mean of the files listed here (those that moved on are not). */
+  readonly progress: import("@angular/core").InputSignal<number | undefined>;
+  readonly toggle: import("@angular/core").OutputEmitterRef<void>;
+  /** Cancel an upload in progress, or dismiss a finished row. The tracker tells the two apart. */
+  readonly discard: import("@angular/core").OutputEmitterRef<string>;
+  readonly retry: import("@angular/core").OutputEmitterRef<string>;
+  protected readonly config: import("@angular/core").Signal<SectionConfig>;
+  /** A failure, or a file the server will not index: both are in the error colours. */
+  protected readonly failed: import("@angular/core").Signal<boolean>;
+  /** The bar: the phase's overall progress, or else the mean progress of the files in the section. */
+  protected readonly average: import("@angular/core").Signal<number>;
+  /** The translation key standing for a row with no file name: a job started elsewhere. Only read when `name` is empty. */
+  protected label(upload: TrackedUpload): string;
+  protected round(value: number): number;
+  static ɵfac: i0.ɵɵFactoryDeclaration<UploadTrackerSection, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<UploadTrackerSection, "upload-tracker-section", never, {
+    "status": {
+      "alias": "status";
+      "required": true;
+      "isSignal": true;
+    };
+    "uploads": {
+      "alias": "uploads";
+      "required": true;
+      "isSignal": true;
+    };
+    "open": {
+      "alias": "open";
+      "required": false;
+      "isSignal": true;
+    };
+    "progress": {
+      "alias": "progress";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "toggle": "toggle";
+    "discard": "discard";
+    "retry": "retry";
+  }, never, never, true, never>;
+}
+type ViewMode$1 = "grid" | "list";
+/**
+ * The home of the workspaces view: every workspace you can reach, as a grid or a
+ * list, filtered by tab and by search, with multi-selection and deletion.
+ *
+ * It reads `WorkspacesStore` and does not know how a workspace is opened or
+ * created — it says so (`opened`, `createRequested`) and whoever hosts it decides.
+ *
+ * Each time it is shown it refreshes: workspaces created by others since the last
+ * time appear, and the document counts match the server. The list already on
+ * screen stays until the answer lands, and a failure leaves it untouched behind
+ * an inline error. While it stays shown, it keeps polling in the background
+ * (`injectLiveRefresh`) so a workspace created by someone else — one the current
+ * user only reads, say — appears on its own, with no action needed.
+ */
+export declare class WorkspaceList {
+  /** A workspace was chosen for opening. */
+  readonly opened: import("@angular/core").OutputEmitterRef<Workspace>;
+  /** The user wants a new workspace. Creating one is the host's dialog. */
+  readonly createRequested: import("@angular/core").OutputEmitterRef<void>;
+  protected readonly store: {
+    workspaces: import("@angular/core").Signal<Workspace[]>;
+    loaded: import("@angular/core").Signal<boolean>;
+    loading: import("@angular/core").Signal<boolean>;
+    pagination: import("@ngrx/signals").DeepSignal<import("@sinequa/atomic-angular/document-workspaces").Pagination>;
+    documents: import("@angular/core").Signal<Record<string, import("@sinequa/atomic-angular/document-workspaces").WorkspaceDocument[]>>;
+    documentPagination: import("@angular/core").Signal<Record<string, import("@sinequa/atomic-angular/document-workspaces").Pagination>>;
+    selectedIds: import("@angular/core").Signal<string[]>;
+    hasMore: import("@angular/core").Signal<boolean>;
+    truncated: import("@angular/core").Signal<boolean>;
+    selectedCount: import("@angular/core").Signal<number>;
+    selectedIdSet: import("@angular/core").Signal<Set<string>>;
+    workspace: (id: string) => Workspace | undefined;
+    documentsOf: (workspaceId: string) => import("@sinequa/atomic-angular/document-workspaces").WorkspaceDocument[];
+    hasMoreDocuments: (workspaceId: string) => boolean;
+    ensureLoaded: () => Promise<Workspace[]>;
+    reload: () => Promise<Workspace[]>;
+    loadMore: () => Promise<Workspace[]>;
+    fetch: (id: string) => Promise<Workspace>;
+    create: ({ name, description, tags, owners, readers }: import("@sinequa/atomic-angular/document-workspaces").CreateWorkspaceInput) => Promise<Workspace>;
+    update: (id: string, patch: import("@sinequa/atomic").UpdateContainerInput) => Promise<Workspace | null>;
+    remove: (ids: string[]) => Promise<import("@sinequa/atomic-angular/document-workspaces").RemoveWorkspacesResult>;
+    forget: (id: string) => void;
+    loadDocuments: (workspaceId: string, signal?: AbortSignal) => Promise<import("@sinequa/atomic-angular/document-workspaces").WorkspaceDocument[]>;
+    loadMoreDocuments: (workspaceId: string) => Promise<import("@sinequa/atomic-angular/document-workspaces").WorkspaceDocument[]>;
+    addDocuments: (workspaceId: string, documents: import("@sinequa/atomic-angular/document-workspaces").WorkspaceDocument[]) => void;
+    discardDocuments: (workspaceId: string, documentIds: string[]) => void;
+    patchDocument: (workspaceId: string, documentId: string, patch: Partial<import("@sinequa/atomic-angular/document-workspaces").WorkspaceDocument>) => void;
+    saveDocuments: (workspaceId: string, documents: Pick<import("@sinequa/atomic-angular/document-workspaces").WorkspaceDocument, "name">[]) => Promise<import("@sinequa/atomic-angular/document-workspaces").WorkspaceDocument[]>;
+    removeDocuments: (workspaceId: string, documentIds: string[]) => Promise<void>;
+    moveDocuments: (fromWorkspaceId: string, toWorkspaceId: string, documentIds: string[]) => Promise<void>;
+    toggleSelected: (id: string, checked: boolean) => void;
+    clearSelection: () => void;
+  } & import("@ngrx/signals").StateSource<{
+    workspaces: Workspace[];
+    loaded: boolean;
+    loading: boolean;
+    pagination: import("@sinequa/atomic-angular/document-workspaces").Pagination;
+    documents: Record<string, import("@sinequa/atomic-angular/document-workspaces").WorkspaceDocument[]>;
+    documentPagination: Record<string, import("@sinequa/atomic-angular/document-workspaces").Pagination>;
+    selectedIds: string[];
+  }>;
+  private readonly uploads;
+  private readonly injector;
+  private readonly transloco;
+  protected readonly tabs: readonly {
+    tab: WorkspaceTab;
+    labelKey: string;
+  }[];
+  protected readonly viewMode: import("@angular/core").WritableSignal<ViewMode$1>;
+  protected readonly status: import("@angular/core").WritableSignal<"error" | "loading" | "ready">;
+  protected readonly loadError: import("@angular/core").WritableSignal<Message | null>;
+  protected readonly refreshError: import("@angular/core").WritableSignal<string | null>;
+  protected readonly loadingMore: import("@angular/core").WritableSignal<boolean>;
+  protected readonly loadMoreError: import("@angular/core").WritableSignal<string | null>;
+  protected readonly filter: {
+    tab: import("@angular/core").WritableSignal<WorkspaceTab>;
+    query: import("@angular/core").WritableSignal<string>;
+    counts: import("@angular/core").Signal<import("@sinequa/atomic-angular/document-workspaces").WorkspaceTabCounts>;
+    filtered: import("@angular/core").Signal<Workspace[]>;
+    clearQuery: () => void;
+  };
+  /** The search box, bound to the filter's own query signal. */
+  protected readonly searchForm: import("@angular/forms/signals").FieldTree<string, string | number, "writable">;
+  protected readonly selection: import("@sinequa/atomic-angular/document-workspaces").Selection<Workspace>;
+  private readonly liveRefresh;
+  constructor();
+  /** Shows what is cached at once and refreshes behind it, or loads for the first time. */
+  protected load(): Promise<void>;
+  private refresh;
+  protected loadMore(): Promise<void>;
+  protected onTabChange(tab: string | undefined): void;
+  protected deleteSelected(): void;
+  /**
+   * Asks, then deletes. The API only has a bulk DELETE, so one workspace is a
+   * one-element batch. If some could not be deleted the dialog stays open and says
+   * which, and a retry only targets those, so it does not re-attempt ones already gone.
+   */
+  protected confirmDelete(targets: Workspace[]): Promise<void>;
+  private translate;
+  static ɵfac: i0.ɵɵFactoryDeclaration<WorkspaceList, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<WorkspaceList, "workspace-list", never, {}, {
+    "opened": "opened";
+    "createRequested": "createRequested";
+  }, never, never, true, never>;
+}
+/**
+ * A workspace in the grid.
+ *
+ * It only reports what the user asked for — open it, delete it, tick it — and
+ * leaves doing it to the list. Opening is on the title, a real button, so the
+ * keyboard reaches it; the whole card is clickable as a convenience for the pointer.
+ */
+export declare class WorkspaceCard {
+  readonly workspace: import("@angular/core").InputSignal<Workspace>;
+  /** The search box's text, to mark in the name. */
+  readonly query: import("@angular/core").InputSignal<string>;
+  /** The list is in selection mode: checkboxes show, and a click ticks instead of opening. */
+  readonly selecting: import("@angular/core").InputSignal<boolean>;
+  readonly selected: import("@angular/core").InputSignal<boolean>;
+  /** Whether this workspace may be ticked — not one shared read-only. */
+  readonly selectable: import("@angular/core").InputSignal<boolean>;
+  readonly opened: import("@angular/core").OutputEmitterRef<void>;
+  readonly deleteRequested: import("@angular/core").OutputEmitterRef<void>;
+  readonly selectedChange: import("@angular/core").OutputEmitterRef<boolean>;
+  /** Opens the workspace — or, in selection mode, ticks it. */
+  protected activate(): void;
+  protected onCardClick(event: MouseEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<WorkspaceCard, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<WorkspaceCard, "workspace-card", never, {
+    "workspace": {
+      "alias": "workspace";
+      "required": true;
+      "isSignal": true;
+    };
+    "query": {
+      "alias": "query";
+      "required": false;
+      "isSignal": true;
+    };
+    "selecting": {
+      "alias": "selecting";
+      "required": false;
+      "isSignal": true;
+    };
+    "selected": {
+      "alias": "selected";
+      "required": false;
+      "isSignal": true;
+    };
+    "selectable": {
+      "alias": "selectable";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "opened": "opened";
+    "deleteRequested": "deleteRequested";
+    "selectedChange": "selectedChange";
+  }, never, never, true, never>;
+}
+/**
+ * The columns of the list view — the header and every row share it.
+ * Written out in full: Tailwind only generates the classes it can read as literals.
+ */
+export declare const WORKSPACE_ROW_COLUMNS = "grid grid-cols-[minmax(0,1fr)_auto_auto_2.5rem] items-center gap-x-4 px-3 data-selecting:grid-cols-[2rem_minmax(0,1fr)_auto_auto_2.5rem] @xl:grid-cols-[minmax(0,1fr)_4.5rem_6.5rem_6.5rem_2.5rem] @xl:data-selecting:grid-cols-[2rem_minmax(0,1fr)_4.5rem_6.5rem_6.5rem_2.5rem] @3xl:grid-cols-[minmax(0,2fr)_5.5rem_7.5rem_9rem_minmax(5rem,1fr)_2.5rem] @3xl:data-selecting:grid-cols-[2rem_minmax(0,2fr)_5.5rem_7.5rem_9rem_minmax(5rem,1fr)_2.5rem]";
+/** A workspace in the list view. Same contract as {@link WorkspaceCard}. */
+export declare class WorkspaceRow {
+  readonly workspace: import("@angular/core").InputSignal<Workspace>;
+  readonly query: import("@angular/core").InputSignal<string>;
+  readonly selecting: import("@angular/core").InputSignal<boolean>;
+  readonly selected: import("@angular/core").InputSignal<boolean>;
+  readonly selectable: import("@angular/core").InputSignal<boolean>;
+  readonly opened: import("@angular/core").OutputEmitterRef<void>;
+  readonly deleteRequested: import("@angular/core").OutputEmitterRef<void>;
+  readonly selectedChange: import("@angular/core").OutputEmitterRef<boolean>;
+  protected activate(): void;
+  protected onRowClick(event: MouseEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<WorkspaceRow, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<WorkspaceRow, "workspace-row", never, {
+    "workspace": {
+      "alias": "workspace";
+      "required": true;
+      "isSignal": true;
+    };
+    "query": {
+      "alias": "query";
+      "required": false;
+      "isSignal": true;
+    };
+    "selecting": {
+      "alias": "selecting";
+      "required": false;
+      "isSignal": true;
+    };
+    "selected": {
+      "alias": "selected";
+      "required": false;
+      "isSignal": true;
+    };
+    "selectable": {
+      "alias": "selectable";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "opened": "opened";
+    "deleteRequested": "deleteRequested";
+    "selectedChange": "selectedChange";
+  }, never, never, true, never>;
+}
+/**
+ * A document in the grid.
+ *
+ * Like `WorkspaceCard` it only reports what the user asked for — open it,
+ * delete it, tick it — and leaves doing it to the detail view. The name is a real
+ * button so the keyboard reaches it; the whole card is clickable for the pointer.
+ */
+export declare class DocumentCard {
+  readonly document: import("@angular/core").InputSignal<WorkspaceDocument>;
+  /** The role of the current user in the workspace — the delete button is for writers. */
+  readonly workspaceRole: import("@angular/core").InputSignal<WorkspaceRole | null | undefined>;
+  /** The search box's text, to mark in the name. */
+  readonly query: import("@angular/core").InputSignal<string>;
+  /** The one open in the preview. */
+  readonly active: import("@angular/core").InputSignal<boolean>;
+  readonly selecting: import("@angular/core").InputSignal<boolean>;
+  readonly selected: import("@angular/core").InputSignal<boolean>;
+  readonly selectable: import("@angular/core").InputSignal<boolean>;
+  readonly opened: import("@angular/core").OutputEmitterRef<void>;
+  readonly deleteRequested: import("@angular/core").OutputEmitterRef<void>;
+  readonly selectedChange: import("@angular/core").OutputEmitterRef<boolean>;
+  protected readonly labels: import("@sinequa/atomic-angular/document-workspaces").DocumentLabels;
+  /** Opens the document — or, in selection mode, ticks it. */
+  protected activate(): void;
+  protected onCardClick(event: MouseEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<DocumentCard, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<DocumentCard, "document-card", never, {
+    "document": {
+      "alias": "document";
+      "required": true;
+      "isSignal": true;
+    };
+    "workspaceRole": {
+      "alias": "workspaceRole";
+      "required": true;
+      "isSignal": true;
+    };
+    "query": {
+      "alias": "query";
+      "required": false;
+      "isSignal": true;
+    };
+    "active": {
+      "alias": "active";
+      "required": false;
+      "isSignal": true;
+    };
+    "selecting": {
+      "alias": "selecting";
+      "required": false;
+      "isSignal": true;
+    };
+    "selected": {
+      "alias": "selected";
+      "required": false;
+      "isSignal": true;
+    };
+    "selectable": {
+      "alias": "selectable";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "opened": "opened";
+    "deleteRequested": "deleteRequested";
+    "selectedChange": "selectedChange";
+  }, never, never, true, never>;
+}
+/**
+ * The columns of the document list — the header and every row share it.
+ * Written out in full: Tailwind only generates the classes it can read as literals.
+ */
+export declare const DOCUMENT_ROW_COLUMNS = "grid grid-cols-[minmax(0,1fr)_auto_2.5rem] items-center gap-x-4 px-3 data-selecting:grid-cols-[2rem_minmax(0,1fr)_auto_2.5rem] @3xl:grid-cols-[minmax(0,2fr)_minmax(0,1fr)_6rem_10rem_2.5rem] @3xl:data-selecting:grid-cols-[2rem_minmax(0,2fr)_minmax(0,1fr)_6rem_10rem_2.5rem]";
+/** A document in the list view. Same contract as `DocumentCard`. */
+export declare class DocumentRow {
+  readonly document: import("@angular/core").InputSignal<WorkspaceDocument>;
+  readonly workspaceRole: import("@angular/core").InputSignal<WorkspaceRole | null | undefined>;
+  readonly query: import("@angular/core").InputSignal<string>;
+  readonly active: import("@angular/core").InputSignal<boolean>;
+  readonly selecting: import("@angular/core").InputSignal<boolean>;
+  readonly selected: import("@angular/core").InputSignal<boolean>;
+  readonly selectable: import("@angular/core").InputSignal<boolean>;
+  readonly opened: import("@angular/core").OutputEmitterRef<void>;
+  readonly deleteRequested: import("@angular/core").OutputEmitterRef<void>;
+  readonly selectedChange: import("@angular/core").OutputEmitterRef<boolean>;
+  protected readonly labels: import("@sinequa/atomic-angular/document-workspaces").DocumentLabels;
+  protected activate(): void;
+  protected onRowClick(event: MouseEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<DocumentRow, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<DocumentRow, "document-row", never, {
+    "document": {
+      "alias": "document";
+      "required": true;
+      "isSignal": true;
+    };
+    "workspaceRole": {
+      "alias": "workspaceRole";
+      "required": true;
+      "isSignal": true;
+    };
+    "query": {
+      "alias": "query";
+      "required": false;
+      "isSignal": true;
+    };
+    "active": {
+      "alias": "active";
+      "required": false;
+      "isSignal": true;
+    };
+    "selecting": {
+      "alias": "selecting";
+      "required": false;
+      "isSignal": true;
+    };
+    "selected": {
+      "alias": "selected";
+      "required": false;
+      "isSignal": true;
+    };
+    "selectable": {
+      "alias": "selectable";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "opened": "opened";
+    "deleteRequested": "deleteRequested";
+    "selectedChange": "selectedChange";
+  }, never, never, true, never>;
+}
+/**
+ * One person of the access list.
+ *
+ * Two rows never get a role menu: the creator's (immutable for the API) and your own
+ * (an owner who demotes or removes themselves loses the workspace with no way back).
+ * Removing asks first, inline in the row.
+ */
+export declare class MemberRow {
+  readonly member: import("@angular/core").InputSignal<Member>;
+  /** A change is in flight: nothing else can be asked meanwhile. */
+  readonly disabled: import("@angular/core").InputSignal<boolean>;
+  readonly roleChange: import("@angular/core").OutputEmitterRef<AssignableRole>;
+  readonly removed: import("@angular/core").OutputEmitterRef<void>;
+  protected readonly confirming: import("@angular/core").WritableSignal<boolean>;
+  protected readonly assignable: import("@angular/core").Signal<AssignableRole>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MemberRow, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MemberRow, "member-row", never, {
+    "member": {
+      "alias": "member";
+      "required": true;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "roleChange": "roleChange";
+    "removed": "removed";
+  }, never, never, true, never>;
+}
+/** A small round avatar: the initials of a person, a glyph for a group. */
+export declare class PrincipalAvatar {
+  readonly name: import("@angular/core").InputSignal<string>;
+  readonly group: import("@angular/core").InputSignal<boolean>;
+  protected readonly initials: import("@angular/core").Signal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<PrincipalAvatar, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<PrincipalAvatar, "principal-avatar", never, {
+    "name": {
+      "alias": "name";
+      "required": true;
+      "isSignal": true;
+    };
+    "group": {
+      "alias": "group";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Picks people: a tag-style box with search-as-you-type over the directory, a chip
+ * per person, and the role the next ones get. The picked people are the `entries`
+ * model — a parent owns them and can clear them.
+ *
+ * Groups never show up in the results: the API documents `owners`/`readers` as
+ * *user* ids, so staging a group would look like it worked and grant nobody anything.
+ *
+ * The id of an entry is the principal's `userId` (`domain|id`), which is what a
+ * workspace holds and the only form the API accepts.
+ *
+ * The search, the results popup (a combobox in the top layer, so a dialog's edges cannot clip it) and its keyboard
+ * are those of the library's `Autocomplete`: this component adds what is specific to people — the avatar in a row, the
+ * role of a chip, the role the next ones get. Like in a chat's mention box, Enter picks the first row and closes the
+ * list.
+ */
+export declare class PrincipalPicker {
+  /** The people picked so far. */
+  readonly entries: import("@angular/core").ModelSignal<PickedPrincipal[]>;
+  /** Ids to keep out of the results — the people who already have access. */
+  readonly excludeIds: import("@angular/core").InputSignal<readonly string[]>;
+  /** Chips carry a toggle to switch their role. Off where everyone picked takes the selector's role. */
+  readonly showChipRole: import("@angular/core").InputSignal<boolean>;
+  private readonly directory;
+  /** The role the next person picked gets. */
+  protected readonly role: import("@angular/core").WritableSignal<AssignableRole>;
+  /** Groups are not offered: see the class comment. */
+  protected readonly search: (query: string, { signal }: {
+    signal: AbortSignal;
+  }) => Promise<SecurityPrincipal[]>;
+  protected readonly principalKey: (person: SecurityPrincipal) => string;
+  protected readonly entryKey: (entry: PickedPrincipal) => string;
+  protected readonly entryLabel: (entry: PickedPrincipal) => string;
+  protected readonly displayName: (person: SecurityPrincipal) => string;
+  protected pick(person: SecurityPrincipal): void;
+  protected toggleRole(index: number): void;
+  protected removeEntry(entry: PickedPrincipal): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<PrincipalPicker, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<PrincipalPicker, "principal-picker", never, {
+    "entries": {
+      "alias": "entries";
+      "required": false;
+      "isSignal": true;
+    };
+    "excludeIds": {
+      "alias": "excludeIds";
+      "required": false;
+      "isSignal": true;
+    };
+    "showChipRole": {
+      "alias": "showChipRole";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "entries": "entriesChange";
+  }, never, never, true, never>;
+}
+/**
+ * "Owner ▾" / "Reader ▾": a menu to pick a role, and — for someone who already has
+ * access — to take it away.
+ *
+ * It only reports the choice; whoever uses it decides what it does.
+ */
+export declare class RoleMenu {
+  readonly role: import("@angular/core").InputSignal<AssignableRole>;
+  /** Adds "Remove" to the menu. */
+  readonly removable: import("@angular/core").InputSignal<boolean>;
+  readonly disabled: import("@angular/core").InputSignal<boolean>;
+  /** The accessible name of the button, already translated. */
+  readonly label: import("@angular/core").InputSignal<string>;
+  readonly roleChange: import("@angular/core").OutputEmitterRef<AssignableRole>;
+  readonly removeRequested: import("@angular/core").OutputEmitterRef<void>;
+  protected readonly roleKey: import("@angular/core").Signal<"documentWorkspaces.share.owner" | "documentWorkspaces.share.reader">;
+  protected onSelect(value: string): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RoleMenu, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RoleMenu, "role-menu", never, {
+    "role": {
+      "alias": "role";
+      "required": true;
+      "isSignal": true;
+    };
+    "removable": {
+      "alias": "removable";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {
+    "roleChange": "roleChange";
+    "removeRequested": "removeRequested";
+  }, never, never, true, never>;
+}
+interface ShareDialogConfig {
+  workspaceId: Workspace["id"];
+}
+/**
+ * "Manage access": who can do what in a workspace.
+ *
+ * ```ts
+ * await ShareWorkspace.call({ workspaceId });
+ * ```
+ *
+ * Every change — a role, a removal, people added — is saved at once. The list reads
+ * the workspace from `WorkspacesStore`, so it shows what the server now holds, and
+ * stays in step with a change made elsewhere. Only the ones who can write to the
+ * workspace get here; the server refuses the others anyway.
+ */
+export declare class ShareDialog {
+  protected readonly call: import("@sinequa/galactik").CallRef<ShareDialogConfig, DialogResult>;
+  private readonly dialog;
+  private readonly store;
+  private readonly directory;
+  private readonly currentUser;
+  private readonly workspaceId;
+  protected readonly workspace: import("@angular/core").Signal<Workspace | undefined>;
+  protected readonly members: import("@angular/core").Signal<import("@sinequa/atomic-angular/document-workspaces").Member[]>;
+  protected readonly memberIds: import("@angular/core").Signal<string[]>;
+  /** The people picked, not added yet. */
+  protected readonly staged: import("@angular/core").WritableSignal<PickedPrincipal[]>;
+  protected readonly adding: import("@angular/core").WritableSignal<boolean>;
+  protected readonly busy: import("@angular/core").WritableSignal<boolean>;
+  protected readonly error: import("@angular/core").WritableSignal<WorkspaceErrorMessage | null>;
+  constructor();
+  protected add(): Promise<void>;
+  protected change(id: string, role: AssignableRole | "remove"): Promise<void>;
+  /** One write at a time: the arrays it sends are built from the workspace as it is now. */
+  private save;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ShareDialog, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<ShareDialog, "share-dialog", never, {}, {}, never, never, true, never>;
+}
+/** Imperative entry point: `await ShareWorkspace.call({ workspaceId })`. */
+export declare const ShareWorkspace: import("@sinequa/galactik").Callable<ShareDialogConfig, DialogResult>;
+/** What "Ask follow-up" hands the host: what to show in its compose area, already translated. */
+interface AskFollowUp {
+  title: string;
+  type: WorkspaceDocument["type"];
+  placeholder: string;
+  suggestions: string[];
+}
+/**
+ * The preview of a document: the converted copy the preview web service points at,
+ * in a frame, with a zoom, a find-in-text and an "Ask follow-up".
+ *
+ * It asks the service for the document by id, as a search app does. Until the
+ * backend hands out the index id for an uploaded document (the listing carries
+ * the upload-side id) the service answers an error, and the panel says the document
+ * cannot be previewed rather than showing a stand-in.
+ *
+ * Finding text needs to read the frame, so it only works when the copy is served
+ * from the same origin as the page; otherwise the box is disabled and says why.
+ */
+export declare class DocumentPreviewPanel {
+  readonly document: import("@angular/core").InputSignal<WorkspaceDocument>;
+  /** The query the preview web service renders the document for — the host's `query-name`. */
+  readonly queryName: import("@angular/core").InputSignal<string>;
+  readonly closed: import("@angular/core").OutputEmitterRef<void>;
+  readonly askFollowUp: import("@angular/core").OutputEmitterRef<AskFollowUp>;
+  private readonly sanitizer;
+  private readonly transloco;
+  private readonly lang;
+  private readonly frame;
+  protected readonly zoomMin = 0.25;
+  protected readonly zoomMax = 2.5;
+  protected readonly zoom: import("@angular/core").WritableSignal<number>;
+  protected readonly status: import("@angular/core").WritableSignal<"loading" | "ready" | "unavailable">;
+  protected readonly frameUrl: import("@angular/core").WritableSignal<SafeResourceUrl | null>;
+  protected readonly titleUrl: import("@angular/core").WritableSignal<string | undefined>;
+  protected readonly date: import("@angular/core").Signal<string | null>;
+  /** The text of the frame, once it has loaded and the page is allowed to read it. */
+  private readonly frameBody;
+  protected readonly searchable: import("@angular/core").Signal<boolean>;
+  protected readonly query: import("@angular/core").WritableSignal<string>;
+  /** The find box, bound to `query`; off while the frame cannot be read. */
+  protected readonly searchForm: import("@angular/forms/signals").FieldTree<string, string | number, "writable">;
+  protected readonly search: import("@sinequa/atomic-angular/document-workspaces").TextSearch;
+  /** A slow answer for a document the user has already left must not replace the one on screen. */
+  private token;
+  private readonly searchHost;
+  constructor();
+  private load;
+  protected onFrameLoad(): void;
+  protected zoomBy(direction: 1 | -1): void;
+  protected onSearchKeydown(event: KeyboardEvent): void;
+  protected askFollowUpClicked(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<DocumentPreviewPanel, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<DocumentPreviewPanel, "document-preview-panel", never, {
+    "document": {
+      "alias": "document";
+      "required": true;
+      "isSignal": true;
+    };
+    "queryName": {
+      "alias": "queryName";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "closed": "closed";
+    "askFollowUp": "askFollowUp";
+  }, never, never, true, never>;
+}
+declare const TITLE_MAX_LENGTH = 120;
+declare const DESCRIPTION_MAX_LENGTH = 300;
+type WorkspaceEditDialogConfig = {
+  mode: "add";
+} | {
+  mode: "edit";
+  workspace: Workspace;
+};
+/** What the dialog resolves with once it saved: the workspace as the server now has it. */
+type WorkspaceEditResult = {
+  type: "dialog-confirm";
+  workspace: Workspace;
+};
+/**
+ * Creates a workspace, or edits the title, description and tags of one.
+ *
+ * ```ts
+ * const result = await EditWorkspace.call({ mode: "add" });
+ * if (typeof result === "object") open(result["workspace"]);
+ * ```
+ *
+ * It saves by itself — on failure it stays open with the error, so the user can
+ * retry — and while a request is in flight it cannot be dismissed. Editing never
+ * sends `owners`/`readers`: the API replaces both wholesale, so sending a snapshot
+ * taken when the dialog opened could undo what "Manage access" did since.
+ */
+export declare class WorkspaceEditDialog {
+  protected readonly call: import("@sinequa/galactik").CallRef<WorkspaceEditDialogConfig, DialogResult>;
+  private readonly dialog;
+  private readonly store;
+  private readonly currentUser;
+  protected readonly titleMax = 120;
+  protected readonly descriptionMax = 300;
+  private readonly config;
+  protected readonly adding: import("@angular/core").Signal<boolean>;
+  private readonly initial;
+  private readonly model;
+  private readonly tagInput;
+  protected readonly editForm: FieldTree<{
+    name: string;
+    description: string;
+    tags: string[];
+  }, string | number, "writable">;
+  protected readonly description: import("@angular/core").Signal<string>;
+  /** The people picked to share a new workspace with. */
+  protected readonly sharedWith: import("@angular/core").WritableSignal<PickedPrincipal[]>;
+  /** Never offered: they are the creator-to-be, and go into `owners` when the workspace is created. */
+  protected readonly excludedIds: import("@angular/core").Signal<string[]>;
+  protected readonly busy: import("@angular/core").WritableSignal<boolean>;
+  protected readonly error: import("@angular/core").WritableSignal<WorkspaceErrorMessage | null>;
+  protected readonly descriptionTooLong: import("@angular/core").Signal<boolean>;
+  protected readonly saveLabel: import("@angular/core").Signal<"documentWorkspaces.common.save" | "documentWorkspaces.edit.creating" | "documentWorkspaces.edit.saving" | "documentWorkspaces.common.create">;
+  /** What to resolve with once the native dialog has closed: the saved workspace, or the plain dismissal. */
+  private outcome;
+  constructor();
+  /** A field shows its error only once the user has left it, or tried to submit. */
+  protected showError<T>(field: FieldTree<T>): boolean;
+  /** The submission itself, only ever reached with a valid form: the title is there, the description fits. */
+  private save;
+  protected onClosed(event: DialogResult): void;
+  /** Escape on a native <dialog> closes it: refuse while the request is running. */
+  protected onNativeCancel(event: Event): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<WorkspaceEditDialog, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<WorkspaceEditDialog, "workspace-edit-dialog", never, {}, {}, never, never, true, never>;
+}
+/** Imperative entry point: `await EditWorkspace.call({ mode: "add" })`. */
+export declare const EditWorkspace: import("@sinequa/galactik").Callable<WorkspaceEditDialogConfig, DialogResult>;
+type ViewMode = "grid" | "list";
+/**
+ * One workspace and its documents, as a grid or a list, with search, multi-selection,
+ * upload, edit and delete.
+ *
+ * It reads `WorkspacesStore` for both the workspace and its documents, so a change
+ * made elsewhere — a role changed from "Manage access", a status patched by the
+ * upload flow — shows without anything being pushed in. It does not know where it is
+ * shown: it says what the user asked for (`back`, `deleted`, `askFollowUp`) and whoever
+ * hosts it decides. The document open in the preview is the `previewedDocumentId` model.
+ *
+ * Only someone who can write sees the edit, share, delete, upload and select controls.
+ *
+ * While a workspace stays open, it keeps polling its documents and its own
+ * metadata in the background (`injectLiveRefresh`), so an edit or a document
+ * another user adds shows up on its own.
+ */
+export declare class WorkspaceDetail {
+  readonly workspaceId: import("@angular/core").InputSignal<string>;
+  /** The tus endpoint uploads go to — the host's `upload-endpoint`. */
+  readonly uploadEndpoint: import("@angular/core").InputSignal<string>;
+  /** The document open in the preview, or `null`. Two-way: the host can open one, and is told when it is opened or closed. */
+  readonly previewedDocumentId: import("@angular/core").ModelSignal<string | null>;
+  /** The query the preview web service renders a document for — the host's `query-name`. */
+  readonly queryName: import("@angular/core").InputSignal<string>;
+  /** The user wants to leave for the list. */
+  readonly back: import("@angular/core").OutputEmitterRef<void>;
+  /** The workspace was deleted from here; the host has nothing left to show. */
+  readonly deleted: import("@angular/core").OutputEmitterRef<Workspace>;
+  /** The workspace was edited from here (title, description, tags). */
+  readonly workspaceUpdated: import("@angular/core").OutputEmitterRef<Workspace>;
+  /** "Ask follow-up" on a previewed document: the host's chat is what takes it from there. */
+  readonly askFollowUp: import("@angular/core").OutputEmitterRef<AskFollowUp>;
+  private readonly store;
+  private readonly uploads;
+  private readonly injector;
+  private readonly transloco;
+  protected readonly viewMode: import("@angular/core").WritableSignal<ViewMode>;
+  protected readonly query: import("@angular/core").WritableSignal<string>;
+  /** The search box, bound to `query`. */
+  protected readonly searchForm: import("@angular/forms/signals").FieldTree<string, string | number, "writable">;
+  protected readonly status: import("@angular/core").WritableSignal<"error" | "loading" | "ready">;
+  protected readonly loadError: import("@angular/core").WritableSignal<Message | null>;
+  protected readonly refreshError: import("@angular/core").WritableSignal<string | null>;
+  protected readonly refreshing: import("@angular/core").WritableSignal<boolean>;
+  protected readonly loadingMore: import("@angular/core").WritableSignal<boolean>;
+  protected readonly loadMoreError: import("@angular/core").WritableSignal<string | null>;
+  /** The background refresh found the workspace gone from the server (deleted elsewhere). */
+  protected readonly deletedElsewhere: import("@angular/core").WritableSignal<boolean>;
+  protected readonly workspace: import("@angular/core").Signal<Workspace | undefined>;
+  protected readonly documents: import("@angular/core").Signal<WorkspaceDocument[]>;
+  protected readonly previewed: import("@angular/core").Signal<WorkspaceDocument | null>;
+  /** The width the user dragged the preview to, if they did. */
+  protected readonly userPreviewWidth: import("@angular/core").WritableSignal<number | null>;
+  /** The width of the view itself: the preview opens at 40% of it (280px at the least), as in the web element. */
+  private readonly hostWidth;
+  protected readonly previewWidth: import("@angular/core").Signal<number>;
+  /** The list keeps at least 360px. */
+  protected readonly maxPreviewWidth: import("@angular/core").Signal<number | undefined>;
+  protected readonly hasMore: import("@angular/core").Signal<boolean>;
+  protected readonly filtered: import("@angular/core").Signal<WorkspaceDocument[]>;
+  private readonly writable;
+  protected readonly selection: import("@sinequa/atomic-angular/document-workspaces").Selection<WorkspaceDocument>;
+  private readonly liveRefresh;
+  constructor();
+  private open;
+  /**
+   * Leaving from here: once the background refresh found the workspace gone,
+   * the cache still holds it (so its name kept showing) — drop it now, so a
+   * stale card does not show it back on the list.
+   */
+  protected leave(): void;
+  /** Reads the workspace (when it is not cached) and its documents, for the workspace currently shown. */
+  protected load(): Promise<void>;
+  /** Reads the documents again without leaving the view; a failure leaves the ones shown as they are. */
+  protected refresh(): Promise<void>;
+  protected loadMore(): Promise<void>;
+  /** Opening the open one again closes it. */
+  protected togglePreview(document: WorkspaceDocument): void;
+  protected upload(workspace: Workspace): void;
+  protected share(workspace: Workspace): void;
+  protected edit(workspace: Workspace): Promise<void>;
+  protected confirmDeleteWorkspace(workspace: Workspace): Promise<void>;
+  protected deleteSelected(): void;
+  protected confirmDeleteDocuments(targets: WorkspaceDocument[]): Promise<void>;
+  private translate;
+  static ɵfac: i0.ɵɵFactoryDeclaration<WorkspaceDetail, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<WorkspaceDetail, "workspace-detail", never, {
+    "workspaceId": {
+      "alias": "workspaceId";
+      "required": true;
+      "isSignal": true;
+    };
+    "uploadEndpoint": {
+      "alias": "uploadEndpoint";
+      "required": false;
+      "isSignal": true;
+    };
+    "previewedDocumentId": {
+      "alias": "previewedDocumentId";
+      "required": false;
+      "isSignal": true;
+    };
+    "queryName": {
+      "alias": "queryName";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "previewedDocumentId": "previewedDocumentIdChange";
+    "back": "back";
+    "deleted": "deleted";
+    "workspaceUpdated": "workspaceUpdated";
+    "askFollowUp": "askFollowUp";
+  }, never, never, true, never>;
+}
+/** What a host chat reads to build its own mention menu. */
+interface MentionSelection {
+  ids: string[];
+  count: number;
+}
+/**
+ * The workspaces as rows to tick, for the "+" / "@" menu of a host chat.
+ *
+ * The ticks are the store's, not this component's: however many of these are on
+ * screen (one per open menu), and wherever else the selection is read, they show the
+ * same thing. Every workspace is listed, the ones shared read-only too — mentioning
+ * one only reads it.
+ */
+export declare class WorkspaceMentionList {
+  /** The ticks changed because of this list. */
+  readonly selectionChanged: import("@angular/core").OutputEmitterRef<MentionSelection>;
+  private readonly store;
+  protected readonly status: import("@angular/core").WritableSignal<"error" | "loading" | "ready">;
+  /** The rows, for this list and for a host that draws its own. */
+  readonly items: import("@angular/core").Signal<{
+    id: string;
+    name: string;
+    color: import("@sinequa/atomic-angular/document-workspaces").WorkspaceColor;
+    documentCount: number;
+    selected: boolean;
+  }[]>;
+  constructor();
+  /** Ticks a workspace from outside — a host that has its own way of choosing one. */
+  select(id: string): void;
+  protected toggle(id: string, checked: boolean): void;
+  private announce;
+  static ɵfac: i0.ɵɵFactoryDeclaration<WorkspaceMentionList, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<WorkspaceMentionList, "workspace-mention-list", never, {}, {
+    "selectionChanged": "selectionChanged";
+  }, never, never, true, never>;
+}
+/** What "save" attaches to a workspace: a document that already exists, by name. */
+interface PickerDocument {
+  name: string;
+}
+export declare const NEW_WORKSPACE_NAME_MAX = 50;
+/**
+ * Picks the workspace to put documents in — "Save to workspace", or "Move to
+ * workspace" when they come from another one — and can make a new one on the spot.
+ *
+ * Only the workspaces the user can write to are offered: attaching a document is a
+ * write, so a workspace shared read-only stays out (it stays visible wherever it is
+ * merely read). When moving, the workspace the documents come from is left out too.
+ *
+ * It does the work (the store's `saveDocuments` / `moveDocuments`) and says when it is
+ * over — `completed` — once the check mark has been seen; whoever shows it (a popover,
+ * a bottom sheet) decides what closing means.
+ */
+export declare class WorkspacePicker {
+  /** `save` attaches `documents` to the chosen workspace; `move` takes `documentIds` from `fromWorkspaceId` to it. */
+  readonly mode: import("@angular/core").InputSignal<"move" | "save">;
+  readonly documents: import("@angular/core").InputSignal<readonly PickerDocument[]>;
+  readonly fromWorkspaceId: import("@angular/core").InputSignal<string | null>;
+  readonly documentIds: import("@angular/core").InputSignal<readonly string[]>;
+  /** The documents are in the workspace, and the check mark has been seen. */
+  readonly completed: import("@angular/core").OutputEmitterRef<Workspace>;
+  private readonly store;
+  protected readonly status: import("@angular/core").WritableSignal<"error" | "loading" | "ready">;
+  protected readonly busyId: import("@angular/core").WritableSignal<string | null>;
+  protected readonly doneId: import("@angular/core").WritableSignal<string | null>;
+  protected readonly error: import("@angular/core").WritableSignal<Message | null>;
+  protected readonly creating: import("@angular/core").WritableSignal<boolean>;
+  /** The name of the workspace being made, in a form of its own. */
+  private readonly newModel;
+  protected readonly newForm: import("@angular/forms/signals").FieldTree<{
+    name: string;
+  }, string | number, "writable">;
+  protected readonly newName: import("@angular/core").Signal<string>;
+  protected readonly submitting: import("@angular/core").WritableSignal<boolean>;
+  /** The workspaces made from here, newest first: they head the list. */
+  private readonly created;
+  private readonly candidates;
+  protected readonly rows: import("@angular/core").Signal<Workspace[]>;
+  protected readonly doneWorkspace: import("@angular/core").Signal<Workspace | undefined>;
+  /** Two workspaces with the same name cannot be told apart in a list: the name is not offered twice (whatever its case). */
+  protected readonly duplicate: import("@angular/core").Signal<boolean>;
+  protected readonly canCreate: import("@angular/core").Signal<boolean>;
+  private timer;
+  constructor();
+  protected load(): Promise<void>;
+  protected isNew(workspace: Workspace): boolean;
+  protected add(workspace: Workspace): Promise<void>;
+  protected onNameKeydown(event: KeyboardEvent): void;
+  protected cancelNew(): void;
+  protected create(): Promise<void>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<WorkspacePicker, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<WorkspacePicker, "workspace-picker", never, {
+    "mode": {
+      "alias": "mode";
+      "required": false;
+      "isSignal": true;
+    };
+    "documents": {
+      "alias": "documents";
+      "required": false;
+      "isSignal": true;
+    };
+    "fromWorkspaceId": {
+      "alias": "fromWorkspaceId";
+      "required": false;
+      "isSignal": true;
+    };
+    "documentIds": {
+      "alias": "documentIds";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "completed": "completed";
+  }, never, never, true, never>;
+}
+/**
+ * Opens the "Save to / Move to workspace" picker from a host page's own button, and
+ * says what came of it. It draws nothing itself: it is what the `lexiq-workspace-picker`
+ * custom element wraps, for hosts that have no Angular component to open the dialog from.
+ * In Angular, call `PickWorkspace.call(...)` directly.
+ */
+export declare class WorkspacePickerLauncher {
+  /** Documents were saved to a workspace: its name. */
+  readonly saved: import("@angular/core").OutputEmitterRef<string>;
+  /** Documents were moved to another workspace. */
+  readonly moved: import("@angular/core").OutputEmitterRef<void>;
+  private readonly injector;
+  /** Opens "Save to workspace" under `anchor`. */
+  openSaveCard(anchor: HTMLElement, options?: {
+    documents?: readonly PickerDocument[];
+  }): Promise<void>;
+  /** Opens "Move to workspace" under `anchor`, for documents of the workspace they come from. */
+  openMoveMenu(anchor: HTMLElement, documentIds: readonly string[], options: {
+    fromWorkspaceId: string;
+  }): Promise<void>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<WorkspacePickerLauncher, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<WorkspacePickerLauncher, "workspace-picker-launcher", never, {}, {
+    "saved": "saved";
+    "moved": "moved";
+  }, never, never, true, never>;
+}
+interface WorkspacePickerDialogConfig {
+  mode: "save" | "move";
+  /** Where the popover opens from. Without one (or on a narrow window) it is a sheet. */
+  anchor?: HTMLElement | null;
+  /** `save`: the documents to attach, by name. */
+  documents?: readonly PickerDocument[];
+  /** `move`: where they come from, and which of its documents. */
+  fromWorkspaceId?: string | null;
+  documentIds?: readonly string[];
+}
+/** What the dialog resolves with once the documents are in: the workspace they went to. */
+type WorkspacePickerResult = {
+  type: "dialog-confirm";
+  workspace: Workspace;
+};
+/**
+ * "Save to workspace" / "Move to workspace", as a popover under the button that asked
+ * (`anchor`), or a sheet at the bottom of a narrow screen.
+ *
+ * ```ts
+ * const result = await PickWorkspace.call({ mode: "save", anchor: button, documents: [{ name: "report.pdf" }] });
+ * ```
+ *
+ * The popover is galactik's `[popover]` — the browser's light dismiss closes it on an outside
+ * press or Escape, and floating-ui keeps it under the anchor; the sheet is galactik's `Sheet`,
+ * modal, with its backdrop. Which one is decided when it opens.
+ */
+export declare class WorkspacePickerDialog {
+  protected readonly call: import("@sinequa/galactik").CallRef<WorkspacePickerDialogConfig, DialogResult>;
+  private readonly injector;
+  protected readonly config: WorkspacePickerDialogConfig;
+  protected readonly title: import("@angular/core").Signal<"documentWorkspaces.picker.moveToWorkspace" | "documentWorkspaces.picker.saveToWorkspace">;
+  /** A popover when there is an anchor to hang it from and room for it; a sheet otherwise. Decided once, when it opens. */
+  protected readonly asPopover: boolean;
+  protected readonly popoverId: string;
+  private readonly popover;
+  private readonly sheet;
+  private outcome;
+  private ended;
+  constructor();
+  /**
+   * The popover finds its trigger by `popovertarget`, so the host's button gets it for as long as the
+   * popover is being placed. The native behaviour of such an attribute — toggling the popover on the
+   * button's own click — is not wanted: what a press on the button means is the host's business.
+   */
+  private showPopover;
+  protected complete(workspace: Workspace): void;
+  /** The popover is closed — by the picker, an outside press, Escape: that is the end of the call. */
+  protected onToggle(event: Event): void;
+  protected onSheetClosed(event: DialogResult): void;
+  private end;
+  static ɵfac: i0.ɵɵFactoryDeclaration<WorkspacePickerDialog, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<WorkspacePickerDialog, "workspace-picker-dialog", never, {}, {}, never, never, true, never>;
+}
+/** Imperative entry point: `await PickWorkspace.call({ mode: "save", anchor, documents })`. */
+export declare const PickWorkspace: import("@sinequa/galactik").Callable<WorkspacePickerDialogConfig, DialogResult>;
+/**
+ * The whole workspaces view in one component: the list, a workspace with its documents
+ * and preview, the dialogs they open, and the upload tracker.
+ *
+ * It is the piece that decides where things go — which the parts leave to their host:
+ * choosing a workspace opens it, "Add workspace" opens the dialog and then the new
+ * workspace, leaving a workspace goes back to the list. `workspaceId` is what is shown
+ * (`null` is the list), two-way: a host can open a workspace, and is told which is open.
+ *
+ * ```html
+ * <workspaces-shell uploadEndpoint="/tus" [(workspaceId)]="id" (askFollowUp)="chat.ask($event)" />
+ * ```
+ *
+ * The parts are exported as well (`WorkspaceList`, `WorkspaceDetail`…) for a host that
+ * wants its own layout. The shell is also what the `lexiq-workspaces` custom element
+ * wraps, for pages that are not Angular.
+ */
+export declare class WorkspacesShell {
+  /** The workspace shown; `null` for the list. */
+  readonly workspaceId: import("@angular/core").ModelSignal<string | null>;
+  /** The tus endpoint uploads go to. */
+  readonly uploadEndpoint: import("@angular/core").InputSignal<string>;
+  /** The query the preview web service renders a document for. */
+  readonly queryName: import("@angular/core").InputSignal<string>;
+  /** `dark` turns the dark tokens on for the shell; otherwise it follows the page. */
+  readonly theme: import("@angular/core").InputSignal<"light" | "dark" | null>;
+  /** A workspace was created from here. */
+  readonly workspaceCreated: import("@angular/core").OutputEmitterRef<Workspace>;
+  /** A workspace was edited from here. */
+  readonly workspaceUpdated: import("@angular/core").OutputEmitterRef<Workspace>;
+  /** "Ask follow-up" on a previewed document. */
+  readonly askFollowUp: import("@angular/core").OutputEmitterRef<AskFollowUp>;
+  private readonly injector;
+  /** Opens the "Add workspace" dialog, then the workspace it made. */
+  addWorkspace(): Promise<void>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<WorkspacesShell, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<WorkspacesShell, "workspaces-shell", never, {
+    "workspaceId": {
+      "alias": "workspaceId";
+      "required": false;
+      "isSignal": true;
+    };
+    "uploadEndpoint": {
+      "alias": "uploadEndpoint";
+      "required": false;
+      "isSignal": true;
+    };
+    "queryName": {
+      "alias": "queryName";
+      "required": false;
+      "isSignal": true;
+    };
+    "theme": {
+      "alias": "theme";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "workspaceId": "workspaceIdChange";
+    "workspaceCreated": "workspaceCreated";
+    "workspaceUpdated": "workspaceUpdated";
+    "askFollowUp": "askFollowUp";
+  }, never, never, true, never>;
+}
+export type { AddFilesOptions, AskFollowUp, AssignableRole, ConfirmDialogConfig, ConnectionNotice, CreateWorkspaceInput, CurrentUser, DocumentLabels, DocumentStatus, DocumentType, Member, MentionSelection, Pagination, PickedPrincipal, PickerDocument, PrincipalSummary, RemoveWorkspacesResult, ResolvedPrincipal, Selection, SelectionOptions, ShareDialogConfig, TextSearch, TextSearchOptions, TrackFileInput, TrackedUpload, TrackerWorkspace, UploadDialogConfig, UploadEvents, UploadFactory, UploadHandle, UploadOptions, UploadStatus, UploadTarget, UploadTrackerState, Workspace, WorkspaceColor, WorkspaceDocument, WorkspaceEditDialogConfig, WorkspaceEditResult, WorkspacePickerDialogConfig, WorkspacePickerResult, WorkspaceRole, WorkspaceTab, WorkspaceTabCounts, WorkspacesState };