import { ActivatedRouteSnapshot, Router, RouterStateSnapshot } from "@angular/router";
import { AuthJwtService } from "@myrmidon/auth-jwt-login";
import * as i0 from "@angular/core";
import { InjectionToken } from "@angular/core";
import { HttpClient } from "@angular/common/http";
import { DataPage, EnvService, ErrorService, ErrorWrapper } from "@myrmidon/ngx-tools";
import { Observable } from "rxjs";
import { DataPinDefinition, DataPinInfo, FacetDefinition, FlagDefinition, Item, ItemFilter, ItemInfo, LayerHint, LayerPartInfo, Part, PartDefinition, PartGroup, ThesauriSet, Thesaurus, ThesaurusFilter } from "@myrmidon/cadmus-core";
import { UserFilter } from "@myrmidon/auth-jwt-admin";
export declare class EditorGuardService {
  private _router;
  private _authService;
  constructor(_router: Router, _authService: AuthJwtService);
  private redirectToLogin;
  canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): boolean;
  static ɵfac: i0.ɵɵFactoryDeclaration<EditorGuardService, never>;
  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
}
/**
 * Editor settings service. These settings are stored server-side.
 */
export declare class EditorSettingsService {
  private _http;
  private _error;
  private _env;
  constructor(_http: HttpClient, _error: ErrorService, _env: EnvService);
  /**
   * Get the setting with the specified ID. If the setting is not found,
   * an empty object is returned.
   * @param id The setting's ID.
   */
  getSetting<T>(id: string): Observable<T>;
  /**
   * Add or update the setting with the specified ID.
   * @param id The setting's ID.
   * @param setting The setting object to add.
   */
  addSetting<T>(id: string, setting: T): Observable<T>;
  /**
   * Delete the setting with the specified ID.
   * @param id The setting's ID.
   */
  deleteSetting(id: string): Observable<any>;
  static ɵfac: i0.ɵɵFactoryDeclaration<EditorSettingsService, never>;
  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
}
/**
 * An entry in the facet model settings. The key is the part or fragment
 * type ID, and the value is metadata about whether the part is a base text
 * part (applicable to parts only) and the list of thesauri IDs to use
 * for the part or fragment. Required thesauri are prefixed by an asterisk.
 */
export interface FacetModelSettingsEntry {
  [key: string]: {
    baseText?: boolean;
    thesauriIds?: string[];
  };
}
/**
 * The facet model settings, which is a map of part and fragment type IDs to
 * their metadata for the purpose of facet editing.
 */
