@idea-ionic/uncommon 8.5.12 → 8.6.0-beta.1

package/index.d.ts

@@ -1,5 +1,1407 @@
+import * as i0 from '@angular/core';
+import { OnInit, EventEmitter, OnDestroy, OnChanges, SimpleChanges } from '@angular/core';
+import { IonAccordionGroup, Platform } from '@ionic/angular/standalone';
+import { Address, Suggestion, Countries, Announcement, Color, Contacts, epochDateTime, epochISOString, ExternalCalendarSources, ClientInfo, DeltaResources, Delta, DeltaRecord, Sentiment, TimeInterval, PushNotificationsDevice } from 'idea-toolbox';
+import { Routes } from '@angular/router';
+import { Observable, Subscription } from 'rxjs';
+import { IDEAStorageService, IDEATranslationsService } from '@idea-ionic/common';
+import { HttpClient, HttpHeaders, HttpParams, HttpErrorResponse } from '@angular/common/http';
+import { PushNotificationSchema } from '@capacitor/push-notifications';
+
+declare class IDEAAddressComponent implements OnInit {
+    /**
+     * The address to manage.
+     */
+    address: Address;
+    addressChange: EventEmitter<Address>;
+    /**
+     * If true, show the field `contact`.
+     */
+    showContact: boolean;
+    /**
+     * If true, show the field `address2`.
+     */
+    showAddress2: boolean;
+    /**
+     * If true, show the field `phone`.
+     */
+    showPhone: boolean;
+    /**
+     * If true, show the field `email`.
+     */
+    showEmail: boolean;
+    /**
+     * Whether the fields are editable or disabled.
+     */
+    editMode: boolean;
+    /**
+     * If true, show obligatory dots.
+     */
+    obligatory: boolean;
+    /**
+     * The lines attribute of the item.
+     */
+    lines: string;
+    /**
+     * The color for the component.
+     */
+    color: string;
+    /**
+     * The label to show for the field; if not set, it has a default value.
+     */
+    label: string;
+    /**
+     * The placeholder to show for the field.
+     */
+    placeholder: string;
+    /**
+     * To toggle the detailed view.
+     */
+    openByDefault: boolean;
+    countriesSuggestions: Suggestion[];
+    Countries: typeof Countries;
+    accordion: IonAccordionGroup;
+    ngOnInit(): void;
+    isCollapsed(): boolean;
+    getCountryName(countryCode: Countries): string;
+    setCountryFromSuggestion(suggestion: Suggestion): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IDEAAddressComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IDEAAddressComponent, "idea-address", never, { "address": { "alias": "address"; "required": false; }; "showContact": { "alias": "showContact"; "required": false; }; "showAddress2": { "alias": "showAddress2"; "required": false; }; "showPhone": { "alias": "showPhone"; "required": false; }; "showEmail": { "alias": "showEmail"; "required": false; }; "editMode": { "alias": "editMode"; "required": false; }; "obligatory": { "alias": "obligatory"; "required": false; }; "lines": { "alias": "lines"; "required": false; }; "color": { "alias": "color"; "required": false; }; "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "openByDefault": { "alias": "openByDefault"; "required": false; }; }, { "addressChange": "addressChange"; }, never, never, true, never>;
+}
+
 /**
- * Generated bundle index. Do not edit.
+ * Announcement card that can be set in any interface to show the alert for this project.
  */
-/// <amd-module name="@idea-ionic/uncommon" />
-export * from './public-api';
+declare class IDEAAnnouncementComponent implements OnInit {
+    protected _env: any;
+    private _tc;
+    private _storage;
+    /**
+     * The color for the announcement card.
+     */
+    color: string;
+    announcement: Announcement;
+    htmlContent: string;
+    storageKey: string;
+    constructor();
+    ngOnInit(): Promise<void>;
+    markAsRead(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IDEAAnnouncementComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IDEAAnnouncementComponent, "idea-announcement", never, { "color": { "alias": "color"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Pick a color from a defined set.
+ */
+declare class IDEAColorPickerComponent {
+    /**
+     * The pickable colors.
+     */
+    colors: Color[];
+    /**
+     * The current color.
+     */
+    current: string;
+    /**
+     * The label for the field.
+     */
+    label: string;
+    /**
+     * A placeholder for the field.
+     */
+    placeholder: string;
+    /**
+     * The icon for the field.
+     */
+    icon: string;
+    /**
+     * The color of the icon.
+     */
+    iconColor: string;
+    /**
+     * If true, the component is disabled.
+     */
+    disabled: boolean;
+    /**
+     * If true, the obligatory dot is shown.
+     */
+    obligatory: boolean;
+    /**
+     * Lines preferences for the item.
+     */
+    lines: string;
+    /**
+     * The color for the component.
+     */
+    color: string;
+    /**
+     * On select event.
+     */
+    select: EventEmitter<string>;
+    /**
+     * Icon select.
+     */
+    iconSelect: EventEmitter<void>;
+    private _popover;
+    openPalette(event: any): Promise<void>;
+    doIconSelect(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IDEAColorPickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IDEAColorPickerComponent, "idea-color-picker", never, { "colors": { "alias": "colors"; "required": false; }; "current": { "alias": "current"; "required": false; }; "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "iconColor": { "alias": "iconColor"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "obligatory": { "alias": "obligatory"; "required": false; }; "lines": { "alias": "lines"; "required": false; }; "color": { "alias": "color"; "required": false; }; }, { "select": "select"; "iconSelect": "iconSelect"; }, never, never, true, never>;
+}
+/**
+ * Component to open in a popover for displaying the colors available.
+ */
+declare class ColorsPaletteComponent {
+    private _popover;
+    /**
+     * The pickable colors.
+     */
+    colors: Color[];
+    /**
+     * The current color.
+     */
+    current: string;
+    pick(color: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColorsPaletteComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ColorsPaletteComponent, "idea-colors-palette", never, { "colors": { "alias": "colors"; "required": false; }; "current": { "alias": "current"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class IDEAContactsComponent {
+    private _alert;
+    private _translate;
+    /**
+     * The contacts to manage.
+     */
+    contacts: Contacts;
+    /**
+     * If true, show the field `name`.
+     */
+    showName: boolean;
+    /**
+     * Whether the fields are editable or disabled.
+     */
+    editMode: boolean;
+    /**
+     * The lines attribute of the item.
+     */
+    lines: string;
+    /**
+     * The color for the component.
+     */
+    color: string;
+    sendEmail(): void;
+    call(): void;
+    private preExternalAction;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IDEAContactsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IDEAContactsComponent, "idea-contacts", never, { "contacts": { "alias": "contacts"; "required": false; }; "showName": { "alias": "showName"; "required": false; }; "editMode": { "alias": "editMode"; "required": false; }; "lines": { "alias": "lines"; "required": false; }; "color": { "alias": "color"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class IDEACalendarPickerComponent implements OnInit {
+    private _modal;
+    private _alert;
+    private _translate;
+    inputDate: epochDateTime | epochISOString;
+    timePicker: boolean;
+    manualTimePicker: boolean;
+    title: string;
+    hideClearButton: boolean;
+    min: epochDateTime | epochISOString;
+    max: epochDateTime | epochISOString;
+    refDate: Date;
+    selectedDate: Date;
+    today: Date;
+    calendarGrid: Date[][];
+    hour: number;
+    minute: number;
+    hours: string[];
+    minutes: string[];
+    weekDays: string[];
+    dateMin: Date;
+    dateMax: Date;
+    ngOnInit(): void;
+    getLocalisedDay(date: Date): number;
+    buildCalendarGrid(refDate: Date): void;
+    addYears(offset: number): void;
+    setYear(year: string | number): void;
+    addMonths(offset: number): void;
+    showMonths(): Promise<void>;
+    isDateSelectable(date: Date): boolean;
+    selectDate(date: Date): void;
+    selectHour(hour: string): void;
+    selectMinute(minute: string): void;
+    isSameDay(a: Date, b: Date): boolean;
+    isSameMonth(a: Date, b: Date): boolean;
+    isSameHour(hour: string): boolean;
+    isSameMinute(minute: string): boolean;
+    save(reset?: boolean): void;
+    close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IDEACalendarPickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IDEACalendarPickerComponent, "idea-calendar-picker", never, { "inputDate": { "alias": "inputDate"; "required": false; }; "timePicker": { "alias": "timePicker"; "required": false; }; "manualTimePicker": { "alias": "manualTimePicker"; "required": false; }; "title": { "alias": "title"; "required": false; }; "hideClearButton": { "alias": "hideClearButton"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class IDEADateTimeComponent implements OnInit, OnDestroy, OnChanges {
+    private _modal;
+    private _translate;
+    /**
+     * The date to show/pick.
+     */
+    date: epochDateTime | epochISOString;
+    /**
+     * Whether to show the time picker (datetime) or not (date).
+     */
+    timePicker: boolean;
+    /**
+     * Whether to show the MANUAL time picker (datetime) or not (date).
+     */
+    manualTimePicker: boolean;
+    /**
+     * Whether to use the `epochISOString` format instead of `epochDateTime`.
+     */
+    useISOFormat: boolean;
+    /**
+     * The label for the field.
+     */
+    label: string;
+    /**
+     * The icon for the field.
+     */
+    icon: string;
+    /**
+     * The color of the icon.
+     */
+    iconColor: string;
+    /**
+     * Lines preferences for the item.
+     */
+    lines: string;
+    /**
+     * The color for the component.
+     */
+    color: string;
+    /**
+     * A placeholder for the field.
+     */
+    placeholder: string;
+    /**
+     * If true, the component is disabled.
+     */
+    disabled: boolean;
+    /**
+     * If true, the obligatory dot is shown.
+     */
+    obligatory: boolean;
+    /**
+     * If true, hidew the clear button in the header.
+     */
+    hideClearButton: boolean;
+    /**
+     * If set, is the minimum date selectable.
+     */
+    min: epochDateTime | epochISOString;
+    /**
+     * If set, is the maximum date selectable.
+     */
+    max: epochDateTime | epochISOString;
+    dateChange: EventEmitter<any>;
+    iconSelect: EventEmitter<void>;
+    valueToDisplay: string;
+    private langChangeSubscription;
+    isOpening: boolean;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    openCalendarPicker(): Promise<void>;
+    private getValueToDisplay;
+    doSelect(date: Date): void;
+    doIconSelect(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IDEADateTimeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IDEADateTimeComponent, "idea-date-time", never, { "date": { "alias": "date"; "required": false; }; "timePicker": { "alias": "timePicker"; "required": false; }; "manualTimePicker": { "alias": "manualTimePicker"; "required": false; }; "useISOFormat": { "alias": "useISOFormat"; "required": false; }; "label": { "alias": "label"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "iconColor": { "alias": "iconColor"; "required": false; }; "lines": { "alias": "lines"; "required": false; }; "color": { "alias": "color"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "obligatory": { "alias": "obligatory"; "required": false; }; "hideClearButton": { "alias": "hideClearButton"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; }, { "dateChange": "dateChange"; "iconSelect": "iconSelect"; }, never, never, true, never>;
+}
+
+declare class IDEADurationComponent implements OnChanges {
+    /**
+     * The default number of seconds, to build the duration.
+     */
+    default: number;
+    /**
+     * The label for the field.
+     */
+    label: string;
+    /**
+     * The icon (alternative to the label) for the field.
+     */
+    icon: string;
+    /**
+     * The title (hint) for the field.
+     */
+    title: string;
+    /**
+     * If true, the component is disabled.
+     */
+    disabled: boolean;
+    /**
+     * If true, the obligatory dot is shown.
+     */
+    obligatory: boolean;
+    /**
+     * Lines preferences for the item.
+     */
+    lines: string;
+    /**
+     * The color for the component.
+     */
+    color: string;
+    /**
+     * Whether to show or hide the seconds input.
+     */
+    hideSeconds: boolean;
+    /**
+     * Whether to show a shortened version of the labels.
+     */
+    shortLabels: boolean;
+    /**
+     * On change event. It emits a number of seconds representing the duration.
+     */
+    set: EventEmitter<number>;
+    /**
+     * The hour part of the duration.
+     */
+    hours: number;
+    /**
+     * The minutes part of the duration.
+     */
+    minutes: number;
+    /**
+     * The seconds part of the duration.
+     */
+    seconds: number;
+    constructor();
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * When one of the parts changes, emit the new duration.
+     */
+    setDuration(type: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IDEADurationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IDEADurationComponent, "idea-duration", never, { "default": { "alias": "default"; "required": false; }; "label": { "alias": "label"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "title": { "alias": "title"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "obligatory": { "alias": "obligatory"; "required": false; }; "lines": { "alias": "lines"; "required": false; }; "color": { "alias": "color"; "required": false; }; "hideSeconds": { "alias": "hideSeconds"; "required": false; }; "shortLabels": { "alias": "shortLabels"; "required": false; }; }, { "set": "set"; }, never, never, true, never>;
+}
+
+declare class IDEAEchoPage implements OnInit {
+    protected _env: any;
+    private _route;
+    private _tc;
+    private _loading;
+    private _API;
+    private _translate;
+    content: string;
+    htmlContent: string;
+    success: boolean;
+    ngOnInit(): void;
+    maintenanceMode(): void;
+    followRegistrationLink(code: string, user: string): Promise<void>;
+    followInvitationLink(code: string): Promise<void>;
+    followEmailChangeConfirmationLink(code: string): Promise<void>;
+    endGitHubIntegrationFlow(success: boolean): void;
+    endTrelloIntegrationFlow(token: string): void;
+    endExternalCalendarsIntegrationFlow(service: ExternalCalendarSources, code: string, calendarId: string): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IDEAEchoPage, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IDEAEchoPage, "idea-echo", never, {}, {}, never, never, true, never>;
+}
+declare enum EchoRequests {
+    MAINTENANCE = "maintenance",
+    REGISTRATION = "registration",
+    INVITATION = "invitation",
+    EMAIL_CHANGE = "email-change",
+    GITHUB_INTEGRATION = "github-integration",
+    TRELLO_INTEGRATION = "trello-integration",
+    MICROSOFT_CALENDARS_INTEGRATION = "microsoft-calendars-integration",
+    GOOGLE_CALENDARS_INTEGRATION = "google-calendars-integration"
+}
+
+declare const ideaEchoRoutes: Routes;
+
+declare class IDEAMDEComponent implements OnInit {
+    private _modal;
+    /**
+     * Id to identify this specific Markdown Editor (default: 'mde').
+     */
+    id: string;
+    /**
+     * The title of the modal.
+     */
+    title: string;
+    /**
+     * The header text content.
+     */
+    header: string;
+    /**
+     * The sub-header description.
+     */
+    description: string;
+    /**
+     * A series of text variables to substitute with values.
+     */
+    variables: string[];
+    /**
+     * If set, will customize the initial value of the editor.
+     */
+    initialValue: string;
+    /**
+     * Custom placeholder that should be displayed.
+     */
+    placeholder: string;
+    value: string;
+    ngOnInit(): void;
+    close(): void;
+    confirm(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IDEAMDEComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IDEAMDEComponent, "idea-mde", never, { "id": { "alias": "id"; "required": false; }; "title": { "alias": "title"; "required": false; }; "header": { "alias": "header"; "required": false; }; "description": { "alias": "description"; "required": false; }; "variables": { "alias": "variables"; "required": false; }; "initialValue": { "alias": "initialValue"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class IDEAMDEToolbarComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IDEAMDEToolbarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IDEAMDEToolbarComponent, "idea-mde-toolbar", never, {}, {}, never, never, true, never>;
+}
+
+declare class IDEAErrorReportingService {
+    protected _env: any;
+    protected _http: HttpClient;
+    protected _platform: Platform;
+    apiStage: string;
+    apiUrl: string;
+    constructor();
+    /**
+     * Send the error report to the back-end.
+     */
+    sendReport(error: Error, forceSend?: boolean): Promise<void>;
+    /**
+     * Whether we should send the reporting or we are in a scenario in which we should skip it.
+     */
+    shouldSend(): boolean;
+    /**
+     * Acquire the client's info.
+     */
+    getClientInfo(): ClientInfo;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IDEAErrorReportingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IDEAErrorReportingService>;
+}
+
+/**
+ * @deprecated use a specific App service instead.
+ */
+declare class IDEATinCanService {
+    protected data: any;
+    constructor();
+    /**
+     * Set a variable with the given value.
+     * @param variable variable to set
+     * @param value value to assign to the variable
+     */
+    set(variable: string, value: any): void;
+    /**
+     * Get the content of a variable.
+     * @param variable variable to acquire
+     * @param getAndDelete if set, delete the variable after the acquisition
+     */
+    get(variable: string, getAndDelete?: boolean): any;
+    /**
+     * Remove a variable.
+     * @param variable variable to remove
+     */
+    remove(variable: string): void;
+    /**
+     * Clear all the variables.
+     */
+    clear(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IDEATinCanService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IDEATinCanService>;
+}
+
+/**
+ * Utility to monitor the network connection.
+ * Note: don't use it directly, if you're also using IDEAOfflineDataService.
+ */
+declare class IDEAOfflineService {
+    /**
+     * True/false if the platform is offline/online.
+     */
+    protected _isOffline: boolean;
+    /**
+     * The observable for subscribing to online/offline status changes.
+     */
+    protected observable: Observable<boolean>;
+    /**
+     * The handler for listenig to network changes.
+     */
+    protected listenerHandler: any;
+    constructor();
+    /**
+     * Subscribe to be notified when the connection status changes.
+     */
+    subscribe(callback: (isOnline: boolean) => void): Subscription;
+    /**
+     * Quickly check the connection status.
+     */
+    isOnline(): boolean;
+    /**
+     * Quickly check the connection status.
+     */
+    isOffline(): boolean;
+    /**
+     * Quickly check for online connection.
+     */
+    check(): Promise<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IDEAOfflineService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IDEAOfflineService>;
+}
+
+/**
+ * To communicate with an AWS's API Gateway istance.
+ *
+ * Includes a rundimental cache on GET requests, until Android doesn't support SWs on local files.
+ *
+ * Note: requires an `AWSAPIAuthToken` variable to be set by IDEATinCanService service.
+ */
+declare class IDEAAWSAPIService {
+    protected _env: any;
+    protected _http: HttpClient;
+    protected _platform: Platform;
+    protected _tc: IDEATinCanService;
+    protected _storage: IDEAStorageService;
+    protected _errorReporting: IDEAErrorReportingService;
+    protected _offline: IDEAOfflineService;
+    apiStage: string;
+    apiUrlProject: string;
+    ideaApiStage: string;
+    apiUrlIDEA: string;
+    constructor();
+    /**
+     * Execute an online API request.
+     * @param resource resource name (e.g. `users`)
+     * @param method enum HTTP methods
+     * @param options the request options
+     */
+    protected request(resource: string, method: string, options?: APIRequestOption): Promise<any>;
+    /**
+     * Prepare the URL to which execute the request.
+     */
+    protected prepareURL(resource: string, opt: APIRequestOption): string;
+    /**
+     * Prepare the headers object to send with a request.
+     * Note: it always adds the Authorization token (`AWSAPIAuthToken`) and the API key (`AWSAPIKey`), if set.
+     */
+    protected prepareHeaders(h: HttpHeaders | any): HttpHeaders;
+    /**
+     * Prepare the queryParams object to send with a request; if requested, add some info about the client.
+     */
+    protected prepareQueryParams(qp: HttpParams | any, addClientInfo?: boolean): HttpParams;
+    /**
+     * Converts the error message to be readable.
+     */
+    protected fixErrMessageBeforeReject(err: HttpErrorResponse, reject: any): void;
+    /**
+     * Use the HttpClient to execute a raw request.
+     */
+    rawRequest(): HttpClient;
+    /**
+     * HEAD request.
+     * @param resource resource name (e.g. `users`)
+     * @param options the request options
+     */
+    headResource(resource: string, options?: APIRequestOption): Promise<any>;
+    /**
+     * GET request. Include options to cache the requests (`options.useCache`), to work also offline.
+     * @param resource resource name (e.g. `users`)
+     * @param options the request options
+     */
+    getResource(resource: string, options?: APIRequestOption): Promise<any>;
+    /**
+     * Observe a GET request. Include options to cache the requests (`options.useCache`), to work also offline.
+     * @param resource resource name (e.g. `users`)
+     * @param options the request options
+     */
+    getResourceObserver(resource: string, options?: APIRequestOption): Observable<any>;
+    /**
+     * Execute a GET request from the local storage.
+     * @param resource resource name (e.g. `users`)
+     * @param options the request options
+     */
+    getFromCache(resource: string, options?: APIRequestOption): Promise<any>;
+    /**
+     * Execute a PUT request in the local storage.
+     * @param resource resource name (e.g. `users`)
+     * @param data resource data
+     * @param options the request options
+     */
+    putInCache(resource: string, data: any, options?: APIRequestOption): Promise<void>;
+    /**
+     * Execute a DELETE request in the local storage.
+     * @param resource resource name (e.g. `users`)
+     * @param options the request options
+     */
+    deleteFromCache(resource: string, options?: APIRequestOption): Promise<void>;
+    /**
+     * POST request.
+     * @param resource resource name (e.g. `users`)
+     * @param options the request options
+     */
+    postResource(resource: string, options?: APIRequestOption): Promise<any>;
+    /**
+     * PUT request.
+     * @param resource resource name (e.g. `users`)
+     * @param options the request options
+     */
+    putResource(resource: string, options?: APIRequestOption): Promise<any>;
+    /**
+     * PATCH request.
+     * @param resource resource name (e.g. `users`)
+     * @param options the request options
+     */
+    patchResource(resource: string, options?: APIRequestOption): Promise<any>;
+    /**
+     * DELETE request.
+     * @param resource resource name (e.g. `users`)
+     * @param options the request options
+     */
+    deleteResource(resource: string, options?: APIRequestOption): Promise<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IDEAAWSAPIService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IDEAAWSAPIService>;
+}
+/**
+ * The options of an API request.
+ */
+declare class APIRequestOption {
+    /**
+     * To identify a specific resource by id.
+     */
+    resourceId?: string;
+    /**
+     * The query parameters of the request.
+     */
+    params?: any;
+    /**
+     * The body of the request.
+     */
+    body?: any;
+    /**
+     * The additional headers of the request; `Authorization` is included by default.
+     */
+    headers?: any;
+    /**
+     * Which mode to use to take advance of the requests caching mechanism.
+     */
+    useCache?: CacheModes;
+    /**
+     * If true, report the errors that occurs during the request.
+     */
+    reportError?: boolean;
+    /**
+     * If true, use IDEA's API instead of the project's API).
+     */
+    idea?: boolean;
+    /**
+     * If `idea` is not set, set this to use an alternative API URL for the request.
+     */
+    alternativeAPI?: string;
+}
+/**
+ * Set of usable cache modes.
+ */
+declare enum CacheModes {
+    /**
+     * Return the result from an online request, with no cache involved.
+     */
+    NO_CACHE = 0,
+    /**
+     * Return the result from an online request, storing the result in the cache, to update it with the latest data.
+     */
+    NETWORK_FIRST = 1,
+    /**
+     * Return the result from the cache, but also execute the request online, to update the cache with the latest data.
+     */
+    CACHE_FIRST = 2,
+    /**
+     * Return the result from the cache, without retrying online if a result wasn't found.
+     */
+    CACHE_ONLY = 3
+}
+
+/**
+ * After how much time we need to request a synchronisation to keep the contents up-to-date.
+ */
+declare const SYNC_EXPIRATION_INTERVAL: number;
+/**
+ * Prefix for the key of the API requests queue info in the local storage.
+ */
+declare const QUEUE_API_REQUESTS_KEY = "IDEAOfflineService.queueAPIrequests";
+/**
+ * Prefix for the key of the last sync time info in the local storage.
+ */
+declare const LAST_SYNC_KEY = "IDEAOfflineService.lastSyncAt";
+/**
+ * The max number of elements per resource to synchronize during the first analysis of a synchronisation.
+ * If the number of elements exceeds (there is more data after the 1st page), the operation require manual confirmation.
+ */
+declare const NUM_ELEMENTS_WITHOUT_MANUAL_SYNC = 100;
+/**
+ * The max number of elements per resource to request at the same time during a normal synchronisation.
+ */
+declare const NUM_ELEMENTS_WITH_MANUAL_SYNC = 300;
+/**
+ * Manage the offline functioning of the app's data (upload/download/synchronization).
+ * Note: it includes all the methods of IDEAOfflineService.
+ *
+ * Download: it works through the **Delta** mechanism on back-end resources.
+ * Practically, the service prepares each possible API GET requests for each of the involved resources.
+ * In this way, if offline, the API service can hit an element by URL in the cache (storage offline).
+ *
+ * **How to use it**. Configure the sync mechanism in the main app.component as it follows:
+ *
+ *    1. Implement a CacheableResource class for each DeltaResource you want to cache offline.
+ *    2. Set up the service (`setUpOfflineData`).
+ *    3. Run a synchronization.
+ *    4. Add the navigation to the Offline Manager (UI).
+ *    5. Optionally, push offline API requests to the queue when offline.
+ *
+ * e.g. of CacheableResource classes:
+ * ```
+ * class CustomerCR extends CacheableResource {
+ *   constructor(description: string) {
+ *     super(DeltaResources.CUSTOMERS, description);
+ *   }
+ *   public listURL(element: any): string {
+ *     return `teams/${element.teamId}/customers`;
+ *   }
+ *   public elementURL(element: any): string {
+ *     return `teams/${element.teamId}/customers/${element.customerId}`;
+ *   }
+ *   public findIndexInList(list: Array<any>, element: any): number {
+ *     return list.findIndex(x => x.customerId === element.customerId);
+ *   }
+ *   public sort(a: any, b: any): number {
+ *     return a.name.localeCompare(b.name);
+ *   }
+ * }
+ */
+declare class IDEAOfflineDataService {
+    protected _storage: IDEAStorageService;
+    protected _translate: IDEATranslationsService;
+    protected _offline: IDEAOfflineService;
+    protected _API: IDEAAWSAPIService;
+    /**
+     * True when running a synchronization.
+     */
+    synchronizing: boolean;
+    /**
+     * The timestamp of the last synchronization.
+     */
+    lastSyncAt: epochDateTime;
+    /**
+     * True if an error happened in the last synchronization.
+     */
+    errorInLastSync: boolean;
+    /**
+     * True if the synchronisation is too vast and so require a manual action of the user.
+     */
+    requiresManualConfirmation: boolean;
+    /**
+     * If false, ignore the entire upload scenario.
+     */
+    useQueueAPIRequests: boolean;
+    /**
+     * The array of the requests not executed because we are/were offline; they need to run once online.
+     */
+    queueAPIRequests: APIRequest[];
+    /**
+     * The id of the team of which to manage data offline.
+     * If null, the project isn't teams-based.
+     */
+    protected teamId: string;
+    /**
+     * The array of DeltaResources to cache offline.
+     */
+    protected resources: (DeltaResources | string)[];
+    /**
+     * Helper structure to manage the CacheableResource for each DeltaResource.
+     */
+    protected cacheableResources: {
+        [resource: string]: CacheableResource;
+    };
+    /**
+     * Key to acquire from the storage the lastSyncAt information of the team.
+     */
+    protected lastSyncKey: string;
+    /**
+     * Key to acquire from the storage the lastSyncAt information of the team.
+     */
+    protected queueAPIRequestKey: string;
+    constructor();
+    /**
+     * Quickly check the connection status.
+     */
+    isOnline(): boolean;
+    /**
+     * Quickly check the connection status.
+     */
+    isOffline(): boolean;
+    /**
+     * Subscribe to the service to be notified when the connection status changes.
+     */
+    subscribe(callback: (isOnline: boolean) => void): Subscription;
+    /**
+     * Quickly check for online connection.
+     */
+    check(): Promise<boolean>;
+    /**
+     * Whether the offline mode is allowed. You can customize this function, if needed.
+     */
+    isAllowed(): boolean;
+    /**
+     * Set up the service to use and sync offline data.
+     */
+    setUpOfflineData(teamId: string, useQueueAPIRequests: boolean, cacheableResources: CacheableResource[]): void;
+    /**
+     * Load from the local storage the last sync at information.
+     */
+    protected loadLastSyncAt(): Promise<number>;
+    /**
+     * Update last sync at info in the local storage.
+     */
+    protected saveLastSyncAt(lastSyncAt: number): Promise<void>;
+    /**
+     * Add a CacheableResource.
+     */
+    protected addCacheableResource(cacheableResource: CacheableResource): void;
+    /**
+     * Remove a CacheableResource by its DeltaResource.
+     */
+    protected removeCacheableResource(resource: DeltaResources | string): void;
+    /**
+     * Get the the DeltaResourced configured.
+     */
+    getResources(): (DeltaResources | string)[];
+    /**
+     * Get a CacheableResource by its DeltaResource.
+     */
+    getCacheableResource(resource: DeltaResources | string): CacheableResource;
+    /**
+     * Execute all the API requests in the queue; the requests terminated with an error will remain in the queue.
+     */
+    protected runQueueAPIRequests(): Promise<void>;
+    /**
+     * Load from the local storage the API requests queue.
+     */
+    protected loadQueueAPIRequest(): Promise<APIRequest[]>;
+    /**
+     * Update the queue in memory and also save the copy in the local storage.
+     */
+    saveQueueAPIRequest(queue?: APIRequest[]): Promise<void>;
+    /**
+     * Delete a request stuck in an error.
+     */
+    deleteRequest(request: APIRequest): Promise<never>;
+    /**
+     * Save the records of a delta and, if the latter has more pages, go recursive.
+     */
+    protected syncDeltaRecords(delta: Delta, done?: any): Promise<any>;
+    /**
+     * Save offline a list of DeltaRecords for this resource, creating a map of all the corresponding API GET requests.
+     */
+    protected syncResourceDeltaRecords(resource: string, records: DeltaRecord[]): Promise<boolean>;
+    /**
+     * Run a sync, but only if needed, i.e. the cached content expired or we have pending API requests in the queue.
+     */
+    synchronizeIfNeeded(): Promise<void>;
+    /**
+     * Synchronization of the whole set of resources (upload+download).
+     * @param manualConfirmation if true, the request comes directly from a user action (not automatic procedures).
+     */
+    synchronize(manualConfirmation?: boolean): Promise<void>;
+    /**
+     * Force a full synchronisation.
+     */
+    forceFullSync(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IDEAOfflineDataService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IDEAOfflineDataService>;
+}
+/**
+ * The description of an API request to a resource, to use with `IDEAAWSAPI`.
+ * Used for queues of requests (UPLOAD).
+ */
+interface APIRequest {
+    /**
+     * Resource path (e.g. `users` or `teams/${teamId}/users`).
+     */
+    resource: string;
+    /**
+     * The id to identify a specific element of the resource.
+     */
+    resourceId: string;
+    /**
+     * The API request method (e.g. POST, PUT, PATCH).
+     */
+    method: string;
+    /**
+     * The body of the request.
+     */
+    body: any;
+    /**
+     * A description to show for the request.
+     */
+    description?: string;
+    /**
+     * If not null, the request tried to run but it encountered the error.
+     */
+    error?: string;
+}
+/**
+ * The abstract class to implement for each resource to cache offline from the back-end (DOWNLOAD).
+ */
+declare abstract class CacheableResource {
+    /**
+     * The team owning the resource.
+     * If null, the project isn't teams-based.
+     */
+    teamId: string;
+    /**
+     * The identifier of the resource.
+     */
+    resource: DeltaResources | string;
+    /**
+     * The resource description (translated) for the UI.
+     */
+    description: string;
+    /**
+     * Runtime attribute to know if the resource is synchronizing.
+     */
+    synchronizing: boolean;
+    /**
+     * True if one of the elements failed the execution.
+     */
+    error: boolean;
+    constructor(resource: string, description: string);
+    /**
+     * How to build the relative URL to the resource (list).
+     * E.g. `teams/${element.teamId}/customers` or `customers`.
+     */
+    abstract listURL(element: any): string;
+    /**
+     * How to build the relative URL to the resource element (detail).
+     * E.g. `teams/${element.teamId}/customers/${element.customerId}` or `customers/${element.customerId}`.
+     */
+    abstract elementURL(element: any): string;
+    /**
+     * How to uniquely identify an element in the list (by its ids).
+     * E.g. `return list.findIndex(x => x.customerId === element.customerId);`
+     */
+    abstract findIndexInList(list: any[], element: any): number;
+    /**
+     * How to keep the list sorted.
+     * E.g. `return a.name.localeCompare(b.name);`
+     */
+    abstract sort(a: any, b: any): number;
+}
+
+declare class IDEACacheableResourceComponent {
+    _offline: IDEAOfflineDataService;
+    /**
+     * The resouece to manage.
+     */
+    resource: CacheableResource;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IDEACacheableResourceComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IDEACacheableResourceComponent, "idea-cacheable-resource", never, { "resource": { "alias": "resource"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class IDEAOfflineIndicatorComponent {
+    private _alert;
+    private _modal;
+    private _translate;
+    _platform: Platform;
+    _offline: IDEAOfflineDataService;
+    /**
+     * Vertical position.
+     */
+    vertical: string;
+    /**
+     * Horizontal position.
+     */
+    horizontal: string;
+    /**
+     * Whether it is positionated on an edge.
+     */
+    edge: boolean;
+    showStatus(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IDEAOfflineIndicatorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IDEAOfflineIndicatorComponent, "idea-offline-indicator", never, { "vertical": { "alias": "vertical"; "required": false; }; "horizontal": { "alias": "horizontal"; "required": false; }; "edge": { "alias": "edge"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class IDEAOfflineManagerComponent {
+    private _modal;
+    private _alert;
+    private _actions;
+    private _translate;
+    _offline: IDEAOfflineDataService;
+    sync(): Promise<void>;
+    deleteRequest(request: APIRequest): Promise<void>;
+    downloadRequestLog(request: APIRequest): void;
+    actions(): Promise<void>;
+    forceFullSync(): Promise<void>;
+    close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IDEAOfflineManagerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IDEAOfflineManagerComponent, "idea-offline-manager", never, {}, {}, never, never, true, never>;
+}
+
+declare class IDEASentimentComponent implements OnChanges {
+    protected _env: any;
+    private _API;
+    private _translate;
+    _offline: IDEAOfflineService;
+    /**
+     * The sentiment detected from the input text.
+     */
+    sentiment: Sentiment;
+    /**
+     * The input text.
+     */
+    text: string;
+    /**
+     * Lines preferences for the item.
+     */
+    lines: string;
+    /**
+     * The color for the component.
+     */
+    color: string;
+    /**
+     * Triggers when the sentiment change.
+     */
+    change: EventEmitter<Sentiment>;
+    ngOnChanges(changes: SimpleChanges): void;
+    private detectSentiment;
+    getColorBySentiment(sentiment?: Sentiment | string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IDEASentimentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IDEASentimentComponent, "idea-sentiment", never, { "text": { "alias": "text"; "required": false; }; "lines": { "alias": "lines"; "required": false; }; "color": { "alias": "color"; "required": false; }; }, { "change": "change"; }, never, never, true, never>;
+}
+
+declare class IDEAFromTimeToTimeComponent implements OnInit {
+    private _modal;
+    private _translate;
+    /**
+     * The time interval to set.
+     */
+    timeInterval: TimeInterval;
+    /**
+     * Whether we should start picking the time displaying the afternoon (PM) or the morning (AM, default).
+     */
+    period: Periods;
+    /**
+     * A time to use as lower limit for the possible choices.
+     */
+    notEarlierThan: number;
+    /**
+     * A time to use as upper limit for the possible choices.
+     */
+    notLaterThan: number;
+    /**
+     * The title of the component.
+     */
+    title: string;
+    segment: Segments;
+    Segments: typeof Segments;
+    Periods: typeof Periods;
+    timeIntervalWC: TimeInterval;
+    minutes: number;
+    ngOnInit(): void;
+    setInterval(hours: number, minutes?: number): void;
+    private timeToMs;
+    getClockButtonContent(hours: number, minutes?: number): string;
+    private contextualizeHour;
+    equalsFrom(hours: number, minutes?: number): boolean;
+    isAllowed(hours: number, minutes?: number): boolean;
+    isHourOfOppositeMeridian(hours: number, minutes?: number): boolean;
+    msToTimeString(time: number): string;
+    save(): void;
+    reset(): void;
+    close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IDEAFromTimeToTimeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IDEAFromTimeToTimeComponent, "idea-from-time-to-time", never, { "timeInterval": { "alias": "timeInterval"; "required": false; }; "period": { "alias": "period"; "required": false; }; "notEarlierThan": { "alias": "notEarlierThan"; "required": false; }; "notLaterThan": { "alias": "notLaterThan"; "required": false; }; "title": { "alias": "title"; "required": false; }; }, {}, never, never, true, never>;
+}
+/**
+ * The two stages of the component, to pick the start and the end of the interval.
+ */
+declare enum Segments {
+    FROM = "FROM",
+    TO = "TO"
+}
+/**
+ * The two possible periods of the component, to interpret the clock the right way.
+ */
+declare enum Periods {
+    AM = "AM",
+    PM = "PM"
+}
+
+declare class IDEATimeIntervalComponent implements OnInit, OnDestroy, OnChanges {
+    private _modal;
+    private _translate;
+    /**
+     * The time interval to set.
+     */
+    timeInterval: TimeInterval;
+    /**
+     * Whether we should start picking the time displaying the afternoon (PM) or the morning (AM, default).
+     */
+    period: Periods;
+    /**
+     * A time to use as lower limit for the possible choices.
+     */
+    notEarlierThan: number;
+    /**
+     * A time to use as upper limit for the possible choices.
+     */
+    notLaterThan: number;
+    /**
+     * The label for the field.
+     */
+    label: string;
+    /**
+     * The icon for the field.
+     */
+    icon: string;
+    /**
+     * The color of the icon.
+     */
+    iconColor: string;
+    /**
+     * A placeholder for the field.
+     */
+    placeholder: string;
+    /**
+     * If true, the component is disabled.
+     */
+    disabled: boolean;
+    /**
+     * If true, the field has a tappable effect when disabled.
+     */
+    tappableWhenDisabled: boolean;
+    /**
+     * If true, the obligatory dot is shown.
+     */
+    obligatory: boolean;
+    /**
+     * Lines preferences for the item.
+     */
+    lines: string;
+    /**
+     * The color for the component.
+     */
+    color: string;
+    /**
+     * On select event.
+     */
+    select: EventEmitter<void>;
+    /**
+     * Icon select.
+     */
+    iconSelect: EventEmitter<void>;
+    /**
+     * On select (with the field disabled) event.
+     */
+    selectWhenDisabled: EventEmitter<void>;
+    valueToDisplay: string;
+    private langChangeSubscription;
+    isOpening: boolean;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private getValueToDisplay;
+    pickTimeInterval(): Promise<void>;
+    doSelectWhenDisabled(): void;
+    doIconSelect(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IDEATimeIntervalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IDEATimeIntervalComponent, "idea-time-interval", never, { "timeInterval": { "alias": "timeInterval"; "required": false; }; "period": { "alias": "period"; "required": false; }; "notEarlierThan": { "alias": "notEarlierThan"; "required": false; }; "notLaterThan": { "alias": "notLaterThan"; "required": false; }; "label": { "alias": "label"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "iconColor": { "alias": "iconColor"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "tappableWhenDisabled": { "alias": "tappableWhenDisabled"; "required": false; }; "obligatory": { "alias": "obligatory"; "required": false; }; "lines": { "alias": "lines"; "required": false; }; "color": { "alias": "color"; "required": false; }; }, { "select": "select"; "iconSelect": "iconSelect"; "selectWhenDisabled": "selectWhenDisabled"; }, never, never, true, never>;
+}
+
+/**
+ * To communicate with an AWS API Gateway websocket istance.
+ *
+ * Note: requires an `AWSAPIAuthToken` variable to be set by IDEATinCanService service.
+ */
+declare class IDEAAWSAPISocketService {
+    protected _env: any;
+    protected _tc: IDEATinCanService;
+    protected _errorReporting: IDEAErrorReportingService;
+    protected _offline: IDEAOfflineService;
+    apiStage: string;
+    /**
+     * The URL to connect for socket communication.
+     */
+    WEBSOCKET_API_URL: string;
+    /**
+     * The current websocket connection.
+     */
+    protected connection: WebSocket;
+    /**
+     * The options with which we opened a connection, to re-open it if needed.
+     */
+    protected options: IDEAAWSAPISocketServiceOpenOptions;
+    /**
+     * A timeout to ping the connection every once in a while, to keep it alive.
+     */
+    protected pingTimeout: any;
+    /**
+     * The timestamp of last activity for the connection, to make sure to ping it in case it's almost dead.
+     */
+    protected lastActivityAt: epochDateTime;
+    /**
+     * A timeout to re-try to open a connection later on, hoping we are online again.
+     */
+    protected offlineTimeout: any;
+    /**
+     * Whether the connection was correctly opened at least once.
+     */
+    protected wasOpenAtLeastOnce: boolean;
+    /**
+     * The maximum amount of minutes of inactivity after which we ping the connection to keep it alive.
+     */
+    MAX_INACTIVITY_MINUTES: number;
+    /**
+     * The amount of minutes after which we check if the connection needs to be pinged to be kept alive.
+     */
+    KEEP_ALIVE_MINUTES_INTERVAL: number;
+    /**
+     * In case we are offline, the amount of minutes after which we check if we are online, so we can re-connect.
+     */
+    TRY_AGAIN_OFFLINE_MINUTES: number;
+    constructor();
+    /**
+     * Open a connection to the websocket API.
+     */
+    open(options?: IDEAAWSAPISocketServiceOpenOptions): void;
+    /**
+     * Close the current connection to the websocket API.
+     * @param itShouldReopen in case the connection was forcibly closed, try to re-open it (with offline mechanism).
+     */
+    close(itShouldReopen?: boolean): void;
+    /**
+     * Try to-reopen a closed connection, if we are online.
+     */
+    protected reOpen(): Promise<void>;
+    /**
+     * Whether the socket connection is currently open.
+     */
+    isOpen(): boolean;
+    /**
+     * A simple message delivered to the server to keep the connection alive.
+     */
+    protected ping(): void;
+    /**
+     * Helper to keep the connection alive, if needed.
+     */
+    protected keepItAlive(): void;
+    /**
+     * Convert minutes to milliseconds.
+     */
+    protected minutesToMS(minutes: number): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IDEAAWSAPISocketService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IDEAAWSAPISocketService>;
+}
+/**
+ * The options to open a socket connection and handle its events.
+ */
+interface IDEAAWSAPISocketServiceOpenOptions {
+    /**
+     * Optional parameters needed to be passed to the socket's authorizer to open the connection.
+     * Note: the authentication (IDEA standard) is automatically included, if `noAuth` isn't set.
+     */
+    openParams?: {
+        [key: string]: any;
+    };
+    /**
+     * If set, the socket connection won't require authentication.
+     */
+    noAuth?: boolean;
+    /**
+     * Action to execute when the connection is confirmed "open" by the server.
+     */
+    onOpen?: (event: any) => void;
+    /**
+     * Action to execute when the connection closes (for external events).
+     */
+    onClose?: (event: any) => void;
+    /**
+     * Action to execute when a message is delivered from the server.
+     */
+    onMessage?: (event: any) => void;
+    /**
+     * Action to execute when an error occurs.
+     */
+    onError?: (event: any) => void;
+    /**
+     * If true, report the errors that occur (IDEA standard).
+     */
+    reportError?: boolean;
+    /**
+     * Whether to show debug messages.
+     */
+    debug?: boolean;
+}
+
+/**
+ * *The service aims to solve the resource caching behaviour of browsers.*
+ * *It's suggested to use it with avatars and other images/resources that can change based on user input.*
+ * The browsers tend to cache images based on their URL;
+ * sometimes, the image changes but the URL doesn't, and the browser keeps showing the old image.
+ * Through this service, when we change a resource (e.g. an image), we also update a cache key.
+ * Each time we load a resource through the service's method `getCachedImage`, we use the cache key as a query param;
+ * in this way, the browser uses the same cached images, until we change the cache key.
+ */
+declare class IDEACachedResourcesService {
+    /**
+     * Change it only if necessary.
+     */
+    cacheKeyIndex: string;
+    private cacheKey;
+    private storage;
+    constructor();
+    /**
+     * Load the cache key from the local storage.
+     */
+    private loadKeyFromStorage;
+    /**
+     * Get an image using the service's caching mechanism.
+     * Optionally update the cache key and forces the image's cache deletion.
+     */
+    getCachedResource(url: string, updateCacheKey?: boolean): string;
+    /**
+     * Set a new cache key.
+     */
+    updateCacheKey(key?: string | number): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IDEACachedResourcesService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IDEACachedResourcesService>;
+}
+
+/**
+ * To subscribe push notifications events.
+ */
+declare class IDEAPushNotificationsService {
+    private _platform;
+    private _errorReporting;
+    registrations: Observable<PushNotificationsDevice>;
+    notifications: Observable<PushNotificationSchema>;
+    errors: Observable<Error>;
+    constructor();
+    /**
+     * Return true if the device is supported.
+     */
+    isAvailable(): boolean;
+    /**
+     * To fire the registration of a new device: it will rewquest the permission to use Push Notification.
+     * On iOS will prompt the request, on Android it's automatic.
+     */
+    registerDevice(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IDEAPushNotificationsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IDEAPushNotificationsService>;
+}
+
+export { APIRequestOption, CacheModes, CacheableResource, ColorsPaletteComponent, EchoRequests, IDEAAWSAPIService, IDEAAWSAPISocketService, IDEAAddressComponent, IDEAAnnouncementComponent, IDEACacheableResourceComponent, IDEACachedResourcesService, IDEACalendarPickerComponent, IDEAColorPickerComponent, IDEAContactsComponent, IDEADateTimeComponent, IDEADurationComponent, IDEAEchoPage, IDEAErrorReportingService, IDEAFromTimeToTimeComponent, IDEAMDEComponent, IDEAMDEToolbarComponent, IDEAOfflineDataService, IDEAOfflineIndicatorComponent, IDEAOfflineManagerComponent, IDEAOfflineService, IDEAPushNotificationsService, IDEASentimentComponent, IDEATimeIntervalComponent, IDEATinCanService, LAST_SYNC_KEY, NUM_ELEMENTS_WITHOUT_MANUAL_SYNC, NUM_ELEMENTS_WITH_MANUAL_SYNC, Periods, QUEUE_API_REQUESTS_KEY, SYNC_EXPIRATION_INTERVAL, ideaEchoRoutes };
+export type { APIRequest, IDEAAWSAPISocketServiceOpenOptions };