@arsedizioni/ars-utils 19.5.74 → 20.0.2

package/clipper.common/index.d.ts

@@ -1,5 +1,1411 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@arsedizioni/ars-utils/clipper.common" />
-export * from './public_api';
+import * as _angular_core from '@angular/core';
+import { Signal, OnDestroy } from '@angular/core';
+import { SendToDialogResult } from '@arsedizioni/ars-utils/ui.application';
+import { NameValueItem, LoginResult, Folder, ApiResult, FolderTree } from '@arsedizioni/ars-utils/core';
+import { LoginOAuthType } from '@arsedizioni/ars-utils/ui.oauth';
+import { HttpInterceptor, HttpRequest, HttpHandler, HttpEvent } from '@angular/common/http';
+import * as rxjs from 'rxjs';
+import { Observable, Subscription } from 'rxjs';
+import * as _angular_common_module_d_yNBsZ8gb from '@angular/common/module.d-yNBsZ8gb';
+import { ResetPasswordDialogResult, RecoverPasswordDialogData, RecoverPasswordDialogResult } from '@arsedizioni/ars-utils/ui';
+
+declare const ClipperMessages: {
+    /**
+     * Messages
+     */
+    ERROR: string;
+    LOGIN_CHANGED: string;
+    LOGIN_COMPLETED: string;
+    LOGOUT_COMPLETED: string;
+    LOGOUT: string;
+    DOCUMENT_READ: string;
+    DOCUMENT_NAVIGATE: string;
+    DOCUMENT_NAVIGATED: string;
+    DOCUMENT_SELECTED: string;
+    DOCUMENT_SELECTED_INNER: string;
+    SETTINGS_CHANGED: string;
+    COMMAND_ARCHIVE_ADD: string;
+    COMMAND_CALENDAR_ADD: string;
+    COMMAND_WORKING_OPEN: string;
+    COMMAND_WORKING_ADD: string;
+    COMMAND_SEARCH_RESTORED: string;
+    COMMAND_SEARCH_EXECUTED: string;
+    COMMAND_HISTORY_OPEN: string;
+    COMMAND_DASHBOARD_UPDATED: string;
+    AI_CONCERN_ME: string;
+    AI_EXPLAIN: string;
+    AI_COMMENT: string;
+    AI_NEWS: string;
+    INTEROP_RS_NEW_LAW: string;
+    INTEROP_RS_NEW_ACTIVITY: string;
+    INTEROP_RS_USAGE_REPORT: string;
+    UPDATE_RELOAD: string;
+};
+
+declare enum ClipperServiceFlags {
+    None = 0,
+    NotifySystemErrors = 1,
+    DisplayConnectionStateMessages = 2
+}
+declare enum ClipperRecurrenceType {
+    Year = 1,
+    Month = 2,
+    Day = 3
+}
+declare const ClipperRecurrenceTypes: NameValueItem<ClipperRecurrenceType>[];
+declare enum ClipperSelectionMode {
+    None = 0,
+    Single = 1,
+    TwoOrMore = 2,
+    Multi = 3
+}
+declare enum ClipperModuleGroup {
+    Home = 0,
+    NormativaVigente = 1,
+    UltimeNovità = 2,
+    ParApprofondire = 3,
+    DGInfo = 4,
+    Giurisprudenza = 5,
+    Calendario = 11,
+    Archivio = 12,
+    Evolution = 201,
+    Ars = 202,
+    Ricerca = 99
+}
+declare enum ClipperModule {
+    NormativaVigente = 4,
+    News = 1,
+    GazzetteBollettiniEFontiDiverse = 2,
+    Giurisprudenza = 5,
+    ModificheAbrogazioniERinvii = 3,
+    ScadenzeESegnalazioni = 12,
+    AllerteAlimentari = 8,
+    Approfondimenti = 6,
+    QuesitiECasiRisolti = 10,
+    MetodiDiAnalisi = 11,
+    DGInfo = 61,
+    Ricerca = 99,
+    GiurisprudenzaRecente = 18
+}
+declare enum ClipperModel {
+    Unknown = 0,
+    AggiornamentoNormativo = 2,
+    News = 3,
+    Articoli = 4,
+    Juris = 5,
+    Quesiti = 8,
+    NormativaVigente = 9,
+    Scadenze = 10,
+    Coordinamento = 11,
+    AllerteAlimentari = 13,
+    MetodiDiAnalisi = 14,
+    GiurisprudenzaRecente = 18,
+    Segnalazioni = 20,
+    UltimeNovità = 21
+}
+declare const ClipperModels: NameValueItem<number>[];
+declare const ClipperModuleGroups: NameValueItem<number>[];
+declare const ClipperModules: NameValueItem<number>[];
+declare enum ClipperChannel {
+    None = 0,
+    LavoroEAmbiente = 1,
+    SostanzeAlimentari = 2,
+    MerciPericolose = 3,
+    Energia = 4,
+    DGInfo = 5
+}
+declare const ClipperChannels: NameValueItem<ClipperChannel>[];
+interface ClipperAvailableChannel extends NameValueItem<ClipperChannel> {
+    active?: boolean;
+}
+declare const ClipperRegions: NameValueItem<string>[];
+interface SectorInfo extends NameValueItem<string> {
+    group?: string;
+    channels?: string;
+    sectorId?: string;
+}
+declare const ClipperSectors: SectorInfo[];
+declare const ClipperSectorTypes: NameValueItem<string>[];
+declare const ClipperAuthors: SectorInfo[];
+declare const ClipperSources: NameValueItem<string>[];
+declare class ClipperUpdateChannelsStateParams {
+    activeChannels: ClipperChannel[];
+}
+interface ClipperChannelSettingsItem<T> {
+    name: string;
+    value: T;
+    checked: boolean;
+}
+declare class ClipperChannelSettings {
+    channelId: ClipperChannel;
+    channelName: string;
+    isEnabled?: boolean;
+    isActive?: boolean;
+    sectors: ClipperChannelSettingsItem<string>[];
+    regions: ClipperChannelSettingsItem<string>[];
+    /**
+     * Check at least one of sector values is contained in sectors list
+     * @param values : the admitted values
+     * @returns true if at least one value has been found
+     */
+    hasAnyOfSectors(values: string[]): boolean;
+    /**
+     * Check at least one of region values is contained in regions list
+     * @param values : the admitted values
+     * @returns true if at least one value has been found
+     */
+    hasAnyOfRegions(values: string[]): boolean;
+}
+interface ClipperUserChannelInfo {
+    channel: ClipperChannel;
+    channelName?: string;
+    expiringDate: string;
+    isTrial?: boolean;
+    isDisabled: boolean;
+    isDvd: boolean;
+    isActive: boolean;
+    documentsViewable?: number;
+    documentsViewed?: number;
+    settings?: ClipperChannelSettings;
+}
+interface ClipperUserInfo {
+    userId: number;
+    customerId?: number;
+    companyName: string;
+    displayName: string;
+    firstName: string;
+    email: string;
+    OAUTH?: boolean;
+    sessionId?: string;
+    scope: number;
+    isAuthenticated: boolean;
+    isTemporary: boolean;
+    hasTrial: boolean;
+    hasTeam: boolean;
+    hasAI: boolean;
+    hasAIAssistant: boolean;
+    hasAIEditor: boolean;
+    channels: ClipperUserChannelInfo[];
+    firstChannelTrial: ClipperUserChannelInfo;
+    trialInfo?: ClipperUserTrialInfo;
+}
+interface ClipperLoginResult extends LoginResult<ClipperUserInfo> {
+    settings?: ClipperChannelSettings[];
+}
+interface ClipperLoginInfo {
+    context: ClipperUserInfo;
+    complianceContext?: any;
+    channels?: ClipperChannelSettings[];
+    credentials?: string;
+    OAUTH?: LoginOAuthType;
+}
+declare class ClipperSearchParams {
+    version: number;
+    searchId?: number;
+    searchName?: string;
+    text?: string;
+    augmentedText?: string;
+    title?: string;
+    titleOnly?: boolean;
+    showUnreadDocumentsOnly?: boolean;
+    showCommentedDocumentsOnly?: boolean;
+    showNotAbrogatedDocumentsOnly?: boolean;
+    expandTextQueryUsingAI?: boolean;
+    number?: string;
+    fromDate?: Date;
+    toDate?: Date;
+    year?: number;
+    sourceNumber?: string;
+    source?: string;
+    sourceFromDate?: Date;
+    sourceToDate?: Date;
+    sourceYear?: number;
+    sector?: string;
+    sectors?: SectorInfo[];
+    topic?: string;
+    topics?: NameValueItem<string>[];
+    taxonomy?: string;
+    taxonomies?: NameValueItem<string>[];
+    taxonomyPath?: string;
+    taxonomyNode?: string;
+    type?: string;
+    types?: NameValueItem<string>[];
+    tag?: string;
+    tags?: NameValueItem<string>[];
+    author?: string;
+    authors?: NameValueItem<string>[];
+    changeReason?: number;
+    changedNumber?: string;
+    changedYear?: number;
+    changedTitle?: string;
+    changedId?: string;
+    modifierId?: string;
+    modifierNumber?: string;
+    modifierYear?: number;
+    modifierTitle?: string;
+    model?: ClipperModel;
+    models?: ClipperModel[];
+    module?: ClipperModule;
+    modules?: NameValueItem<ClipperModule>[];
+    mode?: ClipperQueryReferencesMode;
+    channels?: NameValueItem<ClipperChannel>[];
+    count?: number;
+    id?: string;
+    anchor?: string;
+    excludeTextReferences?: boolean;
+    excludeNotesReferences?: boolean;
+    useModifierInfo?: boolean;
+    returnModifierInfo?: boolean;
+    first?: number;
+    sortMode?: number;
+}
+interface ClipperReferencesSearchParams {
+    documentId: string;
+    year?: number;
+    sector?: string;
+    author?: string;
+    anchor?: string;
+    model?: string;
+    mode?: ClipperQueryReferencesMode;
+    excludeTextReferences?: boolean;
+    excludeNotesReferences?: boolean;
+    useModifierInfo?: boolean;
+    returnModifierInfo?: boolean;
+    count?: number;
+    first?: number;
+}
+declare enum ClipperDocumentContainer {
+    None = 0,
+    LavoroEAmbiente = 1,
+    SostanzeAlimentari = 2,
+    OrangeProject = 4,
+    Energia = 8,
+    DGInfo = 16,
+    DLGS231 = 32,
+    All = 63
+}
+declare const ClipperDocumentChangeReasons: NameValueItem<number>[];
+interface ClipperDocumentAnchorInfo {
+    documentId: string;
+    type: number;
+    typeDescription: string;
+    text: string;
+    title?: string;
+    description?: string;
+    uri: string;
+    ordinal?: string;
+    score?: number;
+    veryRelevant?: boolean;
+    value?: string;
+    level?: number;
+}
+interface ClipperDocumentRelevants {
+    items: ClipperDocumentAnchorInfo[];
+    hits: number;
+    hit: number;
+    minimumScore: number;
+}
+interface ClipperDocumentInfo {
+    id?: string;
+    documentId?: string;
+    documentCode?: string;
+    model?: number;
+    modelName?: string;
+    module?: number;
+    moduleName?: string;
+    channelName?: string;
+    group?: string;
+    title2?: string;
+    title1?: string;
+    tags?: string;
+    topics?: string;
+    number?: string;
+    date?: Date;
+    description?: string;
+    publishingDate?: Date;
+    pictureId?: string;
+    sourceNumber?: string;
+    sourceDate?: Date;
+    source?: string;
+    sector?: string;
+    origin?: string;
+    originDescription?: string;
+    author?: string;
+    anchors?: ClipperDocumentAnchorInfo[];
+    taxonomy?: string;
+    info?: string;
+    isRead?: boolean;
+    isExportable?: boolean;
+    isCommented?: boolean;
+    isJuris?: boolean;
+    isOver?: boolean;
+    isTrial?: boolean;
+    isNew?: boolean;
+    isExpired?: boolean;
+    isExpiring?: boolean;
+    isMenuOpen?: boolean;
+    applicableFromDate?: Date;
+    validityState?: number;
+    validFromDate?: Date;
+    validUntilDate?: Date;
+    validityDescription?: string;
+    validityInfo?: string;
+    expiringDate?: Date;
+    expiringDescription?: string;
+    expiringInfo?: string;
+    popularity?: number;
+    part?: number;
+    primaryId?: string;
+    primaryDescription?: string;
+    primaryModel?: number;
+    hasPrimary?: boolean;
+    secondaryId?: string;
+    bag?: any;
+    lastUpdate?: string;
+}
+declare class ClipperSearchResult {
+    days?: string;
+    interval?: string;
+    items?: ClipperDocumentInfo[];
+    facets?: ClipperSearchFacetsSnapshot;
+    tags?: NameValueItem<string>[];
+    total?: number;
+    terms?: string[];
+    searchInfo?: any;
+    searchParams?: ClipperSearchParams;
+    snapshotMode?: ClipperQueryReferencesMode;
+}
+interface ClipperSearchFacet {
+    type: number;
+    typeName: string;
+    title: string;
+    value: string;
+    count: number;
+}
+interface ClipperSearchFacetGroup {
+    name: string;
+    selectedValue?: string;
+    selectedValueDescription?: string;
+    values: ClipperSearchFacet[];
+    index: number;
+}
+interface ClipperSearchFacetsResult {
+    interval?: string;
+    facets?: ClipperSearchFacet[][];
+    total?: number;
+}
+declare class ClipperSearchFacetsSnapshot {
+    groups: ClipperSearchFacetGroup[];
+    usedGroups: ClipperSearchFacetGroup[];
+    hasFacets: boolean;
+    hasMoreFacets: boolean;
+    hasTooManyResults: boolean;
+    sector?: string;
+    author?: string;
+    anchor?: string;
+    type?: string;
+    reason?: string;
+    fromDate?: Date;
+    toDate?: Date;
+    interval?: string;
+    changedInterval: boolean;
+    changedSector: boolean;
+    changedAuthor: boolean;
+    changedAnchor: boolean;
+    changedType: boolean;
+    changedReason: boolean;
+}
+interface ClipperSearchCalendarSnapshotMonth {
+    days: number[];
+    monthShortName: string;
+    monthName: string;
+    month: number;
+    year: number;
+    total: number;
+    expired: number;
+    expiring: number;
+}
+declare class ClipperSearchCalendarSnapshotResult {
+    months?: ClipperSearchCalendarSnapshotMonth[];
+}
+declare enum ClipperSort {
+    Default = 0,
+    Relevance = 1,
+    DateAsc = 2,
+    DateDesc = 3,
+    SourceDateAsc = 7,
+    SourceDateDesc = 8,
+    Popularity = 5
+}
+declare enum ClipperQueryReferencesMode {
+    ReferencesIn = 1,
+    ReferencesOut = 2,
+    ChangesIn = 3,
+    ChangesOut = 5,
+    Juris = 4
+}
+declare enum ClipperFacet {
+    Sector = 1,
+    Year = 2,
+    DocumentType = 3,
+    Topic = 4,
+    Article = 5,
+    Author = 6,
+    Reason = 95
+}
+interface ClipperOTPInfo {
+    code: string;
+    canPreview?: boolean;
+    canEmbed?: boolean;
+}
+declare enum ClipperExportDocumentsFormat {
+    Deafault = 1,
+    iCalendar = 2
+}
+interface ClipperExportDocumentsParams {
+    query: ClipperSearchParams;
+    ids: string[];
+    format?: ClipperExportDocumentsFormat;
+}
+interface ClipperSendDocumentsByEmailParams extends SendToDialogResult {
+    ids: string[];
+    public: string;
+    isCalendar: boolean;
+}
+interface ClipperDocumentStructure {
+    id: string;
+    title: string;
+    items?: ClipperDocumentAnchorInfo[];
+}
+interface ClipperSearchFilter {
+    container: ClipperDocumentContainer;
+    models: number[];
+    sectors: string[];
+    regions: string[];
+    notifications: number[];
+    isEnabled: boolean;
+    isActive: boolean;
+}
+interface ClipperTaxonomyParams {
+    countItems: boolean;
+    model: ClipperModel;
+    userFilters?: ClipperSearchFilter[];
+}
+interface ClipperUserSearch {
+    id?: number;
+    userId?: number;
+    name?: string;
+    module?: ClipperModule;
+    data?: string;
+}
+interface ClipperUserWorkingDocument {
+    userId?: number;
+    documentId?: string;
+    documentDescriptor?: string;
+    title1?: string;
+    title2?: string;
+    timestamp?: string;
+}
+interface ClipperDeleteWorkingDocumentsParams {
+    documentIds: string[];
+    deleteAll: boolean;
+}
+interface ClipperUserLink {
+    id?: number;
+    userId: number;
+    userName?: string;
+    key: string;
+}
+interface ClipperUserTrialInfo {
+    channelName: string;
+    expiringDate: Date;
+    remainingDocuments: number;
+}
+interface ClipperArsEventInfo {
+    id: number;
+    location?: string;
+    title?: string;
+    pictureId?: string;
+    date?: string;
+    endDate?: string;
+    startTime?: string;
+    endTime?: string;
+    hours?: number;
+    days?: number;
+    dateIntervalDescription?: string;
+    durationDescription?: string;
+    group?: string;
+    address?: string;
+    city?: string;
+    isOver?: boolean;
+}
+interface ClipperSearchArsEventsParams {
+    group?: string;
+    group1?: string;
+    collectGroups?: boolean;
+    collectBundles?: boolean;
+    fromDate?: string;
+    untilDate?: string;
+    text?: string;
+    sortBy?: string;
+    count: number;
+}
+interface ClipperSearchArsEventsResult {
+    interval?: string;
+    items?: ClipperArsEventInfo[];
+    total?: number;
+}
+interface ClipperDocumentUpdateStateParams {
+    documentIds: string[];
+    isRead: boolean;
+}
+interface ClipperDashboardModelItem {
+    id?: ClipperModel;
+    newItems?: number;
+    unreadItems?: number;
+}
+interface ClipperDashboardItem {
+    id?: ClipperModule;
+    models?: ClipperDashboardModelItem[];
+    newItems?: number;
+    unreadItems?: number;
+    lastUpdated?: string;
+}
+interface ClipperDashboardResult {
+    items?: ClipperDashboardItem[];
+    isTrial?: boolean;
+    expiredDeadlines?: number;
+    expiringDeadlines?: number;
+    documentUpdates?: number;
+    channels?: ClipperChannelSettings[];
+}
+declare class ClipperDashboard {
+    items: _angular_core.WritableSignal<ClipperDashboardItem[]>;
+    isTrial?: boolean;
+    expiredDeadlines?: number;
+    expiringDeadlines?: number;
+    documentUpdates?: number;
+    unreadItems: Signal<[ClipperModule, number][]>;
+    unreadItemsByModel: Signal<[ClipperModel, number][]>;
+    /**
+     * Update unread items
+     * @param module : the module
+     * @param model : the optional model
+     * @param increment : the increment (can be negative)
+     */
+    updateUnreadItems(module: ClipperModule, model: ClipperModel | undefined, increment: number): void;
+    /***
+     * Get the module unread items
+     * @param module: the module
+     * @param model : the optional model
+     * @returns the module unread items
+     */
+    getUnreadItems(module: ClipperModule, model?: ClipperModel): number;
+    /**
+     * Return total unread items
+     * @returns : the total unread items
+     */
+    gatTotalUnreadItems(): number;
+}
+interface ClipperDayItem {
+    day: string;
+    label: string;
+    items: ClipperDayGroup[];
+    count: number;
+}
+interface ClipperDayGroup {
+    model: ClipperModel;
+    label: string;
+    items: ClipperDocumentInfo[];
+}
+interface ClipperLastDaysResult {
+    items: ClipperDayItem[];
+}
+declare class ClipperTeamMemberInfo {
+    id: number;
+    teamId: string;
+    name?: string;
+    email?: string;
+    isAdmin?: boolean;
+    isDisabled?: boolean;
+    hasPermission55?: boolean;
+    hasPermission56?: boolean;
+    hasPermission57?: boolean;
+    isMenuOpen?: boolean;
+    isOver?: boolean;
+}
+declare enum ClipperTeamProduct {
+    SharedArchive = 1004676,
+    SharedCalendar = 1004683
+}
+declare enum ClipperTeamProductPermission {
+    SharedArchive = 56,
+    SharedCalendar = 57
+}
+interface ClipperTeamProductInfo {
+    permissionId: ClipperTeamProductPermission;
+    name: string;
+    maxMembers: number;
+    usedMembers: number;
+}
+interface ClipperTeamMembersSearchResult {
+    teamId?: string;
+    teamTitle?: string;
+    total?: number;
+    customerId?: number;
+    canEdit?: boolean;
+    products?: ClipperTeamProductInfo[];
+    items?: ClipperTeamMemberInfo[];
+}
+interface ClipperTeamsSearchParams {
+    teamId?: string;
+    permissionId?: number;
+    productId?: number;
+    adminsOnly?: boolean;
+    activeMembersOnly?: boolean;
+    includeRSTeams?: boolean;
+}
+interface ClipperTeamsSearchResult {
+    total: number;
+    items: NameValueItem<string>[];
+}
+declare class ClipperTeamInfo {
+    id?: string;
+    customerId?: number;
+    title?: string;
+    isDisabled?: boolean;
+    created?: string;
+    lastModified?: string;
+}
+declare enum ClipperCalendarState {
+    Open = 101,
+    Expired = 102,
+    Expiring = 103,
+    Closed = 104
+}
+declare const ClipperCalendarStates: NameValueItem<ClipperCalendarState>[];
+declare class ClipperCalendarSearchParams {
+    id?: string;
+    fromDate?: Date;
+    toDate?: Date;
+    teamId?: string;
+    text?: string;
+    month?: number;
+    year?: number;
+    sortDescending?: boolean;
+    state?: ClipperCalendarState;
+    recurrentOnly?: boolean;
+    first?: number;
+    count?: number;
+}
+interface ClipperCalendarSearchResult {
+    interval: string;
+    items: ClipperDeadlineInfo[];
+    days: number[];
+    teams: NameValueItem<string>[];
+    total: number;
+}
+interface ClipperDeadlineInfo {
+    id?: string;
+    companyId?: number;
+    userId?: number;
+    teamId: string;
+    teamName?: string;
+    group?: string;
+    description?: string;
+    documentTitle?: string;
+    documentId?: string;
+    documentNumber?: string;
+    documentDate?: Date;
+    emails?: string;
+    expiringDate?: Date;
+    expiredAlertSent?: boolean;
+    expiringInfo?: string;
+    expiringDescription?: string;
+    nextExpiringDate?: Date;
+    alarmDays?: number;
+    alarmDate?: Date;
+    alarmMemo?: string;
+    alarmSent?: boolean;
+    hasAlarm?: boolean;
+    isMenuOpen?: boolean;
+    isOver?: boolean;
+    isExpired?: boolean;
+    isExpiring?: boolean;
+    isClosed?: boolean;
+    isClosable?: boolean;
+    isPrivate?: boolean;
+    isRecurrent?: boolean;
+    recurrencePatternType?: ClipperRecurrenceType;
+    recurrenceFrequency?: number;
+    recurrenceEndOfMonth?: boolean;
+    recurrenceNewId?: string;
+    outlookAppointmentId?: string;
+    created?: Date;
+    lastModified?: Date;
+}
+interface ClipperCalendarSaveDeadlineParams {
+    deadline: ClipperDeadlineInfo;
+    teamIds?: string[];
+}
+declare enum ClipperCalendarCopyMode {
+    Duplicate = 1,
+    Move = 2
+}
+interface ClipperCalendarCopyDeadlinesParams {
+    ids: string[];
+    teamId: string;
+    mode: ClipperCalendarCopyMode;
+}
+declare enum ClipperArchiveFileType {
+    None = 0,
+    Procedure = 1,
+    OperatingInstructions = 2,
+    TechnicalReport = 3,
+    AdministrativeDocument = 4,
+    Document = 5,
+    OtherApplicableRules = 6,
+    Other = 7,
+    File = 101,
+    Image = 102
+}
+declare const ClipperArchiveFileTypes: NameValueItem<ClipperArchiveFileType>[];
+declare enum ClipperArchiveFileStorageType {
+    ArsCloud = 2,
+    OtherCloud = 3
+}
+declare const ClipperArchiveFileStorageTypes: NameValueItem<ClipperArchiveFileStorageType>[];
+interface ClipperArchiveFileInfo {
+    id?: string;
+    parentFolderId?: string;
+    isFolder?: boolean;
+    folderId?: string;
+    folderName?: string;
+    folderItemsCount?: number;
+    teamId: string;
+    teamName?: string;
+    topicId?: string;
+    topicPath?: string;
+    topicName?: string;
+    topics?: string[];
+    tags?: string;
+    isPrivate?: boolean;
+    isFile?: boolean;
+    fileName?: string;
+    storageType?: ClipperArchiveFileStorageType;
+    isBinary?: boolean;
+    binaryId?: number;
+    binaryFilePath?: string;
+    isPermalink?: boolean;
+    fileType?: ClipperArchiveFileType;
+    file?: any;
+    notes?: string;
+    position?: number;
+    documentIds?: string;
+    documentLastChangedBy?: string;
+    documentLastChangedById?: string;
+    documentLastChangedReasonDescription?: string;
+    documentLastChanged?: Date;
+    documentUpdateState?: number;
+    isDocumentChanged?: boolean;
+    canPreview?: boolean;
+    canEmbed?: boolean;
+    channelName?: string;
+    model?: ClipperModel;
+    modelName?: string;
+    title1?: string;
+    title2?: string;
+    date?: Date;
+    number?: string;
+    origin?: string;
+    originDescription?: string;
+    documentId?: string;
+    documentCode?: string;
+    isDocument?: boolean;
+    isRead?: boolean;
+    isJuris?: boolean;
+    isMenuOpen?: boolean;
+    isOver?: boolean;
+    validityState?: number;
+    validUntilDate?: Date;
+    expiringDate?: Date;
+    expiringInfo?: string;
+    uniqueId: string;
+}
+interface ClipperArchiveFolderTree extends Folder {
+    subFolders: ClipperArchiveFolderTree[];
+}
+declare class ClipperArchiveFoldersSearchParams {
+    teamId?: string;
+    privateOnly?: boolean;
+}
+interface ClipperArchiveFoldersSearchResult {
+    name: string;
+    teams: NameValueItem<string>[];
+    files: ClipperArchiveFileInfo[];
+    subFolders: ClipperArchiveFolderTree[];
+}
+declare class ClipperArchiveFilesSearchParams {
+    teamId?: string;
+    folderId?: string;
+    folderName?: string;
+    fileType?: ClipperArchiveFileType;
+    fromDate?: Date;
+    toDate?: Date;
+    topicPath?: string;
+    topicId?: string;
+    topicName?: string;
+    titlesOnly?: boolean;
+    text?: string;
+    documentNumber?: string;
+    documentYear?: number;
+    first?: number;
+    count?: number;
+}
+interface ClipperArchiveFilesSearchResult {
+    items: ClipperArchiveFileInfo[];
+    folderName?: string;
+    total: number;
+}
+interface ClipperArchiveFoldersImportParams {
+    teamId: string;
+    destFolderId?: string;
+    sourcePath?: string;
+    sourceFileName?: string;
+    file?: any;
+    overwrite?: boolean;
+    version?: number;
+}
+declare enum ClipperArchiveCopyMode {
+    Duplicate = 1,
+    Move = 2
+}
+interface ClipperArchiveFilesCopyParams {
+    destTeamId: string;
+    destFolderId?: string;
+    files?: ClipperArchiveFileInfo[];
+    mode?: ClipperArchiveCopyMode;
+}
+interface ClipperArchiveFilesDeleteParams {
+    sourceFolderId?: string;
+    destFolderId?: string;
+    files?: ClipperArchiveFileInfo[];
+}
+declare class ClipperUtils {
+    /**
+     * Check if a model is readable
+     * @param model : the model to check
+     * @returns : true if the model is readable
+     */
+    static isClipperModelReadable(model: ClipperModel): boolean;
+    /**
+     * Return the Clipper module from a document
+     * @param item: the documenti item
+     * @returns the module id
+     */
+    static getClipperModuleFromModel(item: ClipperDocumentInfo): ClipperModule | undefined;
+    /**
+     * Return the Clipper group name
+     * @param value: the group value
+     * @returns the group name
+     */
+    static getClipperModuleGroupName(value: ClipperModuleGroup): string;
+    /**
+     * Return the list of modules of a group
+     * @param value: the module name
+     * @returns the list of modules
+     */
+    static getClipperModuleGroupItems(value: ClipperModuleGroup): NameValueItem<ClipperModule>[];
+    /**
+     * Check modules against current selected in filter
+     * @param modules : the modules to check for
+     * @param mode : thc check mode: 1) exactly all elements 2) all elements 3) any of the elements specified
+     * @returns true if the check is successfull
+     */
+    private static checkModules;
+    /**
+     * Return the list of available sort options for a list of modules
+     * @param modules : the modules list
+     * @returns the list of availbale sort options
+     */
+    static getClipperAvailableSortOptions(modules?: NameValueItem<ClipperModule>[], params?: ClipperSearchParams): NameValueItem<ClipperSort>[];
+}
+declare class ClipperSearchUtils {
+    /**
+     * Clear the search params object
+     * @param params : the search params to clear
+     */
+    static clear(params: ClipperSearchParams): void;
+    /**
+     * Get hte model list related to a list of modules
+     * @param modules: the modules to check
+     * @returns the list fo models
+     */
+    static getModulesModels(modules?: NameValueItem<ClipperModule>[]): ClipperModel[];
+    /**
+     * Check if current filter is a text based search
+     * @param params : the search params to check
+     * @returns true if is a text based search
+     */
+    static isTextQuery(params: ClipperSearchParams): boolean;
+    /**
+     * Try to add a query
+     * @param q : the new query
+     * @param queries : the new query
+            */
+    private static concatTextQuery;
+    /**
+     * Normalize text query
+     * @param text : the text query to normalize
+     * @returns : the text normalized or undefined
+     */
+    static normalizeTextQuery(text: string): string | undefined;
+}
+
+declare class ClipperAuthInterceptor implements HttpInterceptor {
+    private clipperService;
+    private broadcastService;
+    private lastErrorTime;
+    intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+    /**
+     * Handle 401 error
+     * @param request : the request
+     * @param next : the http handler
+     */
+    private handle401Error;
+    /**
+     * Add token to request
+     * @param request : the request
+     * @param token: the token or null to use curre3nt
+     */
+    private addTokenToRequest;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ClipperAuthInterceptor, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ClipperAuthInterceptor>;
+}
+
+declare class ClipperService implements OnDestroy {
+    private httpClient;
+    private broadcastServiceSubscription?;
+    private broadcastService;
+    private dialogService;
+    private keepAlive;
+    private _appUri?;
+    get appUri(): string;
+    private _serviceUri;
+    get serviceUri(): string;
+    private _flags;
+    get flags(): ClipperServiceFlags;
+    private _loginInfo?;
+    get loginInfo(): ClipperLoginInfo | undefined;
+    readonly loggedIn: _angular_core.WritableSignal<boolean>;
+    readonly loggingIn: _angular_core.WritableSignal<boolean>;
+    readonly snapshot: _angular_core.WritableSignal<ClipperSearchResult>;
+    readonly supportsRS: _angular_core.WritableSignal<boolean>;
+    readonly shouldRefreshToken: _angular_core.WritableSignal<boolean>;
+    readonly referencesSnapshot: _angular_core.WritableSignal<ClipperSearchResult>;
+    readonly dashboard: ClipperDashboard;
+    readonly bag: _angular_core.WritableSignal<ClipperDocumentInfo[]>;
+    readonly bagTotal: Signal<number>;
+    readonly visible: _angular_core.WritableSignal<boolean>;
+    private _teams;
+    get teams(): NameValueItem<string>[];
+    currentTeamId: _angular_core.WritableSignal<string>;
+    currentTeamName: _angular_core.WritableSignal<string>;
+    currentTeamIsPrivate: Signal<boolean>;
+    readonly availableChannels: _angular_core.WritableSignal<ClipperAvailableChannel[]>;
+    readonly activeChannels: Signal<ClipperAvailableChannel[]>;
+    readonly allowTags: _angular_core.WritableSignal<boolean>;
+    ngOnDestroy(): void;
+    /**
+     * Initialize service
+     * @param serviceUri : the service uri
+     * @param appUri : the clipper application uri
+     * @param flags: the service flags. Default is none.
+     */
+    initialize(serviceUri: string, appUri?: string, flags?: ClipperServiceFlags): void;
+    /**
+   * Get access token expiration date
+   */
+    private getTokenExpirationDate;
+    /**
+     * Checks if access token in expired
+     */
+    isTokenExpired(): boolean;
+    /**
+   * Set keep alive
+   */
+    private setKeepAlive;
+    /**
+     * Remove keep alive
+     */
+    private removeKeepAlive;
+    /**
+   * Ping
+   */
+    ping(): void;
+    /**
+   * Set JWT tokens
+   * @param value : the login result
+   */
+    private setToken;
+    /**
+     * Return current JWT token
+     * @param refresh: true to get the refresh token. Default is false.
+     */
+    getToken(refresh?: boolean): string;
+    /**
+     * Store login info
+     */
+    storeLogin(): void;
+    /**
+   * Perform auto login using current link data
+     * @param email: the optional email if using OAuth2
+     * @parma password: the optional password if using OAuth2
+     * @param remember: remember credentials
+     * @param oauth: the optional open authentication supported
+     * @param oauthAccessToken: the optional OAuth2 access token
+   * @param onSucces: function to execute on seccess
+   */
+    autoLogin(email?: string, password?: string, remember?: boolean, oauth?: LoginOAuthType, oauthAccessToken?: string | undefined, onSucces?: Function): boolean;
+    /**
+     * Perform auto logout
+     * @param onSuccess: function to execute on success
+     */
+    autoLogout(onSuccess?: Function): void;
+    /**
+     * Perform login
+     * @param email: the optioanl email if using OAuth2
+     * @parma password: the optional password if using OAuth2
+     * @param remember: remember credentials
+     * @param oauth: the optional open authentication supported
+     * @param oauthAccessToken: the optional OAuth2 access token
+     * @returns: the login result
+     */
+    login(email?: string, password?: string, remember?: boolean, oauth?: LoginOAuthType, oauthAccessToken?: string | undefined): rxjs.Observable<ApiResult<ClipperLoginResult>>;
+    /**
+     * Perform logout
+     */
+    logout(): rxjs.Observable<any>;
+    /**
+    * Reset login refresh timer and login state
+    */
+    reset(): void;
+    /**
+     * Clear login data
+     * @param clearOAuthToken: true to clear oauth token also
+     */
+    clear(clearOAuthToken?: boolean): void;
+    /**
+    * Perform token refresh
+    */
+    refresh(): rxjs.Observable<ApiResult<ClipperLoginResult>>;
+    /**
+   * Initialize channels
+   */
+    private initializeChannels;
+    /**
+     * Update channels
+     * @param values : the new channel values
+     */
+    updateChannels(values: NameValueItem<ClipperChannel>[]): void;
+    /**
+    * Get a new one time password
+    * @param id: the optional repository id
+    */
+    newOTP(id: string): rxjs.Observable<ApiResult<ClipperOTPInfo>>;
+    /**
+     * Load Ars events calendar
+     */
+    events(params: ClipperSearchArsEventsParams): rxjs.Observable<ApiResult<ClipperSearchArsEventsResult>>;
+    /**
+     * Query documents
+     */
+    query(params: ClipperSearchParams): rxjs.Observable<ApiResult<ClipperSearchResult>>;
+    /**
+     * Get facets for a query
+     */
+    queryFacets(params: ClipperSearchParams): rxjs.Observable<ApiResult<ClipperSearchFacetsResult>>;
+    /**
+    * Update document state
+    */
+    updateState(params: ClipperDocumentUpdateStateParams): rxjs.Observable<ApiResult<number>>;
+    /**
+     * Export a document in pdf format
+     */
+    exportPdf(id: string): rxjs.Observable<Blob>;
+    /**
+   * Export document list (query or selected items) or export deadlines as ics
+   */
+    export(params: ClipperExportDocumentsParams): rxjs.Observable<Blob>;
+    /**
+     * Send documents link by email
+     */
+    sendTo(params: ClipperSendDocumentsByEmailParams): rxjs.Observable<ApiResult<number>>;
+    /**
+     * Display a page the full document report
+     */
+    report(id: string): rxjs.Observable<Blob>;
+    /**
+     * Get document comment
+     */
+    comment(id: string): rxjs.Observable<ApiResult<string>>;
+    /**
+     * Get document info
+     */
+    info(id: string): rxjs.Observable<ApiResult<ClipperDocumentInfo>>;
+    /**
+     * Get document structure
+     */
+    index(id: string): rxjs.Observable<ApiResult<ClipperDocumentStructure>>;
+    /**
+     * Get document last update
+     */
+    lastUpdate(id: string): rxjs.Observable<ApiResult<string>>;
+    /**
+     * Query document references
+     */
+    references(params: ClipperReferencesSearchParams): rxjs.Observable<ApiResult<ClipperSearchResult>>;
+    /**
+     * Get facets for a document references
+     */
+    referencesFacets(params: ClipperReferencesSearchParams): rxjs.Observable<ApiResult<ClipperSearchFacetsResult>>;
+    /**
+     * Wrap document rendering to allow token refresh
+     */
+    preRender(): rxjs.Observable<ApiResult<boolean>>;
+    /**
+     * Get document juris articles
+     */
+    jurisArticles(params: ClipperSearchParams): rxjs.Observable<ApiResult<ClipperSearchResult>>;
+    /**
+    * Get deadlines snapshot based on the deadlines
+    */
+    deadlinesSnapshot(params: ClipperCalendarSearchParams): rxjs.Observable<ApiResult<ClipperSearchCalendarSnapshotResult>>;
+    /**
+     * Retrieve the taxonomy
+     */
+    getTaxonomy(params?: ClipperTaxonomyParams): rxjs.Observable<ApiResult<FolderTree>>;
+    /**
+     * Retrieve topics
+     */
+    getTopics(): rxjs.Observable<ApiResult<NameValueItem<string>[]>>;
+    /**
+    * Retrieve topics as tree
+    */
+    getTopicsAsTree(): rxjs.Observable<ApiResult<FolderTree>>;
+    /**
+     * Retrieve tags
+     */
+    getTags(): rxjs.Observable<ApiResult<NameValueItem<string>[]>>;
+    /**
+    * Retrieve current dashboard
+    */
+    loadDashboard(): Subscription;
+    /**
+   * Retrieve last 15 days
+   * @param params : the query params
+   */
+    last15Days(params: ClipperSearchParams): rxjs.Observable<ApiResult<ClipperLastDaysResult>>;
+    /**
+    * Update unread items
+    * @param module : the module
+    * @param model : the optional model
+    * @param increment : the increment (can be negative)
+    */
+    updateUnreadItems(module: ClipperModule, model?: ClipperModel, increment?: number): void;
+    /**
+    * Save a user link
+    * @param item: the user link
+    */
+    saveLink(item: ClipperUserLink): rxjs.Observable<ApiResult<boolean>>;
+    /**
+     * Delete a user link
+     * @param item: the user link
+     */
+    deleteLink(item: ClipperUserLink): rxjs.Observable<ApiResult<boolean>>;
+    /**
+     * Load working documents
+     */
+    loadBag(): Subscription;
+    /**
+     * Add one or more working document
+     * @param documentIds : the document ids to add
+     */
+    addToBag(documentIds: string[]): Subscription;
+    /**
+     * Remove one working document
+     * @param documentId : the document id
+     */
+    removeFromBag(documentId: string): Subscription;
+    /**
+     * Clear all working documents
+     */
+    clearBag(): Subscription;
+    /**
+     * Load working searches
+     * @param: module: the module to load searches for
+     */
+    loadSearches(module: ClipperModule): rxjs.Observable<ApiResult<ClipperUserSearch[]>>;
+    /**
+     * Save a working search
+     * @param params : the clipper user search
+     */
+    saveSearch(params: ClipperUserSearch): rxjs.Observable<ApiResult<ClipperUserSearch>>;
+    /**
+     * Remove one working search
+     * @param id : the id to remove
+     */
+    deleteSearch(id: number): rxjs.Observable<ApiResult<number>>;
+    /**
+    * Reset a user password
+    * @param params parameters
+    */
+    resetPassword(params: any): rxjs.Observable<ApiResult<ResetPasswordDialogResult>>;
+    /**
+     * Recover password
+     * @param params parameters
+     */
+    recoverPassword(params: RecoverPasswordDialogData): rxjs.Observable<ApiResult<RecoverPasswordDialogResult>>;
+    /**
+     * Update settings
+       * @param params parameters
+     */
+    updateSettings(params: any): rxjs.Observable<ApiResult<boolean>>;
+    /**
+     * Update channel state
+     * @param id: the channel id (1, 2, 3, 4)
+     */
+    updateChannelsState(params: ClipperUpdateChannelsStateParams): rxjs.Observable<ApiResult<ClipperDashboardResult>>;
+    /**
+     * Get trial info
+     */
+    private getTrialInfo;
+    /**
+     * Update trial info
+     */
+    updateTrialInfo(): void;
+    /**
+    * Rename a team
+    * @param newName : the new name
+    */
+    renameTeam(newName: string): rxjs.Observable<ApiResult<ClipperTeamInfo>>;
+    /**
+     * Retrieve teams
+     */
+    getTeams(params: ClipperTeamsSearchParams): rxjs.Observable<ApiResult<ClipperTeamsSearchResult>>;
+    /**
+     * Retrieve team members
+     */
+    getTeamMembers(params: ClipperTeamsSearchParams): rxjs.Observable<ApiResult<ClipperTeamMembersSearchResult>>;
+    /**
+     * Delete members
+     * @param ids: the id list to delete
+     */
+    deleteTeamMembers(ids: number[]): rxjs.Observable<ApiResult<number>>;
+    /**
+     * Save member
+     * @param item: the item to save
+     */
+    saveTeamMember(item: ClipperTeamMemberInfo): rxjs.Observable<ApiResult<ClipperTeamMemberInfo>>;
+    /**
+     * Query calendar
+     */
+    queryCalendar(params: ClipperCalendarSearchParams): rxjs.Observable<ApiResult<ClipperCalendarSearchResult>>;
+    /**
+     * Get the calendar snapshot
+     */
+    calendarSnapshot(params: ClipperCalendarSearchParams): rxjs.Observable<ApiResult<ClipperSearchCalendarSnapshotResult>>;
+    /**
+     * Delete one or more items
+     * @param ids: ids to delete
+     */
+    deleteCalendarDeadlines(ids: string[]): rxjs.Observable<ApiResult<number>>;
+    /**
+     * Copy one or more items
+     * @param params parameters
+     */
+    copyCalendarDeadlines(params: ClipperCalendarCopyDeadlinesParams): rxjs.Observable<ApiResult<number>>;
+    /**
+     * Close a deadline
+     * @param id : the id to close
+     */
+    closeCalendarDeadline(id: string): rxjs.Observable<ApiResult<ClipperDeadlineInfo>>;
+    /**
+     * Save an item
+     * @param params parameters
+     */
+    saveCalendarDeadline(params: ClipperCalendarSaveDeadlineParams): rxjs.Observable<ApiResult<ClipperDeadlineInfo[]>>;
+    /**
+     * Retrive a n item
+     * @param id : the item id
+     */
+    getCalendarDeadline(id: string): rxjs.Observable<ApiResult<ClipperDeadlineInfo>>;
+    /**
+     * Export to iCalendar format
+     * @param ids : deadlines to export
+     */
+    exportCalendarDeadlines(ids: string[]): rxjs.Observable<Blob>;
+    /**
+    * Retrieve all folders
+    * @param params : parameters
+    */
+    getArchiveFolders(params: ClipperArchiveFoldersSearchParams): rxjs.Observable<ApiResult<ClipperArchiveFoldersSearchResult>>;
+    /**
+     * Save folder
+     * @param params : parameters
+     */
+    saveArchiveFolder(params: Folder): rxjs.Observable<ApiResult<Folder>>;
+    /**
+     * Export folders
+     * @param id: the folder id or undefined to export all folders
+     * @param teamId: the optional team id. Default undefined (personal)
+     */
+    exportArchiveFolders(id?: string, teamId?: string): rxjs.Observable<Blob>;
+    /**
+     * Import folders
+     * @param params : parameters
+     */
+    importArchiveFolders(params: ClipperArchiveFoldersImportParams): rxjs.Observable<_angular_common_module_d_yNBsZ8gb.HttpEvent<unknown>>;
+    /**
+     * Get files and folders
+     * @param params : parameters
+     */
+    queryArchiveItems(params: ClipperArchiveFilesSearchParams): rxjs.Observable<ApiResult<ClipperArchiveFilesSearchResult>>;
+    /**
+     * Delete file and folders
+     * @param params parameters
+     */
+    deleteArchiveItems(params: ClipperArchiveFilesDeleteParams): rxjs.Observable<ApiResult<number>>;
+    /**
+     * Copy  file and folders to another folder or the same
+     * @param params parameters
+     */
+    copyArchiveItems(params: ClipperArchiveFilesCopyParams): rxjs.Observable<ApiResult<number>>;
+    /**
+     * Save a file
+     * @param params : parameters
+     */
+    saveArchiveFile(params: ClipperArchiveFileInfo): rxjs.Observable<_angular_common_module_d_yNBsZ8gb.HttpEvent<unknown>>;
+    /**
+     * Get file data
+     * @param id : the item id
+     */
+    getArchiveFile(id: string): rxjs.Observable<ApiResult<ClipperArchiveFileInfo>>;
+    /**
+     * Download file
+     * @param id : the binary id to download
+     * @param otp : the optional one time password
+     */
+    downloadArchiveFile(id: number, otp?: string): rxjs.Observable<Blob>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ClipperService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ClipperService>;
+}
+
+declare class ArsClipperCommonModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ArsClipperCommonModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<ArsClipperCommonModule, never, never, never>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<ArsClipperCommonModule>;
+}
+
+export { ArsClipperCommonModule, ClipperArchiveCopyMode, ClipperArchiveFileStorageType, ClipperArchiveFileStorageTypes, ClipperArchiveFileType, ClipperArchiveFileTypes, ClipperArchiveFilesSearchParams, ClipperArchiveFoldersSearchParams, ClipperAuthInterceptor, ClipperAuthors, ClipperCalendarCopyMode, ClipperCalendarSearchParams, ClipperCalendarState, ClipperCalendarStates, ClipperChannel, ClipperChannelSettings, ClipperChannels, ClipperDashboard, ClipperDocumentChangeReasons, ClipperDocumentContainer, ClipperExportDocumentsFormat, ClipperFacet, ClipperMessages, ClipperModel, ClipperModels, ClipperModule, ClipperModuleGroup, ClipperModuleGroups, ClipperModules, ClipperQueryReferencesMode, ClipperRecurrenceType, ClipperRecurrenceTypes, ClipperRegions, ClipperSearchCalendarSnapshotResult, ClipperSearchFacetsSnapshot, ClipperSearchParams, ClipperSearchResult, ClipperSearchUtils, ClipperSectorTypes, ClipperSectors, ClipperSelectionMode, ClipperService, ClipperServiceFlags, ClipperSort, ClipperSources, ClipperTeamInfo, ClipperTeamMemberInfo, ClipperTeamProduct, ClipperTeamProductPermission, ClipperUpdateChannelsStateParams, ClipperUtils };
+export type { ClipperArchiveFileInfo, ClipperArchiveFilesCopyParams, ClipperArchiveFilesDeleteParams, ClipperArchiveFilesSearchResult, ClipperArchiveFolderTree, ClipperArchiveFoldersImportParams, ClipperArchiveFoldersSearchResult, ClipperArsEventInfo, ClipperAvailableChannel, ClipperCalendarCopyDeadlinesParams, ClipperCalendarSaveDeadlineParams, ClipperCalendarSearchResult, ClipperChannelSettingsItem, ClipperDashboardItem, ClipperDashboardModelItem, ClipperDashboardResult, ClipperDayGroup, ClipperDayItem, ClipperDeadlineInfo, ClipperDeleteWorkingDocumentsParams, ClipperDocumentAnchorInfo, ClipperDocumentInfo, ClipperDocumentRelevants, ClipperDocumentStructure, ClipperDocumentUpdateStateParams, ClipperExportDocumentsParams, ClipperLastDaysResult, ClipperLoginInfo, ClipperLoginResult, ClipperOTPInfo, ClipperReferencesSearchParams, ClipperSearchArsEventsParams, ClipperSearchArsEventsResult, ClipperSearchCalendarSnapshotMonth, ClipperSearchFacet, ClipperSearchFacetGroup, ClipperSearchFacetsResult, ClipperSearchFilter, ClipperSendDocumentsByEmailParams, ClipperTaxonomyParams, ClipperTeamMembersSearchResult, ClipperTeamProductInfo, ClipperTeamsSearchParams, ClipperTeamsSearchResult, ClipperUserChannelInfo, ClipperUserInfo, ClipperUserLink, ClipperUserSearch, ClipperUserTrialInfo, ClipperUserWorkingDocument, SectorInfo };