export interface FacetModelSettings {
  parts: FacetModelSettingsEntry;
  fragments?: FacetModelSettingsEntry;
}
export declare class FacetService {
  private _http;
  private _error;
  private _env;
  private _settings;
  constructor(_http: HttpClient, _error: ErrorService, _env: EnvService, _settings: EditorSettingsService);
  /**
   * Get a list of facets.
   * @returns Observable with facets array.
   */
  getFacets(): Observable<FacetDefinition[]>;
  /**
   * Get the facet with the specified ID.
   *
   * @param id The facet's ID.
   */
  getFacet(id: string): Observable<FacetDefinition>;
  /**
   * Get the facet assigned to the item with the specified ID.
   *
   * @param id The item's ID.
   */
  getFacetFromItemId(id: string): Observable<FacetDefinition>;
  /**
   * Get a list of all the parts defined in the specified facet.
   *
   * @param id The facet ID.
   * @param idIsItem True if the received ID refers to an item's ID rather
   * than to the facet ID. In this case, the item's facet will be retrieved
   * first, and then used to get the requested result.
   * @param noRoles True to ignore the roles when collecting parts from
   *  facets. In this case, you will get just 1 part for each part type.
   * @returns Observable with part definitions array.
   */
  getFacetParts(id: string, idIsItem: boolean, noRoles?: boolean): Observable<PartDefinition[]>;
  /**
   * Get the text layer part type ID if any.
   * @returns Observable of an object with property typeId=result or null.
   */
  getTextLayerPartTypeId(): Observable<{
    typeId: string;
  }>;
  /**
   * Get the color of the part with the specified type and role IDs, inside
   * the specified facet (if any).
   *
   * @param typeId The part's type ID.
   * @param roleId The part's optional role ID.
   * @param facet The facet definition including the part being requested.
   */
  getPartColor(typeId: string, roleId: string | undefined, facet: FacetDefinition | undefined): string;
  /**
   * Add or update the specified facet.
   * @param facet The facet to add or update.
   */
  addFacet(facet: FacetDefinition): Observable<FacetDefinition>;
  /**
   * Delete the facet with the specified ID.
   * @param id The facet ID.
   */
  deleteFacet(id: string): Observable<void>;
  /**
   * Build a baseline FacetModelSettings from the facet definitions alone,
   * without any server-side settings. This is used as a fallback when no
   * "models" setting is stored on the server.
   *
   * For each unique typeId found across all facets' part definitions:
   * - an entry is added to `parts`, keyed by typeId;
   * - if any part with that typeId has a roleId starting with "fr.", the part
   *   entry gets `baseText: true`, and the roleId is also added to `fragments`.
   * No `thesauriIds` are included because that information cannot be derived
   * from FacetDefinition alone.
   */
  private buildDefaultSettings;
  /**
   * Merge server-loaded settings on top of the pre-built defaults.
   * Entries present in `loaded` override or extend those in `defaults`;
   * entries only in `defaults` are kept as-is.
   */
  private mergeSettings;
  /**
   * Get the facet model settings, merging server-stored settings with a
   * baseline derived from the facet definitions.
   *
   * Strategy:
   * 1. Load all facets and build a minimal but valid FacetModelSettings from
   *    their part definitions (see buildDefaultSettings). This guarantees
   *    that every part/fragment known to the profile is represented, even when
   *    the server has no "models" setting stored yet.
   * 2. Load the "models" setting from the server and deep-merge it on top of
   *    the defaults (server values win). When no setting has been configured
   *    the server returns an empty object, so the merge leaves the defaults
   *    intact. A catchError guards against genuine network failures and also
   *    returns the defaults in that case.
   */
  getFacetModelSettings(): Observable<FacetModelSettings>;
  static ɵfac: i0.ɵɵFactoryDeclaration<FacetService, never>;
  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
}
export declare class FlagService {
  private _http;
  private _error;
  private _env;
  constructor(_http: HttpClient, _error: ErrorService, _env: EnvService);
  getFlags(): Observable<FlagDefinition[]>;
  addFlags(flags: FlagDefinition[]): Observable<void>;
  static ɵfac: i0.ɵɵFactoryDeclaration<FlagService, never>;
  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
}
export declare const GRAPH_API_PATH: InjectionToken<string>;
export declare enum NodeSourceType {
  User = 0,
  Item = 1,
  Part = 2,
  Thesaurus = 3,
  Implicit = 4
}
export interface Node {
  id: number;
  isClass?: boolean;
  label: string;
  sourceType: NodeSourceType;
  tag?: string;
  sid?: string;
}
export interface UriNode extends Node {
  uri: string;
}
interface NodeFilterBase {
  uid?: string;
  isClass?: boolean;
  tag?: string;
  label?: string;
  sourceType?: NodeSourceType;
  sid?: string;
  isSidPrefix?: boolean;
  classIds?: number[];
}
export interface NodeFilter extends NodeFilterBase {
  linkedNodeId?: number;
  linkedNodeRole?: 'S' | 'O';
}
export interface Triple {
  id: number;
  subjectId: number;
  predicateId: number;
  objectId?: number;
  objectLiteral?: string;
  objectLiteralIx?: string;
  literalType?: string;
  literalLanguage?: string;
  literalNumber?: number;
  sid?: string;
  tag?: string;
}
export interface UriTriple extends Triple {
  subjectUri: string;
  predicateUri: string;
  objectUri?: string;
}
export interface TripleGroup {
  predicateId: number;
  predicateUri: string;
  count: number;
}
export interface LiteralFilter {
  literalPattern?: string;
  literalType?: string;
  literalLanguage?: string;
  minLiteralNumber?: number;
  maxLiteralNumber?: number;
}
export interface TripleFilter extends LiteralFilter {
  subjectId?: number;
  predicateIds?: number[];
  notPredicateIds?: number[];
  hasLiteralObject?: boolean;
  objectId?: number;
  sid?: string;
  isSidPrefix?: boolean;
  tag?: string;
}
export interface LinkedNodeFilter extends NodeFilterBase {
  /**
   * The other node identifier, which is the subject node
   * ID when isObject is true, otherwise the object node ID.
   */
  otherNodeId: number;
  predicateId: number;
  /**
   * Whether the node to match is the object (true) or
   * the subject (false) of the triple having predicate
   * predicateId.
   */
  isObject?: boolean;
}
export interface LinkedLiteralFilter extends LiteralFilter {
  subjectId?: number;
  predicateId?: number;
}
/**
 * Cadmus semantic graph service.
 */
