@zambon-dev/ui 0.0.0-stage → 1.0.0

package/types/zambon-dev-ui-shared.d.ts

@@ -0,0 +1,675 @@
+import * as i0 from "@angular/core";
+import { AfterViewInit, ElementRef, EnvironmentProviders, InjectionToken, InputSignal, ModelSignal, OnDestroy, OnInit, OutputEmitterRef, PipeTransform, Provider, Signal, WritableSignal } from "@angular/core";
+import * as i1 from "@angular/router";
+import { ActivatedRouteSnapshot, CanActivate, RouterStateSnapshot, Routes } from "@angular/router";
+import { HttpBackend, HttpEvent, HttpHandler, HttpInterceptor, HttpRequest } from "@angular/common/http";
+import { Observable, Subject } from "rxjs";
+import { FormBuilder, FormGroup } from "@angular/forms";
+import { AuthService, ButtonFiltersComponent, ChildList, ModalBase, TabViewBase } from "@zambon-dev/ui/framework";
+import { AngularAssetPattern, DataGridDataset, IGridColumn, IListParameters, SidebarMenu } from "@zambon-dev/ui/library";
+import { SafeHtml, SafeResourceUrl } from "@angular/platform-browser";
+import { MultiTranslateHttpLoader, TranslationResource } from "ngx-translate-multi-http-loader";
+export declare class SharedAuthModule {
+  static ɵfac: i0.ɵɵFactoryDeclaration<SharedAuthModule, never>;
+  static ɵmod: i0.ɵɵNgModuleDeclaration<SharedAuthModule, never, [typeof i1.RouterModule], never>;
+  static ɵinj: i0.ɵɵInjectorDeclaration<SharedAuthModule>;
+}
+export declare class AuthGuard implements CanActivate {
+  private authenticationService;
+  private router;
+  canActivate(_: ActivatedRouteSnapshot, state: RouterStateSnapshot): boolean;
+  static ɵfac: i0.ɵɵFactoryDeclaration<AuthGuard, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare class AuthInterceptor implements HttpInterceptor {
+  private authenticationService;
+  private config;
+  private jwtInterceptor;
+  private refreshToken$?;
+  private router;
+  intercept(request: HttpRequest<unknown>, next: HttpHandler): Observable<HttpEvent<unknown>>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<AuthInterceptor, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare abstract class FiltersBase implements OnInit, OnDestroy {
+  protected buttonFilters?: ButtonFiltersComponent;
+  protected destroy$: Subject<boolean>;
+  protected filterForm: FormGroup;
+  protected formBuilder: FormBuilder;
+  ngOnDestroy(): void;
+  ngOnInit(): void;
+  setFilters(filters: {
+    [key: string]: any;
+  }): void;
+  protected abstract formSetup(): FormGroup<any>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<FiltersBase, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<FiltersBase, "ng-component", never, {}, {}, never, never, true, never>;
+}
+export interface ICurrentUserInfo {
+  costCenterName: string;
+  /**
+   * Optional e-mail address. Present only when the sign-in response includes it; it is one of the
+   * values behind the `{email}` placeholder in an external menu URL.
+   */
+  email?: string;
+  name: string;
+  /** Optional avatar image URL. Falls back to initials when absent. */
+  pictureUrl?: string;
+  /** Optional job position/title shown under the user name. Line is hidden when absent. */
+  position?: string;
+  /**
+   * Optional stable user identifier. Present only when the sign-in response includes it; it is
+   * the value behind the `{userId}` placeholder in an external menu URL.
+   */
+  userID?: number;
+  /**
+   * Login user name. Already carried by the persisted sign-in response; declared here because it
+   * is the value behind the `{userName}` placeholder in an external menu URL.
+   */
+  username?: string;
+}
+export interface IAuthResponse extends ICurrentUserInfo {
+  refreshToken: string;
+  refreshTokenExpiration: string;
+  token: string;
+  username: string;
+}
+/** First segment of the route that hosts embedded external content. */
+export declare const EXTERNAL_CONTENT_ROUTE_PATH = "external-content";
+/**
+ * Flat projection of an external menu item, used to restore an embedded tab.
+ *
+ * Deliberately not a `SidebarMenu`: that class carries a `parent` back-reference, so it is a
+ * circular structure that `JSON.stringify` refuses, and holding one would pin the whole menu tree.
+ */
+export interface IExternalContentEntry {
+  id: number;
+  label: string;
+  url: string;
+}
+export declare class ExternalContentConfigs {
+  /**
+   * Origins an embedded menu item may point at, for example `['https://reports.example.com']`.
+   * Empty — the default — allows any `http`/`https` origin.
+   *
+   * Populating it is the single highest-value control here after the scheme check: it narrows a
+   * compromised menu row from "frame anything on the internet" to "frame one of our report hosts".
+   */
+  allowedOrigins: string[];
+  /** Milliseconds to wait for the frame's first `load` before hinting that framing may be refused. */
+  slowFrameHintDelay: number;
+  constructor(options?: Partial<ExternalContentConfigs>);
+}
+export declare const EXTERNAL_CONTENT_CONFIGS: InjectionToken<ExternalContentConfigs>;
+export interface INotification {
+  /** Short heading for the notification. */
+  title: string;
+  /** Longer descriptive text. */
+  description: string;
+  /** Icon class shown next to the notification (e.g. a Font Awesome class like `fa-solid fa-envelope`). */
+  icon: string;
+  /** Optional call-to-action URL. When present, clicking the notification navigates to it. */
+  callToActionUrl?: string;
+  /** Whether the notification has been read. */
+  isRead: boolean;
+}
+export interface IOperationsHistoryList {
+  /** Capitalised `ID` is intentional: the backend property is `EntityID`, and the camelCase
+   * serialization policy only lowercases a leading run of capitals — so the trailing ones survive. */
+  entityID?: number;
+  entityName?: string;
+  id: number;
+  newValues?: string;
+  oldValues?: string;
+  operationType?: string;
+  tableName?: string;
+}
+export interface IServicesHistoryList {
+  changedByName: string;
+  changedOn: Date;
+  id: number;
+  name: string;
+}
+export declare class AuthenticationService extends AuthService {
+  adminAction: string;
+  private config;
+  private readonly BASE_URL;
+  private http;
+  constructor();
+  authenticate(model: {
+    username: string;
+    password: string;
+    rememberMe: boolean;
+  }): Observable<void>;
+  getActions(): Observable<string[]>;
+  getUserInfo(): ICurrentUserInfo | null;
+  tryRefreshToken(): Observable<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<AuthenticationService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * Remembers which external destination sits behind an embedded tab's `/external-content/:menuID`
+ * route, and resolves it back when the view is created.
+ *
+ * The destination never travels in the route, so the id has to be resolved to a URL somehow. That
+ * happens in three steps, cheapest first:
+ *
+ * 1. the in-memory registry — the item was clicked in this browsing session;
+ * 2. `sessionStorage` — the user pressed F5 on the embedded tab;
+ * 3. the application's `SidebarService.getMenuFromUrl()` — a cold deep link.
+ *
+ * Step 3 reuses the abstract hook every application already implements, so nothing new is required
+ * of a consumer: an application whose menu endpoint cannot resolve `/external-content/:id` simply
+ * gets the unavailable state on a cold deep link, which is the documented behaviour.
+ */
+export declare class ExternalContentService {
+  private readonly maxEntries;
+  private readonly storageKey;
+  private registry;
+  private sidebarService;
+  /** Resolves the destination behind an embedded tab, or `undefined` when it cannot be recovered. */
+  find(menuID: number): Observable<IExternalContentEntry | undefined>;
+  /** Remembers a menu so its embedded tab survives a page refresh. */
+  register(menu: SidebarMenu): void;
+  private readAllFromStorage;
+  private readFromStorage;
+  private toEntry;
+  private writeToStorage;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ExternalContentService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * Resolves the runtime placeholders in an external menu URL, and vets the result before it is
+ * handed to the browser.
+ *
+ * Placeholder syntax is `{name}`, case-sensitive, drawn from a **closed** set:
+ *
+ * | Token        | Source                                              |
+ * |--------------|-----------------------------------------------------|
+ * | `{email}`    | `ICurrentUserInfo.email`                            |
+ * | `{language}` | `TranslateService.currentLang`, then `defaultLang`  |
+ * | `{userId}`   | `ICurrentUserInfo.userID`                           |
+ * | `{userName}` | `ICurrentUserInfo.username`                         |
+ *
+ * The set is closed by construction rather than reflected off the stored user info, and that is a
+ * security property, not a style choice: `AuthenticationService` persists the entire sign-in
+ * response under `userInfo`, tokens included, so a reflective implementation would let a menu URL
+ * configured as `?t={token}` hand the JWT to a third party. No authentication token is ever
+ * substituted.
+ */
+export declare class ExternalUrlResolverService {
+  private authenticationService;
+  private translate;
+  /** Placeholder grammar, used only to *detect* tokens this version does not know. */
+  private readonly unknownPlaceholderPattern;
+  /**
+   * Whether `url` is an absolute `http`/`https` address.
+   *
+   * Rejects relative paths, malformed values, protocol-relative `//host/path` (which throws
+   * without a base), and the schemes that would execute rather than navigate: `javascript:`,
+   * `data:`, `blob:`, `file:`.
+   */
+  isAllowed(url: string): boolean;
+  /**
+   * Substitutes every known placeholder, URL-encoding each value.
+   *
+   * Because every value is percent-encoded, a placeholder must occupy one *whole* value — a full
+   * path segment, or a full query-parameter value. Encoding is what stops a display name that
+   * contains `&` from injecting an extra query parameter into the destination.
+   *
+   * A known placeholder with no value becomes an empty string; an unrecognized `{…}` is left
+   * exactly as configured, so a report URL that legitimately contains braces is not corrupted.
+   */
+  resolve(url: string): string;
+  private getPlaceholderValues;
+  private warnAboutUnknownPlaceholders;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ExternalUrlResolverService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * Streams top-bar notifications from a SignalR hub.
+ *
+ * The hub is configured via `AppConfig.notificationsEnabled` and `AppConfig.notificationsUrl`.
+ * When enabled, {@link start} opens a connection (authenticated with the current JWT) and
+ * listens for the server to push the notification list via the `ReceiveNotifications` client
+ * method. Consuming apps do not interact with this service directly — the top bar drives it.
+ */
+export declare class NotificationsService {
+  private authService;
+  private config;
+  private connection?;
+  private notifications$;
+  /** Whether the notifications feature is enabled (toggled on and given a hub URL). */
+  get isEnabled(): boolean;
+  /** Emits the current list of notifications. */
+  getNotifications(): Observable<INotification[]>;
+  /** Emits the number of unread notifications. */
+  getUnreadCount(): Observable<number>;
+  /** Marks every notification as read and notifies the hub. */
+  markAllAsRead(): void;
+  /** Marks a single notification as read (optimistically; the server reconciles on the next push). */
+  markAsRead(notification: INotification): void;
+  /** Opens the SignalR connection and starts receiving notifications. Idempotent and a no-op when disabled. */
+  start(): void;
+  /** Closes the SignalR connection. */
+  stop(): Promise<void>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<NotificationsService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare class OperationsHistoryService {
+  private config;
+  private http;
+  list(controllerName: string, entityID: number, serviceHistoryID: number, parameters: IListParameters): Observable<IOperationsHistoryList[]>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<OperationsHistoryService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare class ServicesHistoryService {
+  private config;
+  private http;
+  list(controllerName: string, entityID: number, parameters: IListParameters): Observable<IServicesHistoryList[]>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ServicesHistoryService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare class OperationsHistoryDataset extends DataGridDataset {
+  columns: IGridColumn[];
+  controllerName?: string;
+  protected operationsHistoryService: OperationsHistoryService;
+  private _serviceID?;
+  set serviceId(value: number | undefined);
+  constructor();
+  getData(params: IListParameters): Observable<IOperationsHistoryList[]>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<OperationsHistoryDataset, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare class ServicesHistoryDataset extends DataGridDataset {
+  columns: IGridColumn[];
+  controllerName?: string;
+  protected servicesHistoryService: ServicesHistoryService;
+  constructor();
+  getData(params: IListParameters): Observable<IServicesHistoryList[]>;
+  /**
+   * Widens the picked dates to whole local days and sends them as UTC instants.
+   *
+   * A date input yields `YYYY-MM-DD` -- no time, no zone -- while the history stores UTC instants
+   * and the backend compares what it is given. Sent as they are, "from the 5th to the 5th" is the
+   * single instant at midnight and matches nothing, and in a zone behind UTC it does not even
+   * cover the right day.
+   *
+   * Done here rather than in the filter form because the form is what the modal shows: reopening
+   * it patches these values straight back into the fields, which have to keep reading as the dates
+   * the person picked. This is the boundary where the request is built, so it is also the last
+   * point that sees every caller.
+   */
+  private withUtcPeriod;
+  /**
+   * The UTC wall clock of one end of a local day, written without a zone designator.
+   *
+   * Without one on purpose. `DateTime.TryParse` on the server reads a trailing `Z` as an instant
+   * and hands back the *machine's* local time for it, so the same request would mean different
+   * things on a server in UTC and one in UTC-3, and the stored column is plain UTC either way.
+   * Dropping the designator leaves the numbers alone, which is what the column holds.
+   */
+  private static toUtcInstant;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ServicesHistoryDataset, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * Displays an external destination inside an application tab.
+ *
+ * Routed as `/external-content/:menuID` — the destination itself never travels in the URL, so no
+ * one can hand-craft a link that makes the application frame an arbitrary site.
+ *
+ * A `TabViewBase` like any other screen, so its actions live in the ribbon rather than in a
+ * bar of its own: it must be routed under `DefaultTabViewComponent`, which is what renders the
+ * `#ribbon` template this view publishes. Use the exported `externalContentRoutes`.
+ */
+export declare class ExternalContentComponent extends TabViewBase implements OnInit, OnDestroy {
+  protected readonly frameUrl: WritableSignal<SafeResourceUrl | undefined>;
+  protected readonly isBlocked: WritableSignal<boolean>;
+  protected readonly isFrameLoading: WritableSignal<boolean>;
+  protected readonly isInsecure: WritableSignal<boolean>;
+  protected readonly isSlow: WritableSignal<boolean>;
+  protected readonly isUnavailable: WritableSignal<boolean>;
+  protected readonly label: WritableSignal<string>;
+  protected readonly resolvedUrl: WritableSignal<string>;
+  private activatedRoute;
+  private configs;
+  private document;
+  private externalContentService;
+  private externalUrlResolverService;
+  private sanitizer;
+  private slowHintTimeout?;
+  private tabService;
+  constructor();
+  ngOnDestroy(): void;
+  ngOnInit(): void;
+  protected onFrameLoad(): void;
+  protected onOpenInNewTab(): void;
+  protected onReload(): void;
+  private clearSlowHint;
+  private isMixedContent;
+  private isOriginAllowed;
+  private show;
+  private displayFrame;
+  private startSlowHint;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ExternalContentComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<ExternalContentComponent, "shared-external-content", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Route table for embedded external content. Spread it into `MainLayoutComponent`'s children:
+ *
+ * ```ts
+ * { path: '', component: MainLayoutComponent, canActivate: [AuthGuard], children: [
+ *   ...externalContentRoutes,
+ *   // the application's own features
+ * ] }
+ * ```
+ *
+ * Three things about the shape are load-bearing and must not be "simplified" away:
+ *
+ * - The path is nested one segment per route. `RouteHelper.getRouteURL` and
+ *   `CustomReuseStrategy.getUrlFromRoute` collect segments walking up the parent chain and then
+ *   reverse the flat list, so a route declared `'external-content/:menuID'` rebuilds as
+ *   `/:menuID/external-content` and every tab URL is wrong.
+ * - `DefaultTabViewComponent` hosts the view. It is what renders the `#ribbon` template the
+ *   component publishes, so dropping it leaves the Reload and Open-in-a-new-browser-tab actions
+ *   with nowhere to appear.
+ * - `FRAMEWORK_VIEW_TYPE` must be present. `TabsComponent` re-creates the tab after a page refresh
+ *   by looking for a `Details` or `List` view in the activated route tree, and navigates to `/`
+ *   when it finds neither — the embedded tab would vanish on F5.
+ */
+export declare const externalContentRoutes: Routes;
+export declare class OperationsHistoryChildListComponent extends ChildList<any> implements AfterViewInit {
+  private readonly modal;
+  private readonly operationTemplate;
+  set controllerName(value: string);
+  /**
+   * Filters to send with the list.
+   *
+   * The audit view applies its filters to the services grid and hands the same set here, because
+   * one of them -- whether to list only the audited record's own operations -- belongs to this
+   * list. The rest mean nothing to it, and the backend reads only what it recognises.
+   *
+   * `setFilters` refreshes the grid itself. With no service selected the dataset answers with an
+   * empty list rather than calling the backend, so a refresh then costs nothing.
+   */
+  set filters(value: {
+    [key: string]: string;
+  } | undefined);
+  set serviceID(value: number | undefined);
+  readonly selectedNewValues: WritableSignal<any | null>;
+  readonly selectedOldValues: WritableSignal<any | null>;
+  ngAfterViewInit(): void;
+  openModal(): void;
+  selectedRowChanged(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<OperationsHistoryChildListComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<OperationsHistoryChildListComponent, "shared-operations-history-child-list", never, {
+    "controllerName": {
+      "alias": "controllerName";
+      "required": false;
+    };
+    "filters": {
+      "alias": "filters";
+      "required": false;
+    };
+    "serviceID": {
+      "alias": "serviceID";
+      "required": false;
+    };
+  }, {}, never, never, true, never>;
+}
+export declare class OperationsHistoryModalComponent extends ModalBase {
+  private readonly modal;
+  readonly newValues: InputSignal<string | undefined>;
+  readonly oldValues: InputSignal<string | undefined>;
+  /** Delegates to the inner modal; a signal query, so it re-runs once that child resolves. */
+  readonly isModalShown: Signal<boolean>;
+  toggle(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<OperationsHistoryModalComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<OperationsHistoryModalComponent, "shared-operations-history-modal", never, {
+    "newValues": {
+      "alias": "newValues";
+      "required": false;
+      "isSignal": true;
+    };
+    "oldValues": {
+      "alias": "oldValues";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export declare class ServicesHistoryChildListComponent extends ChildList<any> implements AfterViewInit, OnInit {
+  private readonly serviceTemplate;
+  set controllerName(value: string);
+  /** Re-emits the grid's own filter changes, for a sibling list that has to follow them. */
+  readonly filtersChanged: OutputEmitterRef<{
+    [key: string]: string;
+  } | undefined>;
+  readonly selectedServiceID: WritableSignal<number | undefined>;
+  ngAfterViewInit(): void;
+  ngOnInit(): void;
+  selectedRowChanged(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ServicesHistoryChildListComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<ServicesHistoryChildListComponent, "shared-services-history-child-list", never, {
+    "controllerName": {
+      "alias": "controllerName";
+      "required": false;
+    };
+  }, {
+    "filtersChanged": "filtersChanged";
+  }, never, never, true, never>;
+}
+export declare class ServicesHistoryFilterComponent extends FiltersBase implements OnInit {
+  /**
+   * Catalog that resolves the people who can appear as the author of a change.
+   *
+   * There is no such catalog in this library -- who a user is belongs to the application -- so the
+   * author filter is offered only when one is supplied.
+   */
+  readonly usersCatalogEndpoint: InputSignal<string | undefined>;
+  protected readonly hasUsersCatalog: Signal<boolean>;
+  private get changedOnFromControl();
+  private get changedOnToControl();
+  ngOnInit(): void;
+  /**
+   * The control names are the filter names the backend reads, case insensitively: `name`,
+   * `changedByID`, `changedOnFrom`, `changedOnTo` and `onlyCurrentEntity` reach `AuditFilters` in
+   * ZWebAPI. The two dates are sent as picked and turned into UTC instants by
+   * {@link ServicesHistoryDataset}, which is the boundary where the request is built.
+   */
+  protected formSetup(): FormGroup<any>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ServicesHistoryFilterComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<ServicesHistoryFilterComponent, "shared-services-history-filter", never, {
+    "usersCatalogEndpoint": {
+      "alias": "usersCatalogEndpoint";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export declare class ServicesHistoryViewComponent extends TabViewBase {
+  readonly controllerName: ModelSignal<string>;
+  readonly entityID: ModelSignal<number | undefined>;
+  /**
+   * Catalog resolving the people who can appear as the author of a change, for the filter.
+   *
+   * Supplied through the route's `usersCatalogEndpoint` data, or bound directly. Without it the
+   * author filter is not offered -- see {@link ServicesHistoryFilterComponent}.
+   */
+  readonly usersCatalogEndpoint: ModelSignal<string | undefined>;
+  /**
+   * The filters applied to the services grid, forwarded to the operations grid.
+   *
+   * Only `onlyCurrentEntity` means anything to the operations list, and the backend reads only what
+   * it recognises, so the set is passed whole rather than picked apart here: a filter added later
+   * then reaches both lists without this having to learn about it.
+   */
+  protected readonly operationsFilters: WritableSignal<{
+    [key: string]: string;
+  } | undefined>;
+  private activatedRoute;
+  private dataProviderService;
+  constructor();
+  protected onFiltersChanged(filters?: {
+    [key: string]: string;
+  }): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ServicesHistoryViewComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<ServicesHistoryViewComponent, "shared-services-history-view", never, {
+    "controllerName": {
+      "alias": "controllerName";
+      "required": false;
+      "isSignal": true;
+    };
+    "entityID": {
+      "alias": "entityID";
+      "required": false;
+      "isSignal": true;
+    };
+    "usersCatalogEndpoint": {
+      "alias": "usersCatalogEndpoint";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "controllerName": "controllerNameChange";
+    "entityID": "entityIDChange";
+    "usersCatalogEndpoint": "usersCatalogEndpointChange";
+  }, never, never, true, never>;
+}
+export declare const ZAMBON_SHARED_I18N_ASSET_PATH = "assets/i18n/zambon-dev/shared";
+export declare const ZAMBON_SHARED_I18N_ASSET: AngularAssetPattern;
+export declare const ZAMBON_SHARED_I18N_RESOURCES: TranslationResource[];
+export interface ZambonSharedTranslateConfig {
+  defaultLanguage?: string;
+  appResources?: (string | TranslationResource)[];
+}
+export declare function createZambonSharedTranslateLoader(httpBackend: HttpBackend, appResources?: (string | TranslationResource)[]): MultiTranslateHttpLoader;
+export declare function provideZambonSharedTranslateLoader(appResources?: (string | TranslationResource)[]): Provider;
+export declare function provideZambonSharedTranslateService(config?: ZambonSharedTranslateConfig): EnvironmentProviders;
+export declare class LoginLayoutComponent {
+  static ɵfac: i0.ɵɵFactoryDeclaration<LoginLayoutComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<LoginLayoutComponent, "shared-login-layout", never, {}, {}, never, never, true, never>;
+}
+export declare class MainLayoutComponent implements OnInit, OnDestroy {
+  private readonly logoutModal;
+  private authenticationService;
+  private destroy$;
+  private externalContentService;
+  private externalUrlResolverService;
+  private router;
+  private sidebarService;
+  private tabService;
+  /** Application version (from AppConfig) projected into the sidebar footer. */
+  protected appVersion: string;
+  ngOnDestroy(): void;
+  ngOnInit(): void;
+  onLogoutClick(): void;
+  onLogoutConfirm(): void;
+  private openExternalMenu;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MainLayoutComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MainLayoutComponent, "shared-main-layout", never, {}, {}, never, never, true, never>;
+}
+export declare class BrandComponent {
+  private config;
+  protected get appName(): string;
+  protected get companyName(): string;
+  protected get logoUrl(): string | undefined;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BrandComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<BrandComponent, "shared-brand", never, {}, {}, never, never, true, never>;
+}
+export declare class EnvironmentBadgeComponent {
+  private config;
+  /** CSS modifier class for the current environment, falling back to a neutral style. */
+  protected get badgeClass(): string;
+  /** Normalized environment key (uppercase, trimmed). */
+  protected get environment(): string;
+  /** The badge is hidden in production and when no environment is configured. */
+  protected get isVisible(): boolean;
+  static ɵfac: i0.ɵɵFactoryDeclaration<EnvironmentBadgeComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<EnvironmentBadgeComponent, "shared-environment-badge", never, {}, {}, never, never, true, never>;
+}
+export declare class NotificationsComponent implements OnInit {
+  readonly dropdown: Signal<ElementRef<HTMLDivElement> | undefined>;
+  private notificationsService;
+  private router;
+  protected notifications$: Observable<INotification[]>;
+  protected readonly showDropdown: WritableSignal<boolean>;
+  protected unreadCount$: Observable<number>;
+  /** Whether the notifications feature is enabled; when false the bell is not rendered. */
+  get isEnabled(): boolean;
+  ngOnInit(): void;
+  onDropdownClick(): void;
+  onMarkAllAsRead(): void;
+  onNotificationClick(notification: INotification): void;
+  protected documentClick(event: MouseEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<NotificationsComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<NotificationsComponent, "shared-notifications", never, {}, {}, never, never, true, never>;
+}
+export declare class TopBarComponent {
+  /** Emitted when the logout button is clicked. */
+  readonly logout: OutputEmitterRef<void>;
+  onLogoutClick(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<TopBarComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<TopBarComponent, "shared-top-bar", never, {}, {
+    "logout": "logout";
+  }, never, never, true, never>;
+}
+export declare class UserProfileComponent implements OnInit {
+  private authenticationService;
+  protected readonly user: WritableSignal<ICurrentUserInfo | null>;
+  /** Up to two uppercase initials derived from the user's name, used when no picture is set. */
+  protected get initials(): string;
+  protected get name(): string;
+  protected get pictureUrl(): string | undefined;
+  protected get position(): string;
+  ngOnInit(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<UserProfileComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<UserProfileComponent, "shared-user-profile", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Pipe that bypasses Angular's built-in HTML sanitization.
+ *
+ * **WARNING: This pipe introduces XSS (Cross-Site Scripting) risk.**
+ * It marks the provided HTML string as trusted, meaning Angular will
+ * render it without any sanitization. Malicious content such as
+ * `<script>` tags, inline event handlers (`onerror`, `onclick`, etc.),
+ * and `javascript:` URLs will be executed in the user's browser.
+ *
+ * ### Safe usage
+ * - Server-rendered HTML from **trusted, internal APIs** that never
+ *   include user-generated content (e.g., admin-authored rich text
+ *   that is sanitized server-side before storage).
+ * - Static HTML snippets defined in application code.
+ *
+ * ### Unsafe usage (DO NOT use for these)
+ * - Any value that originates from user input (form fields, query
+ *   params, URL fragments, file uploads).
+ * - Third-party API responses whose content you do not control.
+ * - Database fields that may contain unsanitized user submissions.
+ *
+ * @example
+ * // Safe — trusted server content
+ * <div [innerHTML]="trustedServerHtml | bypassHtmlSanitizer"></div>
+ *
+ * // UNSAFE — user-provided content (use Angular’s default sanitization instead)
+ * <div [innerHTML]="comment.body | bypassHtmlSanitizer"></div>  // ❌ XSS risk
+ * <div [innerHTML]="comment.body"></div>                        // ✅ Angular sanitizes automatically
+ */
+export declare class BypassHtmlSanitizerPipe implements PipeTransform {
+  private sanitizer;
+  transform(html: string): SafeHtml;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BypassHtmlSanitizerPipe, never>;
+  static ɵpipe: i0.ɵɵPipeDeclaration<BypassHtmlSanitizerPipe, "bypassHtmlSanitizer", true>;
+}
+export declare class EnumLabelPipe implements PipeTransform {
+  transform(value?: number, enumType?: any): string;
+  static ɵfac: i0.ɵɵFactoryDeclaration<EnumLabelPipe, never>;
+  static ɵpipe: i0.ɵɵPipeDeclaration<EnumLabelPipe, "enumLabel", true>;
+}
+export declare class UtcDatePipe implements PipeTransform {
+  private static readonly timeZoneMarker;
+  transform(value?: Date | string): Date | null;
+  static ɵfac: i0.ɵɵFactoryDeclaration<UtcDatePipe, never>;
+  static ɵpipe: i0.ɵɵPipeDeclaration<UtcDatePipe, "utcDate", true>;
+}