@arsedizioni/ars-utils 22.5.12 → 22.5.14

package/types/arsedizioni-ars-utils-clipper.common.d.ts

@@ -1,15 +1,27 @@
 import * as i0 from '@angular/core';
 import { Signal, WritableSignal } from '@angular/core';
-import { NameValueItem, LoginOAuthType, LoginResult, ApiResult, FolderTree } from '@arsedizioni/ars-utils/core';
+import { NameValueItem, LoginResult, ApiResult, FolderTree } from '@arsedizioni/ars-utils/core';
 import { SendToDialogResult } from '@arsedizioni/ars-utils/ui';
 import { HttpInterceptorFn } from '@angular/common/http';
 import * as rxjs from 'rxjs';
+import { Observable } from 'rxjs';
 
 declare const ClipperMessages: {
     /**
      * Messages
      */
     ERROR: string;
+    /**
+     * The session is gone: a 401 on a request that was not a login attempt.
+     * Emitted once per dead session by `clipperAuthInterceptor`, which re-arms on the first
+     * good response.
+     */
+    ERROR_401: string;
+    /**
+     * The API is not answering: the interceptor has already sent the request three times over
+     * ten seconds. Emitted once, and re-armed on the first good response.
+     */
+    ERROR_UNAVAILABLE: string;
     SUCCESS: string;
     SUCCESS_TOAST: string;
     LOGIN_CHANGED: string;
@@ -191,10 +203,7 @@ interface ClipperLoginResult extends LoginResult<ClipperUserInfo> {
 }
 interface ClipperLoginInfo {
     context?: ClipperUserInfo;
-    complianceContext?: any;
     channels?: ClipperChannelSettings[];
-    oauth?: LoginOAuthType;
-    remember?: boolean;
 }
 declare enum ClipperQueryDocumentFlags {
     None = 0,
@@ -319,6 +328,40 @@ interface ClipperDocumentRelevants {
     hit: number;
     chunks: number;
 }
+/** One delivery of a shared note by email, and whether the recipient opened it. */
+interface ClipperDocumentNoteTracking {
+    id: string;
+    userMailId: number;
+    email?: string;
+    sentDate: Date;
+    openDate?: Date;
+}
+/**
+ * A shared note attached to a document.
+ *
+ * The library never creates or edits one -- notes belong to the application that owns the
+ * account -- but the API attaches them to documents and to `metadata()`, so the shape is
+ * declared here rather than letting a consumer read a response it cannot see.
+ */
+interface ClipperDocumentNote {
+    id?: number;
+    teamId?: string;
+    teamTitle?: string;
+    documentId?: string;
+    documentTitle?: string;
+    color?: string;
+    name?: string;
+    note?: string;
+    trackings?: ClipperDocumentNoteTracking[];
+    trackingsCount?: number;
+    trackingsOpenedCount?: number;
+    expiringDate?: Date;
+    isExpired?: boolean;
+    isTroubled?: boolean;
+    isMenuOpen?: boolean;
+    isOver?: boolean;
+    created?: Date;
+}
 interface ClipperDocumentInfo {
     id?: string;
     documentId?: string;
@@ -346,6 +389,7 @@ interface ClipperDocumentInfo {
     originDescription?: string;
     author?: string;
     anchors?: ClipperDocumentAnchorInfo[];
+    notes?: ClipperDocumentNote[];
     chunks?: ClipperDocumentAnchorInfo[];
     chunksList?: string;
     taxonomy?: string;
@@ -474,13 +518,15 @@ declare enum ClipperExportDocumentsFormat {
     iCalendar = 2
 }
 interface ClipperExportDocumentsParams {
-    query: ClipperSearchParams;
+    query?: ClipperSearchParams;
     ids: string[];
     format?: ClipperExportDocumentsFormat;
 }
 interface ClipperSendDocumentsByEmailParams extends SendToDialogResult {
     ids?: string[];
+    isCalendar?: boolean;
     public?: string;
+    userNoteId?: number;
 }
 interface ClipperDocumentStructure {
     id: string;
@@ -688,9 +734,36 @@ declare class ClipperSearchUtils {
 /**
  * Builds the Clipper auth HTTP interceptor.
  *
- * Takes its two inputs — the Clipper base URI and the service flags — directly
- * as arguments (captured in the closure), so it never injects ClipperService:
- * registering it does not pull the full Clipper service into the eager bundle.
+ * Attaches the credentials and the service-worker bypass header to every request aimed at the
+ * Clipper API, and turns HTTP failures into broadcast messages — no UI dependency here.
+ *
+ * Takes the Clipper base URI and the service flags directly as arguments, captured in the closure,
+ * so it never injects `ClipperService`: registering it does not pull the whole Clipper service into
+ * the eager bundle. The debounce and the two notification latches live in that same closure, so two
+ * applications registering two interceptors never share them.
+ *
+ * ## What the statuses mean
+ *
+ * Aligned with the Clipper 7.5 API on 2026-08-25. The meaning of the status codes changed with the
+ * API: failures used to arrive as `200 OK` with `success: false`, and this interceptor had to guess.
+ * Now the status is the truth — a 401 on an already-authenticated request means the session is
+ * gone, a 403 means the permission is missing, and a 5xx means the server broke, which is not the
+ * same thing at all and must not sign the user out.
+ *
+ * A dead session is broadcast as `ClipperMessages.ERROR_401`, for the host application to handle
+ * centrally; every other failure stays a `ClipperMessages.ERROR` carrying a message. The two are
+ * separate because they call for opposite things: one returns to the sign-in page, the other shows
+ * a dialog and leaves the user where they are.
+ *
+ * Between them sits the third case, which is neither: the API is being replaced. A deployment
+ * answers with a 5xx that has no `ApiResult` envelope, or does not answer at all, for the few
+ * seconds the process takes to come back. That is not worth a dialog and not worth a redirect
+ * either, so the request is simply sent again — twice, five seconds apart — and only if the third
+ * attempt fails too does it become `ClipperMessages.ERROR_UNAVAILABLE`.
+ *
+ * `ClipperServiceFlags.NotifySystemErrors` still governs one narrow case, and only that one: a 5xx
+ * that DOES carry an envelope, i.e. a server error the API itself described. Without the flag it is
+ * swallowed, as it always was in this library.
  *
  * Register it with `withInterceptors`:
  * @example
@@ -806,11 +879,16 @@ declare class ClipperDocumentsService {
     index(id: string): rxjs.Observable<ApiResult<ClipperDocumentStructure>>;
     /**
      * Gets the last-update metadata for a document.
+     *
+     * The response carries two things, not one: the last-update string and the shared notes attached
+     * to the document. The second was long left undeclared here, so a consumer of this library could
+     * not see data the API had already sent it.
      * @param id - The ID of the document.
-     * @returns An observable emitting the API result wrapping the last update string.
+     * @returns An observable emitting the API result wrapping the last update string and its notes.
      */
     metadata(id: string): rxjs.Observable<ApiResult<{
         item1?: string;
+        item2?: ClipperDocumentNote[];
     }>>;
     /**
      * Queries document references, changes or jurisprudence depending on the requested mode.
@@ -907,74 +985,116 @@ declare class ClipperDocumentsService {
 }
 
 /**
- * Authentication: credential / OAuth2 login, MFA confirmation, logout and OTP.
- * Shared login context, channels and the logged-in flag live in `ClipperCoreService`.
+ * Authentication: password login, e-mailed code confirmation, logout and session restore.
+ * The login context, the channels and the logged-in flag live in `ClipperCoreService`.
+ *
+ * Aligned with the Clipper 7.5 API on 2026-08-25. Everything here now goes through `/session/*`
+ * and an HttpOnly cookie: there is no bearer token, no `remember` credential the API can replay,
+ * and no OAuth token acquired by the caller — the external-provider flow is a full-page redirect
+ * handled server-side, and all that reaches this service is the `/session/me` call on the way back.
+ *
+ * This is a deliberately reduced subset of what the Clipper application itself does. Passkeys and
+ * the passwordless recovery code (`/session/otp`) are not here: a library whose job is showing
+ * documents signs in with a password, and an application that offers the other ways in owns them.
  */
 declare class ClipperLoginService {
     private readonly httpClient;
     private readonly broadcastService;
     private readonly splashService;
     private readonly core;
-    /**
-     * Attempts an automatic login using the credentials currently stored in session storage.
-     * @param onSuccess - Optional callback invoked with the login result value on success.
-     */
-    autoLogin(onSuccess?: (value?: any) => void): void;
-    /**
-     * Performs an automatic logout and clears the stored session.
-     * @param onSuccess - Optional callback invoked after a successful logout.
+    /** Whether {@link initialize} has already run. */
+    private initialized;
+    /**
+     * Validates a context that survived a page refresh before trusting it.
+     *
+     * Called by `ClipperService.initialize`, right after `ClipperCoreService.initialize`, so a
+     * consumer gets the restore for free and never has to know this method exists. The auth cookie is
+     * HttpOnly and may have expired while the stored context lived on, so a stored context only ever
+     * means "there WAS a session" — this is what turns it into "there is one".
+     *
+     * A host application that drives its own return from an external provider, or that starts on its
+     * own sign-in page, should call `core.setLoggedIn(false)` before bootstrapping rather than let
+     * this race its own restore.
+     * @returns void
+     */
+    initialize(): void;
+    /**
+     * Asks `/session/me` whether the restored session is still alive. On success the login is
+     * finalised from the current claims; on a dead session the interceptor's 401 handling takes over.
+     *
+     * Nothing is cleared on failure, and that is deliberate: a failure here is not proof of a dead
+     * session — the API may be unreachable, the proxy may have answered 502, the device may be
+     * offline. Clearing on any of those would sign the user out with a perfectly valid cookie.
+     * @returns void
+     */
+    private restoreSession;
+    /**
+     * Authenticates the user with email and password.
+     *
+     * Nothing is replayed from a stored credential any more: the former "remember me" token, which
+     * let the API sign a caller in from something kept for sixty days, is gone. A login always starts
+     * from what the user just typed.
+     * @param email - The user's email address.
+     * @param password - The user's password.
+     * @returns An observable emitting the API result wrapping the login result.
      */
-    autoLogout(onSuccess?: () => void): void;
+    login(email?: string, password?: string): Observable<ApiResult<ClipperLoginResult>>;
     /**
-     * Authenticates the user against the Clipper API, supporting both credential-based and
-     * OAuth2 login flows.
-     * @param email - The user's email address (credential login only).
-     * @param password - The user's password (credential login only).
-     * @param remember - When `true`, the session is remembered across browser restarts.
-     * @param oauth - The OAuth2 provider type, when authenticating via SSO.
-     * @param oauthAccessToken - The OAuth2 bearer token. Defaults to the value stored in session storage.
+     * Confirms a pending e-mailed code challenge, which establishes the session.
+     *
+     * The address travels with the code because the API stores each code under the account it was
+     * issued to: a code alone is not redeemable, which is what stops a guessed code from opening
+     * whatever session happens to be pending. It also keeps the code out of the URL, where it used to
+     * sit — `/login/confirm/{code}` put it in the path, and therefore in the server logs and in the
+     * browser history.
+     * @param code - The one-time confirmation code provided to the user.
+     * @param email - The address the code was sent to.
      * @returns An observable emitting the API result wrapping the login result.
      */
-    login(email?: string, password?: string, remember?: boolean, oauth?: LoginOAuthType, oauthAccessToken?: string | undefined): rxjs.Observable<ApiResult<ClipperLoginResult>>;
+    confirm(code: string, email?: string): Observable<ApiResult<ClipperLoginResult>>;
     /**
-     * Finalises the login flow by updating the stored context, setting the logged-in signal,
-     * initialising channels, and broadcasting `LOGIN_COMPLETED`.
-     * @param result - The login result returned by the API.
+     * Logs the user out on the server and clears the local state.
+     * @returns An observable that emits once the logout has been processed.
      */
-    private completeLogin;
+    logout(): Observable<ApiResult<unknown>>;
     /**
-     * Submits the MFA confirmation code to complete a two-factor login flow.
-     * @param code - The one-time confirmation code provided to the user.
-     * @returns An observable emitting the API result wrapping the login result.
+     * Reads the current session from the server, which resolves it from the auth cookie claims
+     * without touching the database. Used to restore the state after a page refresh instead of
+     * trusting what local storage holds, and to close an external-provider round-trip.
+     * @returns An observable emitting the current session.
      */
-    confirmIdentity(code: string): rxjs.Observable<ApiResult<ClipperLoginResult>>;
+    me(): Observable<ApiResult<ClipperLoginResult>>;
     /**
-     * Logs the user out and clears the current session.
-     * @param forget - When `true`, all stored user credentials are also removed.
-     * @returns An observable that completes once the logout request has been processed.
+     * Finalises the login flow after an authentication, a code confirmation or a session restore:
+     * writes the context into the shared state, raises the logged-in signal, rebuilds the channel
+     * list and announces `LOGIN_COMPLETED`.
+     *
+     * `loggingIn` is deliberately left alone. Whoever raised it lowers it — {@link restoreSession}
+     * for a refresh, the host application for an external-login round-trip — because lowering it
+     * here would drop the splash the instant the response arrived, before anything was on screen.
+     * @param result - The login result returned by the API.
+     * @param notify - Whether to broadcast `LOGIN_COMPLETED`. Defaults to `true`.
+     * @returns void
      */
-    logout(forget?: boolean): rxjs.Observable<any>;
+    private completeLogin;
     /**
-     * Requests a new one-time password for the given repository.
-     * @param id - The repository ID for which the OTP should be generated.
+     * Requests a new one-time password used to authorise a binary download.
+     * @param id - The repository ID of the binary the OTP is generated for.
      * @returns An observable emitting the API result wrapping the generated OTP info.
      */
-    newOTP(id: string): rxjs.Observable<ApiResult<ClipperOTPInfo>>;
+    newOTP(id: string): Observable<ApiResult<ClipperOTPInfo>>;
     /**
      * Persists the current login context to `localStorage`.
      * Delegates to `ClipperCoreService.storeContext()`.
+     * @returns void
      */
     storeContext(): void;
     /**
-     * Updates the stored login context with the values from a fresh login result.
-     * Delegates to `ClipperCoreService.updateContext()`.
-     * @param result - The login result containing the new user context and channel settings.
-     */
-    updateContext(result: ClipperLoginResult): void;
-    /**
-     * Clears all session-storage authentication keys and resets the login state.
+     * Clears every trace of the current session on this device: the stored context, the logged-in
+     * signal and the session-storage keys. Does NOT call the server — use {@link logout} for that.
      * Delegates to `ClipperCoreService.clear()`.
-     * @param clearOAuthToken - When `true`, the OAuth bearer token is also removed.
+     * @param clearOAuthToken - Whether to drop the legacy OAuth token too. Defaults to `true`.
+     * @returns void
      */
     clear(clearOAuthToken?: boolean): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ClipperLoginService, never>;
@@ -991,7 +1111,7 @@ declare class ClipperLoginService {
  */
 declare class ClipperService {
     private readonly core;
-    /** Authentication: login/logout, MFA, OTP. */
+    /** Authentication: login/logout, e-mailed code confirmation, session restore, OTP. */
     readonly session: ClipperLoginService;
     /** Document search, references, export, working-documents bag and saved searches. */
     readonly documents: ClipperDocumentsService;
@@ -1030,10 +1150,12 @@ declare class ClipperService {
     /** @returns A signal indicating whether tagging is allowed. */
     get allowTags(): WritableSignal<boolean>;
     /**
-     * Initialises the application with the API base URI, optional app URI, and feature flags.
+     * Initialises the application with the API base URI, optional app URI, and feature flags, then
+     * validates any session that survived a page refresh.
      * @param serviceUri - The base URI of the Clipper REST API.
      * @param appUri - Optional URI of the Clipper web application (used to build document links).
      * @param flags - Feature flags that control service behaviour. Defaults to `ClipperServiceFlags.None`.
+     * @returns void
      */
     initialize(serviceUri: string, appUri?: string, flags?: ClipperServiceFlags): void;
     /**
@@ -1077,6 +1199,16 @@ declare class ClipperCoreService {
      * @returns The current login context, or `undefined` if not authenticated.
      */
     get loginInfo(): ClipperLoginInfo | undefined;
+    /**
+     * Seeded from the stored context, which is the only trace a session leaves on this device: the
+     * auth cookie is HttpOnly and unreadable from here. It means "there WAS a session", never "there
+     * is one" -- `ClipperLoginService.initialize` validates it against `/session/me` before it is
+     * trusted, and a failure there ends as a 401 that clears the session.
+     *
+     * It used to be seeded from a `clipper_oauth_token` session-storage key, which nothing has
+     * written since the provider flow moved server-side: the flag was therefore false at every
+     * bootstrap and the whole restore path could never run.
+     */
     private readonly _loggedIn;
     readonly loggedIn: Signal<boolean>;
     readonly loggingIn: i0.WritableSignal<boolean>;
@@ -1094,6 +1226,10 @@ declare class ClipperCoreService {
      * Ensures a login-info object exists and returns it for further mutation.
      * Replaces the inline `if (!this._loginInfo) { ... }` guards now that the field
      * is private to this service.
+     *
+     * Reads through the getter, never the field: the context is loaded from storage lazily, so a
+     * caller that mutates before anyone has read would find the field empty and start from a blank
+     * object, silently dropping a perfectly good stored context.
      * @returns The existing login-info object, or a freshly created empty one.
      */
     ensureLoginInfo(): ClipperLoginInfo;
@@ -1104,11 +1240,21 @@ declare class ClipperCoreService {
      */
     setLoggedIn(value: boolean): void;
     /**
-     * Persists the current login context to `localStorage`.
+     * Persists the current login context to `localStorage`, but only when there is a context to
+     * persist. A login-info object with no `context` is not a session: it is the empty shell
+     * `ensureLoginInfo` hands out before anything has been written into it, and storing it would leave
+     * behind a key whose mere presence makes the next bootstrap declare the user logged in.
      */
     storeContext(): void;
     /**
      * Updates the stored login context with the values from a fresh login result.
+     *
+     * Each half is written only when the server actually sent it. An absent `context` or `settings`
+     * means "not carried by this response", never "the user has none": overwriting on absence is what
+     * made a page refresh empty the channel list, because `/session/me` answers without the settings
+     * and this method wrote that emptiness -- through `storeContext`, onto the disk, where it survived
+     * the reload it was born in. An EMPTY array is a different matter and is stored as it comes: that
+     * is the server saying the subscription really is gone.
      * @param result - The login result containing the new user context and channel settings.
      */
     updateContext(result: ClipperLoginResult): void;
@@ -1141,4 +1287,4 @@ declare class ClipperCoreService {
 }
 
 export { ClipperAccountService, ClipperAuthors, ClipperCalendarSearchParams, ClipperCalendarState, ClipperCalendarStates, ClipperChannel, ClipperChannelSettings, ClipperChannels, ClipperCoreService, ClipperDashboard, ClipperDocumentChangeReasons, ClipperDocumentContainer, ClipperDocumentsService, ClipperExportDocumentsFormat, ClipperFacet, ClipperLoginService, ClipperMessages, ClipperModel, ClipperModels, ClipperModule, ClipperModuleGroup, ClipperModuleGroups, ClipperModules, ClipperQueryDocumentFlags, ClipperQueryReferencesMode, ClipperRegions, ClipperSearchCalendarSnapshotResult, ClipperSearchFacetsSnapshot, ClipperSearchParams, ClipperSearchResult, ClipperSearchUtils, ClipperSectorTypes, ClipperSectors, ClipperSelectionMode, ClipperService, ClipperServiceFlags, ClipperSort, ClipperSources, ClipperUtils, clipperAuthInterceptor };
-export type { ClipperAvailableChannel, ClipperChannelSettingsItem, ClipperDashboardItem, ClipperDashboardModelItem, ClipperDeleteWorkingDocumentsParams, ClipperDocumentAnchorInfo, ClipperDocumentInfo, ClipperDocumentRelevantChunkHit, ClipperDocumentRelevants, ClipperDocumentStructure, ClipperDocumentUpdateStateParams, ClipperExportDocumentsParams, ClipperLoginInfo, ClipperLoginResult, ClipperOTPInfo, ClipperReferencesSearchParams, ClipperSearchCalendarSnapshotMonth, ClipperSearchFacet, ClipperSearchFacetGroup, ClipperSearchFacetsResult, ClipperSearchFilter, ClipperSendDocumentsByEmailParams, ClipperTaxonomyParams, ClipperTopicInfo, ClipperUserChannelInfo, ClipperUserInfo, ClipperUserSearch, ClipperUserTrialInfo, ClipperUserWorkingDocument, EditedEventArgs, SectorInfo };
+export type { ClipperAvailableChannel, ClipperChannelSettingsItem, ClipperDashboardItem, ClipperDashboardModelItem, ClipperDeleteWorkingDocumentsParams, ClipperDocumentAnchorInfo, ClipperDocumentInfo, ClipperDocumentNote, ClipperDocumentNoteTracking, ClipperDocumentRelevantChunkHit, ClipperDocumentRelevants, ClipperDocumentStructure, ClipperDocumentUpdateStateParams, ClipperExportDocumentsParams, ClipperLoginInfo, ClipperLoginResult, ClipperOTPInfo, ClipperReferencesSearchParams, ClipperSearchCalendarSnapshotMonth, ClipperSearchFacet, ClipperSearchFacetGroup, ClipperSearchFacetsResult, ClipperSearchFilter, ClipperSendDocumentsByEmailParams, ClipperTaxonomyParams, ClipperTopicInfo, ClipperUserChannelInfo, ClipperUserInfo, ClipperUserSearch, ClipperUserTrialInfo, ClipperUserWorkingDocument, EditedEventArgs, SectorInfo };

package/types/arsedizioni-ars-utils-clipper.ui.d.ts

@@ -267,7 +267,7 @@ declare class ClipperSearchCalendarComponent {
  * asynchronous continuation after the dynamic `import()` is outside the injection context, so an
  * `inject()` added in there would have failed at runtime.
  */
-declare class ClipperDocumentUtilsService {
+declare class ClipperDocumentViewerService {
     private readonly dialogService;
     private readonly clipperService;
     /**
@@ -284,8 +284,8 @@ declare class ClipperDocumentUtilsService {
      * @returns void
      */
     openDocument(documentId: string, query?: string, queryChunks?: string, selectionMode?: ClipperSelectionMode, selectableModules?: ClipperModule[], theme?: ThemeType, canHandleTooManyResults?: boolean, replaceUrl?: string): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ClipperDocumentUtilsService, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ClipperDocumentUtilsService>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ClipperDocumentViewerService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ClipperDocumentViewerService>;
 }
 /**
  * Pure helpers on document data. Deliberately NOT a service: there is nothing to inject, and a
@@ -307,7 +307,7 @@ declare class ClipperSearchResultManager extends ClipperDocumentManager {
     protected readonly destroyRef: DestroyRef;
     protected readonly changeDetector: ChangeDetectorRef;
     protected readonly breakpointObserver: BreakpointObserver;
-    protected readonly documentUtils: ClipperDocumentUtilsService;
+    protected readonly documentUtils: ClipperDocumentViewerService;
     protected readonly themeService: ThemeService;
     readonly screenService: ScreenService;
     selection: SelectableModel<ClipperDocumentInfo, string> | undefined;
@@ -945,7 +945,7 @@ declare class ClipperDocumentComponent extends ClipperDocumentManager {
      */
     open(documentId: string, query?: string, queryChunks?: string, newWindow?: boolean): void;
     /**
-     * Opens a document inline via the {@link ClipperDocumentUtilsService}.
+     * Opens a document inline via the {@link ClipperDocumentViewerService}.
      * @param documentId - The id of the document to open.
      * @param query - Optional free-text query for highlight.
      * @param queryChunks - Optional chunk offsets for semantic highlight.
@@ -1297,5 +1297,5 @@ declare class ClipperSearchResultItemComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<ClipperSearchResultItemComponent, "clipper-search-result-item", never, { "parent": { "alias": "parent"; "required": true; "isSignal": true; }; "item": { "alias": "item"; "required": true; "isSignal": true; }; "actions": { "alias": "actions"; "required": true; "isSignal": true; }; "tileNoPictureUrl": { "alias": "tileNoPictureUrl"; "required": false; "isSignal": true; }; "tilePictureUrl": { "alias": "tilePictureUrl"; "required": false; "isSignal": true; }; "isSelectable": { "alias": "isSelectable"; "required": false; "isSignal": true; }; "isReadable": { "alias": "isReadable"; "required": false; "isSignal": true; }; "isReadableModel": { "alias": "isReadableModel"; "required": false; "isSignal": true; }; "displayModifiedTitle": { "alias": "displayModifiedTitle"; "required": false; "isSignal": true; }; "displayModelName": { "alias": "displayModelName"; "required": false; "isSignal": true; }; "displayDate": { "alias": "displayDate"; "required": false; "isSignal": true; }; "displayMode": { "alias": "displayMode"; "required": false; "isSignal": true; }; }, { "item": "itemChange"; }, never, never, true, never>;
 }
 
-export { ClipperBrowserComponent, ClipperBrowserDialogComponent, ClipperDocumentComponent, ClipperDocumentIndexComponent, ClipperDocumentManager, ClipperDocumentMenuComponent, ClipperDocumentUtilsService, ClipperDocumentsUtils, ClipperReferencesComponent, ClipperSearchCalendarComponent, ClipperSearchFacetsComponent, ClipperSearchFreeTextHelpComponent, ClipperSearchFreeTextQueryBuilderComponent, ClipperSearchResultItemComponent, ClipperSearchResultItemDisplayMode, ClipperSearchResultManager };
+export { ClipperBrowserComponent, ClipperBrowserDialogComponent, ClipperDocumentComponent, ClipperDocumentIndexComponent, ClipperDocumentManager, ClipperDocumentMenuComponent, ClipperDocumentViewerService, ClipperDocumentsUtils, ClipperReferencesComponent, ClipperSearchCalendarComponent, ClipperSearchFacetsComponent, ClipperSearchFreeTextHelpComponent, ClipperSearchFreeTextQueryBuilderComponent, ClipperSearchResultItemComponent, ClipperSearchResultItemDisplayMode, ClipperSearchResultManager };
 export type { ClipperBrowserDialogData, ClipperDocumentDialogData, ClipperDocumentIndexDialogData, ClipperDocumentIndexDialogResult, ClipperReferenceDialogResult, ClipperReferencesDialogData, SearchFreeTextQueryParams };