export declare class GraphService {
  private _http;
  private _error;
  private _env;
  private readonly _apiPath;
  constructor(_http: HttpClient, _error: ErrorService, _env: EnvService, apiPath?: string);
  /**
   * Get the specified page of graph nodes.
   *
   * @param filter The nodes filter.
   * @returns A page of nodes.
   */
  getNodes(pageNumber: number, pageSize: number, filter: NodeFilter): Observable<DataPage<UriNode>>;
  /**
   * Get the specified set of nodes.
   *
   * @param ids The nodes IDs.
   * @returns List of nodes/nulls.
   */
  getNodeSet(ids: number[]): Observable<(UriNode | null)[]>;
  /**
   * Get the node with the specified ID.
   *
   * @param id The node's ID.
   * @returns The node.
   */
  getNode(id: number): Observable<UriNode>;
  /**
   * Get the node with the specified URI.
   *
   * @param uri The node's URI.
   * @returns The node.
   */
  getNodeByUri(uri: string): Observable<UriNode>;
  /**
   * Add or update the specified node. A new node has id=0 and uri set;
   * an existing node has its id.
   *
   * @param node The node to add.
   * @returns The added node.
   */
  addNode(node: UriNode): Observable<UriNode>;
  /**
   * Delete the node with the specified ID.
   *
   * @param id The node's ID.
   */
  deleteNode(id: number): Observable<any>;
  private applyTripleFilter;
  /**
   * Get the specified page of triples.
   *
   * @param filter The filter.
   * @returns The page.
   */
  getTriples(pageNumber: number, pageSize: number, filter: TripleFilter): Observable<DataPage<UriTriple>>;
  /**
   * Get the triple with the specified ID.
   *
   * @param id The triple's ID.
   * @returns The triple.
   */
  getTriple(id: number): Observable<UriTriple>;
  /**
   * Add or update the specified triple.
   *
   * @param triple The triple to add.
   * @returns The added triple.
   */
  addTriple(triple: Triple): Observable<Triple>;
  /**
   * Delete the triple with the specified ID.
   *
   * @param id The triple's ID.
   */
  deleteTriple(id: number): Observable<any>;
  private applyLiteralFilter;
  /**
   * Get the specified page of triples grouped by their property.
   *
   * @param filter The filter.
   * @returns The page of triples.
   */
  getTripleGroups(pageNumber: number, pageSize: number, filter: TripleFilter): Observable<DataPage<TripleGroup>>;
  /**
   * Get linked nodes.
   * @param filter The filter.
   * @returns Observable with data page.
   */
  getLinkedNodes(pageNumber: number, pageSize: number, filter: LinkedNodeFilter): Observable<DataPage<UriNode>>;
  /**
   * Get linked literals.
   * @param filter The filter.
   * @returns Observable with data page.
   */
  getLinkedLiterals(pageNumber: number, pageSize: number, filter: LinkedLiteralFilter): Observable<DataPage<UriTriple>>;
  static ɵfac: i0.ɵɵFactoryDeclaration<GraphService, [null, null, null, {
    optional: true;
  }]>;
  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
}
export declare class ItemBrowserService {
  private _http;
  private _error;
  private _env;
  constructor(_http: HttpClient, _error: ErrorService, _env: EnvService);
  /**
   * Get the array of items browser IDs registered in the server.
   *
   * @returns Observable with strings array.
   */
  getBrowserIds(): Observable<string[]>;
  /**
   * Get the specified page of items from the specified items browser.
   *
   * @param browserId The items browser ID.
   * @param pageNumber The items page number.
   * @param pageSize The items page size.
   * @param filters The filters object.
   */
  getItems(browserId: string, pageNumber: number, pageSize: number, filters: any): Observable<DataPage<ItemInfo>>;
  static ɵfac: i0.ɵɵFactoryDeclaration<ItemBrowserService, never>;
  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
}
export interface RolePartId {
  roleId: string;
  partId: string;
}
export declare class ItemService {
  private _http;
  private _error;
  private _env;
  constructor(_http: HttpClient, _error: ErrorService, _env: EnvService);
  /**
   * Get a page of items matching the specified filters.
   *
   * @param filter The items filter.
   * @returns Observable with paged result.
   */
  getItems(filter: ItemFilter, pageNumber?: number, pageSize?: number): Observable<DataPage<ItemInfo>>;
  /**
   * Search the items using the specified query.
   *
   * @param query The query text.
   * @param pageNumber The page number.
   * @param pageSize The page size.
   */
  searchItems(query: string, pageNumber: number, pageSize: number): Observable<ErrorWrapper<DataPage<ItemInfo>>>;
  /**
   * Search the item's parts pins using the specified query.
   *
   * @param query The query text.
   * @param pageNumber The page number.
   * @param pageSize The page size.
   */
  searchPins(query: string, pageNumber: number, pageSize: number): Observable<ErrorWrapper<DataPage<DataPinInfo>>>;
  /**
   * Get the item with the specified ID.
   * @param id Items filter.
   * @param parts True to get also item's parts.
   * @param noErrIfNotFound True to return null if the item is not found.
   * @returns Observable with paged result.
   */
  getItem(id: string, parts: boolean, noErrIfNotFound?: boolean): Observable<Item | null>;
  /**
   * Delete the item with the specified ID.
   * @param id The item's ID.
   * @returns Observable with result.
   */
  deleteItem(id: string): Observable<any>;
  /**
   * Add or update the specified item.
   * @param item The item.
   * @returns Observable with result.
   */
  addItem(item: Item): Observable<Item>;
  /**
   * Generate the specified count of items using the specified item as a template.
   *
   * @param count The count of items to generate.
   * @param itemId The ID of the item to be used as a template.
   * @param title The title template for the new item. It can contain
   * a placeholder like {0} for the item number. This can use any
   * formatting supported by the backend (C# `string.Format`).
   * @param flags The flag(s) to be set for each new item.
   */
  generateItems(count: number, itemId: string, title: string, flags?: number): Observable<any>;
  /**
   * Get a user-facing message from an HTTP error response, using the
   * details of the problem returned by the server when available.
   * @param error The error response.
   * @returns The message.
   */
  private static getErrorMessage;
  /**
   * Download the item with the specified ID as a JSON file, which can
   * later be uploaded via uploadItem.
   * @param id The item's ID.
   * @param parts True to include the item's parts (default).
   * @returns Observable with the JSON file content. On error, the
   * observable fails with a user-facing message.
   */
  downloadItem(id: string, parts?: boolean): Observable<Blob>;
  /**
   * Upload the specified JSON file, as generated by downloadItem, to add
   * a new item with its parts. The upload fails if an item with the same
   * ID already exists; if the item or any of its parts were deleted, they
   * get a new ID.
   * @param file The JSON file.
   * @returns Observable with the imported item, including its parts with
   * their final IDs. On error, the observable fails with a user-facing
   * message.
   */
  uploadItem(file: File): Observable<Item>;
  /**
   * Get the item's part with the specified ID.
   * @param id The part ID.
   * @returns Observable with result. If the part ID is null,
   * a null part will be returned.
   */
  getPart(id: string): Observable<Part | null>;
  /**
   * From the item with the specified ID, get the first (and normally unique)
   * part matching the specified type and/or role.
   * @param id The item ID.
   * @param type The part type or "any".
   * @param role The part role or "default".
   * @param noErrIfNotFound If true, no error will be thrown if the part is not found.
   * Rather, null will be returned.
   * @returns Observable with result.
   */
  getPartFromTypeAndRole(id: string, type: string, role?: string, noErrIfNotFound?: boolean): Observable<Part | null>;
  /**
   * Check if the item with the specified ID has a part of the specified type
   * and role.
   * @param id The item ID.
   * @param type The part type of "any".
   * @param role The part role or "default".
   * @returns Observable with result.
   */
  partWithTypeAndRoleExists(id: string, type: string, role?: string): Observable<boolean>;
  /**
   * Get the base text (if any) of the item with the specified ID.
   * @param id The item's ID.
   * @returns An observable of an object with a "text" property.
   */
  getBaseTextPart(id: string): Observable<{
    part: Part;
    text: string;
  }>;
  /**
   * Get the information about all the layer parts in the item with
   * the specified ID. If parameter "absent" is true, the layer parts are added
   * also from the item's facet, even if absent from the database. This produces
   * the full list of all the possible layer parts which could be connected
   * to the given item.
   * Remember that you can have multiple parts of the same type in an item,
   * provided that you specify different roles for them.
   * This happens for the layer part: it is a unique type, but it differs
   * according to its role. Thus, the role here identifies the layer, and
   * in fact it is equal to the layer fragment type ID.
   * Should you need to have several layers of the same type (e.g. 2 comment
   * layers), you can add a layer-specific role to the fragment type ID,
   * by appending it preceded by a colon. For instance, the fragment type ID
   * "fr.it.vedph.comment:scholarly" has the ID proper followed by ":"
   * and its role ("scholarly").
   * Thus, the role IDs (=layer type) for layer parts may just be equal
   * to the fragment type ID (e.g. "fr.it.vedph.comment"), or include
   * this + colon + role ID proper (e.g."fr.it.vedph.comment:scholarly").
   * @param id The item's ID.
   * @returns Observable with array of RolePartId's.
   */
  getItemLayerInfo(id: string, absent: boolean): Observable<LayerPartInfo[]>;
  /**
   * Get the data pins of the part with the specified ID.
   * @param id The part ID.
   * @returns Observable with array of IDataPin's.
   */
  getPartPins(id: string): Observable<RolePartId[]>;
  /**
   * Get the data pin definitions for the part or fragment
   * with the specified type ID.
   * @param typeId The type ID (e.g. "it.vedph.token-text" or
   * "fr.it.vedph.comment").
   * @returns Observable with array of definitions.
   */
  getDataPinDefinitions(typeId: string): Observable<DataPinDefinition[]>;
  /**
   * Get the layer part break chance, a number indicating whether the layer part
   * with the specified ID might potentially be broken because of changes in its
   * base text.
   * @param id The layer part's ID.
   * @returns An object with a chance property equal to 0=not broken, 1=potentially
   * broken, or 2=surely broken.
   */
  getLayerPartBreakChance(id: string): Observable<{
    chance: number;
  }>;
  /**
   * Get the layer part reconciliation hints, one for each fragment.
   * @param id The layer part's ID.
   * @returns A list of layer hints, one per fragment.
   */
  getLayerPartHints(id: string): Observable<LayerHint[]>;
  /**
   * Apply a set of patches to the specified layer part.
   *
   * @param id The layer part ID.
   * @param patches The array of patch instructions.
   */
  applyLayerPatches(id: string, patches: string[]): Observable<Part>;
  /**
   * Delete the part with the specified ID.
   * @param id The part's ID.
   * @returns Observable with result.
   */
  deletePart(id: string): Observable<any>;
  /**
   * Add or update the specified part.
   * @param part The part.
   * @returns Observable with result.
   */
  addPart(part: Part): Observable<Part>;
  /**
   * Set the flags value for all the specified items.
   *
   * @param ids The item IDs.
   * @param flags The flags value to be set.
   */
  setItemFlags(ids: string[], flags: number): Observable<any>;
  /**
   * Get the specified page of item group IDs.
   * @param pageNumber The page number.
   * @param pageSize The page size.
   * @param filter The optional ID filter. If specified, it should be included
   * in each group ID returned.
   * @returns Page.
   */
  getItemGroupIds(pageNumber: number, pageSize: number, filter?: string): Observable<DataPage<string>>;
  /**
   * Set the group ID value for all the specified items.
   *
   * @param ids The item IDs.
   * @param groupId The group ID value to be set.
   */
  setItemGroupId(ids: string[], groupId: string): Observable<any>;
  /**
   * Set the thesaurus scope for all the specified parts.
   *
   * @param ids The part IDs.
   * @param scope The scope to be set.
   */
  setPartThesaurusScope(ids: string[], scope: string): Observable<any>;
  /**
   * Group the specified item's parts according to the specified part
   * definitions. This is used to list item's parts in editing it.
   * Each part is grouped under a specific group according to its groupKey,
   * and the parts of each group are sorted according to their sortyKey.
   *
   * @param parts The parts to group.
   * @param partDefs The part definitions to use for grouping.
   * @return The groups.
   */
  groupParts(parts: Part[], partDefs: PartDefinition[]): PartGroup[];
  /**
   * Vanilla groupBy function.
   * See https://gomakethings.com/a-vanilla-js-equivalent-of-lodashs-groupby-method.
   *
   * @param array The array.
   * @param criteria The grouping criteria (either a function receiving the
   * item and returning a key, or a property name).
   * @returns Grouped array.
   */
  private groupBy;
  /**
   * Let the server build metadata for the target item looking at its parts
   * and return it. This is used when users request to autogenerate the title
   * and/or description of an item.
   *
   * @param id The item's ID.
   * @param targets The target metadata in item: T=title, D=description.
   * @returns Object with requested target keys when found, else empty.
   */
  getItemMetadata(id: string, targets?: string): Observable<{
    [key: string]: string;
  }>;
  static ɵfac: i0.ɵɵFactoryDeclaration<ItemService, never>;
  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
}
/**
 * A message payload, with an ID and optional data.
 */
export interface MessagePayload<T> {
  id: string;
  data?: T;
}
/**
 * A simple messaging service, allowing to send messages to subscribers.
 * This is typically used to send messages between components.
 */
export declare class MessagingService {
  private _subject;
  /**
   * Observable of messages.
   */
  get messages$(): import("rxjs").Observable<MessagePayload<any>>;
  /**
   * Send a message to subscribers.
   *
   * @param id The message ID.
   * @param data The optional data to send.
   */
  sendMessage<T>(id: string, data?: T): void;
  static ɵfac: i0.ɵɵFactoryDeclaration<MessagingService, never>;
  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
}
export declare class OperatorGuardService {
  private _router;
  private _authService;
  constructor(_router: Router, _authService: AuthJwtService);
  private redirectToLogin;
  canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): boolean;
  static ɵfac: i0.ɵɵFactoryDeclaration<OperatorGuardService, never>;
  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
}
/**
 * Result of an object rendition.
 */
export interface RenditionResult {
  result: string;
}
export interface AnnotatedTextRange {
  start: number;
  end: number;
  fragmentIds?: string[];
  text?: string;
}
/**
 * A text span used in rendering.
 */
export interface StringPair {
  name: string;
  value?: string;
}
/**
 * A segment of a text used in export/preview.
 */
export interface ExportedSegment {
  sourceId: number;
  type?: string;
  text?: string;
  features?: StringPair[];
  tags?: string[];
  payloads?: any[];
}
/**
 * Cadmus preview API service.
 */
export declare class PreviewService {
  private _http;
  private _error;
  private _env;
  constructor(_http: HttpClient, _error: ErrorService, _env: EnvService);
  /**
   * Gets all the Cadmus objects keys registered for preview.
   *
   * @param type A character: J=JSON renderer keys, F=text flattener keys,
   * C=item composer keys. The default is J.
   * @returns List of unique keys.
   */
  getKeys(type: string): Observable<string[]>;
  /**
   * Render the part with the specified ID.
   *
   * @param itemId The item's ID.
   * @param partId The part's ID.
   * @returns Rendition.
   */
  renderPart(itemId: string, partId: string): Observable<RenditionResult>;
  /**
   * Render the fragment at the specified index in the part with the specified
   * ID.
   *
   * @param itemId The item's ID.
   * @param partId The part's ID.
   * @param frIndex The fragment's index (0-N).
   * @returns Rendition.
   */
  renderFragment(itemId: string, partId: string, frIndex: number): Observable<RenditionResult>;
  /**
   * Gets the text segments built by flattening the text part with the
   * specified ID with all the layers specified.
   *
   * @param textPartId The base text part's ID.
   * @param layerPartIds The layer parts IDs.
   */
  getTextSegments(textPartId: string, layerPartIds: string[]): Observable<ExportedSegment[]>;
  static ɵfac: i0.ɵɵFactoryDeclaration<PreviewService, never>;
  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
}
export interface ItemEditFrameStats {
  start?: Date;
  end?: Date;
  createdCount: number;
  updatedCount: number;
  deletedCount: number;
}
export declare class StatsService {
  private _http;
  private _error;
  private _env;
  constructor(_http: HttpClient, _error: ErrorService, _env: EnvService);
  getEditFrameStats(start: Date | string, end: Date | string, interval: string, frameLimit?: number): Observable<ItemEditFrameStats[]>;
  static ɵfac: i0.ɵɵFactoryDeclaration<StatsService, never>;
  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
}
export declare class ThesaurusService {
  private _http;
  private _error;
  private _env;
  constructor(_http: HttpClient, _error: ErrorService, _env: EnvService);
  private getFilterParams;
  /**
   * Get the list of all thesauri IDs or of the subset of them matching the filter.
   * @param filter The optional filter to use.
   * @returns Array of IDs.
   */
  getThesaurusIds(filter?: ThesaurusFilter): Observable<string[]>;
  /**
   * Check whether a thesaurus with the specified ID exists.
   *
   * @param id The ID of the thesaurus to check for.
   * @returns Promise having true/false on resolution.
   */
  thesaurusExists(id: string): Promise<boolean>;
  /**
   * Gets the tags set with the specified ID.
   * @param id string The tag set ID.
   * @param emptyIfNotFound True to return an empty thesaurus when the requested
   * thesaurus ID is not found, rather than getting a 404.
   * @returns Tag set.
   */
  getThesaurus(id: string, emptyIfNotFound?: boolean): Observable<Thesaurus>;
  /**
   * Get a list of thesauri IDs whose target ID is the specified one.
   * @param targetId The target ID of the thesaurus.
   * @returns An ordered list of thesauri IDs whose target ID is targetId.
   */
  getThesaurusAliases(targetId: string): Observable<string[]>;
  /**
   * Get the requested thesauri in a batch.
   * @param ids The IDs of the requested thesauri.
   * @returns An object where each key is the purged thesaurus ID with value
   * equal to the thesaurus model.
   */
  getThesauriSet(ids: string[]): Observable<ThesauriSet>;
  /**
   * Get a page of thesauri.
   *
   * @param filter The filter.
   */
  getThesauri(filter: ThesaurusFilter, pageNumber?: number, pageSize?: number): Observable<DataPage<Thesaurus>>;
  /**
   * Add or update the specified thesaurus.
   *
   * @param thesaurus The thesaurus.
   */
  addThesaurus(thesaurus: Thesaurus): Observable<any>;
  /**
   * Delete the specified thesaurus.
   *
   * @param id The thesaurus ID.
   */
  deleteThesaurus(id: string): Observable<any>;
  /**
   * Get the thesaurus scoped ID from the corresponding non-scoped thesaurus ID
   * and the specified scope ID. This just suffixes the thesaurus ID with
   * the scope ID prefixed by a dot, before the language ID. For instance,
   * a thesaurus ID "witnesses@en" with a scope ID "lucr" would become
   * "witnesses.lucr@en". If the thesaurus ID starts with an exclamation mark,
   * which means that it must not be scoped, this function will return it
   * without the leading mark.
   *
   * @param id The thesaurus ID.
   * @param scopeId The scope ID, or undefined when you just want to strip off
   * the leading exclamation mark if any.
   */
  getScopedId(id: string, scopeId?: string): string;
  /**
   * Get the unscoped thesaurus ID from the specified ID, also stripping
   * any language suffix off and any leading "!". For instance, an ID like
   * "apparatus-witnesses.verg-eclo@en" becomes "apparatus-witnesses".
   *
   * @param id The thesaurus ID.
   */
  getUnscopedId(id: string): string;
  static ɵfac: i0.ɵɵFactoryDeclaration<ThesaurusService, never>;
  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
}
/**
 * Generic upload service.
 */
export declare class UploadService {
  private http;
  constructor(http: HttpClient);
  /**
   * Upload the specified file to the specified URL.
   * @param file The file to upload.
   * @param url The upload URL.
   * @param options The options. For instance, you can pass { reportProgress: true}
   * to get upload progress events.
   * @returns Observable.
   */
  uploadFile(file: File, url: string, options?: any): Observable<any>;
  static ɵfac: i0.ɵɵFactoryDeclaration<UploadService, never>;
  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
}
export declare class UserLevelService {
  private _authService;
  constructor(_authService: AuthJwtService);
  /**
   * Get the authorization level of the current user if any.
   * @returns 4-1 for admin, editor, operator, visitor; else 0.
   */
  getCurrentUserLevel(): number;
  static ɵfac: i0.ɵɵFactoryDeclaration<UserLevelService, never>;
  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
}
/**
 * A Cadmus user with his roles.
 */
export interface UserWithRoles {
  user: {
    id: string;
    firstName: string;
    lastName: string;
    userName: string;
    email: string;
  };
  roles: string[];
}
/**
 * Cadmus users service.
 */
export declare class UserService {
  private _http;
  private _error;
  private _env;
  constructor(_http: HttpClient, _error: ErrorService, _env: EnvService);
  getAllUsers(): Observable<DataPage<UserWithRoles>>;
  getUsers(filter: UserFilter, pageNumber?: number, pageSize?: number): Observable<DataPage<UserWithRoles>>;
  /**
   * Get the user with the specified name.
   *
   * @param name The user name.
   * @returns Observable with the user, or undefined if not found.
   */
  getUser(name: string): Observable<UserWithRoles | undefined>;
  static ɵfac: i0.ɵɵFactoryDeclaration<UserService, never>;
  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
}
export declare function editorGuard(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): boolean;
export declare function operatorGuard(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): boolean;