import * as _angular_core from '@angular/core';
import { OnInit, EventEmitter, OnChanges, SimpleChanges, OnDestroy, PipeTransform, EnvironmentProviders, NgZone, InjectionToken } from '@angular/core';
import { ActionSheetButton } from '@ionic/core';
import { AppStatus, Attachment, AttachmentSections, AttachmentSection, Check, Languages, Label, CustomBlockMeta, CustomFieldTypes, CustomFieldMeta, CustomSectionMeta, EmailData, StringVariable, Suggestion, Ionicons, LabelVariable, PDFTemplateBlueprint, PDFTemplateSection, PDFTemplateSectionBlueprint, PDFTemplateSectionTypes, PDFTemplateSimpleField, PDFTemplateComplexField, Signature, epochDateTime } from 'idea-toolbox';
import { Routes } from '@angular/router';
import { IonSearchbar, IonPopover } from '@ionic/angular/standalone';
import SignaturePad from 'signature_pad';

/**
 * It's an alternative for desktop devices to the traditional ActionSheet.
 * It shares (almost) the same inputs so they are interchangeable.
 */
declare class IDEAActionSheetComponent implements OnInit {
    private _popover;
    /**
     * An array of buttons for the actions panel.
     */
    buttons: ActionSheetButton[];
    /**
     * Additional classes to apply for custom CSS. If multiple classes are provided they should be separated by spaces.
     */
    cssClass?: string;
    /**
     * Title for the actions panel.
     */
    header?: string;
    /**
     * Subtitle for the actions panel.
     */
    subHeader?: string;
    withIcons: boolean;
    ngOnInit(): void;
    buttonClicked(button: ActionSheetButton): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IDEAActionSheetComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IDEAActionSheetComponent, "idea-action-sheet", never, { "buttons": { "alias": "buttons"; "required": false; }; "cssClass": { "alias": "cssClass"; "required": false; }; "header": { "alias": "header"; "required": false; }; "subHeader": { "alias": "subHeader"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * It's an alternative to the traditional ActionSheetController.
 * It shares (almost) the same inputs, so they are interchangeable.
 */
declare class IDEAActionSheetController {
    private _platform;
    private _actions;
    private _popover;
    /**
     * Based on the platform, open the traditional or the customised ActionSheet.
     */
    create(options: IDEAActionSheetOptions, forceCustom?: boolean): Promise<HTMLIonActionSheetElement>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IDEAActionSheetController, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<IDEAActionSheetController>;
}
/**
 * The options for the ActionSheet.
 */
interface IDEAActionSheetOptions {
    /**
     * If true, the action sheet will be dismissed when the backdrop is clicked.
     */
    backdropDismiss?: boolean;
    /**
     * An array of buttons for the action sheet.
     */
    buttons: ActionSheetButton[];
    /**
     * Additional classes to apply for custom CSS. If multiple classes are provided they should be separated by spaces.
     */
    cssClass?: string;
    /**
     * Title for the action sheet.
     */
    header?: string;
    /**
     * Subtitle for the action sheet.
     */
    subHeader?: string;
}

/**
 * Handle blocking status messaging for the app.
 */
declare class IDEAAppStatusPage {
    protected _env: any;
    private _platform;
    private _translate;
    private _appStatus;
    status: AppStatus;
    htmlContent: string;
    appleStoreURL: string;
    googleStoreURL: string;
    appIconURI: string;
    constructor();
    ionViewWillEnter(): Promise<void>;
    getTitle(): string;
    isAndroid(): boolean;
    isIOS(): boolean;
    openGoogleStoreLink(): Promise<void>;
    opeAppleStoreLink(): Promise<void>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IDEAAppStatusPage, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IDEAAppStatusPage, "idea-app-status", never, {}, {}, never, never, true, never>;
}

declare const ideaAppStatusRoutes: Routes;

/**
 * Check whether the app has some status message or update to handle.
 */
declare class IDEAAppStatusService {
    protected _env: any;
    private _nav;
    private _toast;
    private _translate;
    private _api;
    private _storage;
    private _appRef;
    appStatus: AppStatus;
    storageKey: string;
    statusFileURL: string;
    constructor();
    /**
     * Check the app's status and take according actions.
     */
    check(options?: {
        viaApi?: boolean;
        toastColor?: string;
        toastPosition?: string;
    }): Promise<AppStatus>;
    private getStatus;
    private getStatusFromApi;
    private getStatusFromAsset;
    private presentToast;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IDEAAppStatusService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<IDEAAppStatusService>;
}

declare class IDEAAttachmentsComponent {
    protected _env: any;
    private _loading;
    private _message;
    private _translate;
    private _attachments;
    /**
     * The array of attachments to display and manage.
     */
    readonly attachments: _angular_core.ModelSignal<Attachment[]>;
    /**
     * The API path to the entity for which we want to manage the attachments.
     */
    readonly entityPath: _angular_core.InputSignal<string | string[]>;
    /**
     * The list of accepted formats.
     */
    readonly acceptedFormats: _angular_core.InputSignal<string[]>;
    /**
     * Whether to accept multiple files as target for the browse function.
     */
    readonly multiple: _angular_core.InputSignal<boolean>;
    /**
     * Whether we are viewing or editing the attachments.
     */
    readonly disabled: _angular_core.InputSignal<boolean>;
    /**
     * The background color of the component.
     */
    readonly color: _angular_core.InputSignal<string>;
    /**
     * Trigger to download a file by URL.
     */
    readonly download: _angular_core.OutputEmitterRef<string>;
    readonly attachmentPicker: _angular_core.Signal<any>;
    uploadErrors: _angular_core.WritableSignal<UploadError[]>;
    maxSize: any;
    browseFiles(): Promise<void>;
    addAttachmentsFromPicker(target: HTMLInputElement): void;
    private addAttachmentToListAndUpload;
    removeAttachment(attachment: Attachment): void;
    removeErrorFromList(err: UploadError): void;
    reorderAttachments(ev: any): void;
    downloadAttachment(attachment: Attachment): Promise<void>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IDEAAttachmentsComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IDEAAttachmentsComponent, "idea-attachments", never, { "attachments": { "alias": "attachments"; "required": false; "isSignal": true; }; "entityPath": { "alias": "entityPath"; "required": false; "isSignal": true; }; "acceptedFormats": { "alias": "acceptedFormats"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; }, { "attachments": "attachmentsChange"; "download": "download"; }, never, never, true, never>;
}
interface UploadError {
    file: string;
    error: string;
}

declare class IDEAAttachmentSectionsComponent {
    private _modal;
    private _alert;
    private _message;
    private _translate;
    /**
     * The attachment sections to display and manage.
     */
    readonly attachmentSections: _angular_core.InputSignal<AttachmentSections>;
    /**
     * The API path to the entity for which we want to manage the attachments.
     */
    readonly entityPath: _angular_core.InputSignal<string | string[]>;
    /**
     * The list of accepted formats.
     */
    readonly acceptedFormats: _angular_core.InputSignal<string[]>;
    /**
     * Whether to accept multiple files as target for the browse function.
     */
    readonly multiple: _angular_core.InputSignal<boolean>;
    /**
     * Whether the component is disabled or not.
     */
    readonly disabled: _angular_core.InputSignal<boolean>;
    /**
     * Lines preferences for the component.
     */
    readonly lines: _angular_core.InputSignal<string>;
    /**
     * The background color of the component.
     */
    readonly color: _angular_core.InputSignal<string>;
    /**
     * Trigger to download a file by URL.
     */
    readonly download: _angular_core.OutputEmitterRef<string>;
    reorderSectionsLegend(ev: any): void;
    manageSection(s: string): Promise<void>;
    removeSection(sectionKey: string, event: Event): Promise<void>;
    addNewSection(): Promise<void>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IDEAAttachmentSectionsComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IDEAAttachmentSectionsComponent, "idea-attachment-sections", never, { "attachmentSections": { "alias": "attachmentSections"; "required": false; "isSignal": true; }; "entityPath": { "alias": "entityPath"; "required": false; "isSignal": true; }; "acceptedFormats": { "alias": "acceptedFormats"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "lines": { "alias": "lines"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; }, { "download": "download"; }, never, never, true, never>;
}

declare class IDEAManageAttachmentsSectionComponent implements OnInit {
    private _modal;
    private _translate;
    /**
     * The attachments section to manage.
     */
    section?: AttachmentSection;
    /**
     * The API path to the entity for which we want to manage the attachments.
     */
    entityPath?: string | string[];
    /**
     * The list of accepted formats.
     */
    acceptedFormats: string[];
    /**
     * Whether to accept multiple files as target for the browse function.
     */
    multiple: boolean;
    /**
     * Lines preferences for the component.
     */
    lines?: string;
    /**
     * The background color of the component.
     */
    color?: string;
    /**
     * Trigger a callback in the parent component to download a file by URL.
     */
    downloadCallback?: (url: string) => void;
    _section: AttachmentSection;
    errors: Set<string>;
    ngOnInit(): void;
    hasFieldAnError(field: string): boolean;
    editName(): Promise<void>;
    editDescription(): Promise<void>;
    private editLabel;
    save(): void;
    close(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IDEAManageAttachmentsSectionComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IDEAManageAttachmentsSectionComponent, "idea-manage-attachments-section", never, { "section": { "alias": "section"; "required": false; }; "entityPath": { "alias": "entityPath"; "required": false; }; "acceptedFormats": { "alias": "acceptedFormats"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "lines": { "alias": "lines"; "required": false; }; "color": { "alias": "color"; "required": false; }; "downloadCallback": { "alias": "downloadCallback"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * To communicate with an AWS API Gateway istance.
 * Lighter, alternative version of _IDEAAWSAPIService_.
 */
declare class IDEAApiService {
    protected _env: any;
    private _platform;
    private _appRef;
    /**
     * The base URL to which to make requests.
     */
    baseURL: string;
    /**
     * A reference to the current's app version.
     */
    appVersion: string;
    /**
     * A reference to the current's app package (bundle).
     * It can be `undefined` in case the app doesn't have a (mobile) app bundle.
     */
    appBundle: string;
    /**
     * Passed as `Authorization` header.
     */
    authToken: string | (() => Promise<string>);
    /**
     * Passed as `X-API-Key` header.
     */
    apiKey: string;
    /**
     * Some custom headers to set so that they are used in any API request.
     */
    defaultHeaders: Record<string, string | number>;
    constructor();
    /**
     * Execute an online API request.
     * @param path resource path (e.g. `['users', userId]`)
     * @param method HTTP method
     * @param options the request options
     */
    protected request(path: string[] | string, method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE', options?: ApiRequestOptions): Promise<any>;
    /**
     * GET request.
     */
    getResource(path: string[] | string, options?: ApiRequestOptions): Promise<any>;
    /**
     * POST request.
     */
    postResource(path: string[] | string, options?: ApiRequestOptions): Promise<any>;
    /**
     * PUT request.
     */
    putResource(path: string[] | string, options?: ApiRequestOptions): Promise<any>;
    /**
     * PATCH request.
     */
    patchResource(path: string[] | string, options?: ApiRequestOptions): Promise<any>;
    /**
     * DELETE request.
     */
    deleteResource(path: string[] | string, options?: ApiRequestOptions): Promise<any>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IDEAApiService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<IDEAApiService>;
}
/**
 * The options of an API request.
 */
interface ApiRequestOptions {
    /**
     * The additional headers of the request.
     * The headers "Authorization" and "X-API-Key" are included by default, if set.
     * The headers set in `defaultHeaders` are always added to any API request.
     */
    headers?: {
        [key: string]: string | number | boolean;
    };
    /**
     * The query parameters of the request.
     */
    params?: {
        [key: string]: string | number | boolean;
    };
    /**
     * The body of the request.
     */
    body?: any;
}

declare class IDEAAttachmentsService {
    protected _env: any;
    protected _api: IDEAApiService;
    private _appRef;
    /**
     * Upload a new attachment related to an entity and return the `attachmentId`.
     */
    uploadAndGetId(file: File, entityPath: string | string[], options?: {
        customAction?: string;
    }): Promise<string>;
    /**
     * Get the URL to download an attachment related to an entity.
     */
    getDownloadURL(attachment: Attachment | string, entityPath: string | string[], options?: {
        customAction?: string;
    }): Promise<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IDEAAttachmentsService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<IDEAAttachmentsService>;
}
/**
 * Approximate conversion of bytes in MB.
 */
declare const bytesToMegaBytes: (bytes: number) => number;

declare class IDEAChecksComponent implements OnInit {
    private _modal;
    /**
     * It should be read only until the component closure.
     */
    data?: Check[];
    /**
     * If true, sort alphabetically the data (by name or, fallback, by value).
     */
    sortData?: boolean;
    /**
     * A placeholder for the searchbar.
     */
    searchPlaceholder?: string;
    /**
     * The text to show in case no element is found after a search.
     */
    noElementsFoundText?: string;
    /**
     * Whether to show an avatar aside each element.
     */
    showAvatars?: boolean;
    /**
     * Limit the number of selectable elements to the value provided.
     * Note: if this attribute is active, `allowSelectDeselectAll` will be ignored.
     */
    limitSelectionToNum: number;
    /**
     * Whether to allow the select/deselect-all buttons.
     */
    allowSelectDeselectAll?: boolean;
    /**
     * A pre-filter for the category1.
     */
    category1?: string;
    /**
     * A pre-filter for the category2.
     */
    category2?: string;
    /**
     * Whether tho show the categories filters.
     */
    showCategoriesFilters: boolean;
    /**
     * The translation key to get the preview text; it has a `num` variable available.
     */
    previewTextKey: string;
    workingData: Check[];
    filteredChecks: _angular_core.WritableSignal<Check[]>;
    currentPage: number;
    activeCategories1: Set<string>;
    activeCategories2: Set<string>;
    readonly searchbar: _angular_core.Signal<IonSearchbar>;
    ngOnInit(): void;
    ionViewDidEnter(): void;
    private loadActiveCategories;
    private mapIntoSuggestions;
    search(toSearch?: string, scrollToNextPage?: HTMLIonInfiniteScrollElement): void;
    setFilterCategoryN(whichCategory: number): Promise<void>;
    resetFilterCategoryN(whichCategory: number): void;
    getNumChecked(): number;
    checkAll(check: boolean): void;
    cancel(): void;
    confirm(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IDEAChecksComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IDEAChecksComponent, "idea-checks", never, { "data": { "alias": "data"; "required": false; }; "sortData": { "alias": "sortData"; "required": false; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; }; "noElementsFoundText": { "alias": "noElementsFoundText"; "required": false; }; "showAvatars": { "alias": "showAvatars"; "required": false; }; "limitSelectionToNum": { "alias": "limitSelectionToNum"; "required": false; }; "allowSelectDeselectAll": { "alias": "allowSelectDeselectAll"; "required": false; }; "category1": { "alias": "category1"; "required": false; }; "category2": { "alias": "category2"; "required": false; }; "showCategoriesFilters": { "alias": "showCategoriesFilters"; "required": false; }; "previewTextKey": { "alias": "previewTextKey"; "required": false; }; }, {}, never, never, true, never>;
}

declare class IDEACheckerComponent {
    private _modal;
    private _translate;
    /**
     * The checks to show.
     */
    readonly data: _angular_core.ModelSignal<Check[]>;
    /**
     * @deprecated Alternative to the case above; function that returns a Promise<Array<Check>>.
     */
    readonly dataProvider: _angular_core.InputSignal<any>;
    /**
     * The label for the field.
     */
    label: string;
    /**
     * The icon for the field.
     */
    icon: string;
    /**
     * The color of the icon.
     */
    readonly iconColor: _angular_core.InputSignal<string>;
    /**
     * A placeholder for the searchbar.
     */
    readonly searchPlaceholder: _angular_core.InputSignal<string>;
    /**
     * If true, show the string instead of the preview text.
     */
    readonly noPreviewText: _angular_core.InputSignal<string>;
    /**
     * The text to show in case no element is found after a search.
     */
    readonly noElementsFoundText: _angular_core.InputSignal<string>;
    /**
     * If true, no elements selected equals all the elements selected.
     */
    readonly noneEqualsAll: _angular_core.InputSignal<boolean>;
    /**
     * If no element is selected, set this custom text.
     */
    readonly noneText: _angular_core.InputSignal<string>;
    /**
     * If all the elements are selected, set this custom text.
     */
    readonly allText: _angular_core.InputSignal<string>;
    /**
     * The translation key to get the preview text; it has a `num` variable available.
     */
    readonly previewTextKey: _angular_core.InputSignal<string>;
    /**
     * Lines preferences for the item.
     */
    readonly lines: _angular_core.InputSignal<string>;
    /**
     * The color for the component.
     */
    readonly color: _angular_core.InputSignal<string>;
    /**
     * If true, the component is disabled.
     */
    disabled: boolean;
    /**
     * If true, the field has a tappable effect when disabled.
     */
    readonly tappableWhenDisabled: _angular_core.InputSignal<boolean>;
    /**
     * If true, the obligatory dot is shown.
     */
    readonly obligatory: _angular_core.InputSignal<boolean>;
    /**
     * If true, sort alphabetically the data.
     */
    readonly sortData: _angular_core.InputSignal<boolean>;
    /**
     * How many elements to show in the preview before to generalize on the number.
     */
    readonly numMaxElementsInPreview: _angular_core.InputSignal<number>;
    /**
     * Whether to show an avatar aside each element.
     */
    readonly showAvatars: _angular_core.InputSignal<boolean>;
    /**
     * Limit the number of selectable elements to the value provided.
     * Note: if this attribute is active, `allowSelectDeselectAll` will be ignored.
     */
    readonly limitSelectionToNum: _angular_core.InputSignal<number>;
    /**
     * Whether to allow the select/deselect-all buttons.
     */
    readonly allowSelectDeselectAll: _angular_core.InputSignal<boolean>;
    /**
     * A pre-filter for the category1.
     */
    readonly category1: _angular_core.InputSignal<string>;
    /**
     * A pre-filter for the category2.
     */
    readonly category2: _angular_core.InputSignal<string>;
    /**
     * Whether tho show the categories filters.
     */
    readonly showCategoriesFilters: _angular_core.InputSignal<boolean>;
    /**
     * On change event.
     */
    readonly change: _angular_core.OutputEmitterRef<void>;
    /**
     * Icon select.
     */
    readonly iconSelect: _angular_core.OutputEmitterRef<void>;
    isOpening: _angular_core.WritableSignal<boolean>;
    fetchDataAndOpenModal(): Promise<void>;
    private openChecker;
    getPreview(): string;
    doIconSelect(event: any): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IDEACheckerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IDEACheckerComponent, "idea-checker", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; "dataProvider": { "alias": "dataProvider"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "iconColor": { "alias": "iconColor"; "required": false; "isSignal": true; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; "isSignal": true; }; "noPreviewText": { "alias": "noPreviewText"; "required": false; "isSignal": true; }; "noElementsFoundText": { "alias": "noElementsFoundText"; "required": false; "isSignal": true; }; "noneEqualsAll": { "alias": "noneEqualsAll"; "required": false; "isSignal": true; }; "noneText": { "alias": "noneText"; "required": false; "isSignal": true; }; "allText": { "alias": "allText"; "required": false; "isSignal": true; }; "previewTextKey": { "alias": "previewTextKey"; "required": false; "isSignal": true; }; "lines": { "alias": "lines"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; }; "tappableWhenDisabled": { "alias": "tappableWhenDisabled"; "required": false; "isSignal": true; }; "obligatory": { "alias": "obligatory"; "required": false; "isSignal": true; }; "sortData": { "alias": "sortData"; "required": false; "isSignal": true; }; "numMaxElementsInPreview": { "alias": "numMaxElementsInPreview"; "required": false; "isSignal": true; }; "showAvatars": { "alias": "showAvatars"; "required": false; "isSignal": true; }; "limitSelectionToNum": { "alias": "limitSelectionToNum"; "required": false; "isSignal": true; }; "allowSelectDeselectAll": { "alias": "allowSelectDeselectAll"; "required": false; "isSignal": true; }; "category1": { "alias": "category1"; "required": false; "isSignal": true; }; "category2": { "alias": "category2"; "required": false; "isSignal": true; }; "showCategoriesFilters": { "alias": "showCategoriesFilters"; "required": false; "isSignal": true; }; }, { "data": "dataChange"; "change": "change"; "iconSelect": "iconSelect"; }, never, never, true, never>;
}

declare class IDEAChipCheckerComponent {
    private _popover;
    private _modal;
    private _translate;
    /**
     * The checks to show.
     */
    readonly data: _angular_core.InputSignal<Check[]>;
    /**
     * The label for the field.
     */
    readonly label: _angular_core.InputSignal<string>;
    /**
     * The icon for the field.
     */
    icon: string;
    /**
     * The color of the icon.
     */
    readonly iconColor: _angular_core.InputSignal<string>;
    /**
     * A placeholder for the searchbar.
     */
    readonly searchPlaceholder: _angular_core.InputSignal<string>;
    /**
     * If true, show the string instead of the preview text.
     */
    readonly noPreviewText: _angular_core.InputSignal<string>;
    /**
     * The text to show in case no element is found after a search.
     */
    readonly noElementsFoundText: _angular_core.InputSignal<string>;
    /**
     * If true, no elements selected equals all the elements selected.
     */
    readonly noneEqualsAll: _angular_core.InputSignal<boolean>;
    /**
     * If no element is selected, set this custom text.
     */
    readonly noneText: _angular_core.InputSignal<string>;
    /**
     * If all the elements are selected, set this custom text.
     */
    readonly allText: _angular_core.InputSignal<string>;
    /**
     * The translation key to get the preview text; it has a `num` variable available.
     */
    readonly previewTextKey: _angular_core.InputSignal<string>;
    /**
     * The color for the component.
     */
    readonly color: _angular_core.InputSignal<string>;
    /**
     * The color for the inactive component.
     */
    readonly inactiveColor: _angular_core.InputSignal<string>;
    /**
     * If true, the component is disabled.
     */
    readonly disabled: _angular_core.InputSignal<boolean>;
    /**
     * If true, sort alphabetically the data.
     */
    readonly sortData: _angular_core.InputSignal<boolean>;
    /**
     * Whether to always show the `value`, even when the `name` is set.
     */
    readonly alwaysShowValue: _angular_core.InputSignal<boolean>;
    /**
     * How many elements to show in the preview before to generalize on the number.
     */
    readonly numMaxElementsInPreview: _angular_core.InputSignal<number>;
    /**
     * Limit the number of selectable elements to the value provided.
     */
    readonly limitSelectionToNum: _angular_core.InputSignal<number>;
    /**
     * Whether to allow the select/deselect-all buttons.
     */
    readonly allowSelectDeselectAll: _angular_core.InputSignal<boolean>;
    /**
     * Whether to show the reset button.
     */
    readonly resetButton: _angular_core.InputSignal<boolean>;
    /**
     * Whether to show the check list as a popover.
     * If false, we show a centered modal.
     */
    readonly showAsPopover: _angular_core.InputSignal<boolean>;
    /**
     * On change event.
     */
    readonly change: _angular_core.OutputEmitterRef<string[]>;
    isOpening: _angular_core.WritableSignal<boolean>;
    openChecker(event: Event): Promise<void>;
    getPreview(): string;
    private allChecked;
    someChecked(): boolean;
    resetChecks(event: Event): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IDEAChipCheckerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IDEAChipCheckerComponent, "idea-chip-checker", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; }; "iconColor": { "alias": "iconColor"; "required": false; "isSignal": true; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; "isSignal": true; }; "noPreviewText": { "alias": "noPreviewText"; "required": false; "isSignal": true; }; "noElementsFoundText": { "alias": "noElementsFoundText"; "required": false; "isSignal": true; }; "noneEqualsAll": { "alias": "noneEqualsAll"; "required": false; "isSignal": true; }; "noneText": { "alias": "noneText"; "required": false; "isSignal": true; }; "allText": { "alias": "allText"; "required": false; "isSignal": true; }; "previewTextKey": { "alias": "previewTextKey"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "inactiveColor": { "alias": "inactiveColor"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "sortData": { "alias": "sortData"; "required": false; "isSignal": true; }; "alwaysShowValue": { "alias": "alwaysShowValue"; "required": false; "isSignal": true; }; "numMaxElementsInPreview": { "alias": "numMaxElementsInPreview"; "required": false; "isSignal": true; }; "limitSelectionToNum": { "alias": "limitSelectionToNum"; "required": false; "isSignal": true; }; "allowSelectDeselectAll": { "alias": "allowSelectDeselectAll"; "required": false; "isSignal": true; }; "resetButton": { "alias": "resetButton"; "required": false; "isSignal": true; }; "showAsPopover": { "alias": "showAsPopover"; "required": false; "isSignal": true; }; }, { "change": "change"; }, never, never, true, never>;
}

declare class IDEAInlineCheckerComponent {
    private _popover;
    private _translate;
    /**
     * The options to show and sort.
     */
    readonly data: _angular_core.InputSignal<Check[]>;
    /**
     * The label for the component.
     */
    readonly label: _angular_core.InputSignal<string>;
    /**
     * The label placement.
     */
    readonly labelPlacement: _angular_core.InputSignal<string>;
    /**
     * The placeholder for the component.
     */
    readonly placeholder: _angular_core.InputSignal<string>;
    /**
     * A placeholder for the searchbar.
     */
    readonly searchPlaceholder: _angular_core.InputSignal<string>;
    /**
     * The text to show in case no element is found after a search.
     */
    readonly noElementsFoundText: _angular_core.InputSignal<string>;
    /**
     * The lines of the component.
     */
    readonly lines: _angular_core.InputSignal<string>;
    /**
     * The color of the component.
     */
    readonly color: _angular_core.InputSignal<string>;
    /**
     * Whether the component is disabled.
     */
    readonly disabled: _angular_core.InputSignal<boolean>;
    /**
     * Whether the checklist is reorderable or not.
     */
    readonly reorder: _angular_core.InputSignal<boolean>;
    /**
     * If true, sort the checklist alphabetically.
     */
    readonly sortData: _angular_core.InputSignal<boolean>;
    /**
     * How many elements to show in the preview before to generalize on the number.
     */
    readonly numMaxElementsInPreview: _angular_core.InputSignal<number>;
    /**
     * The translation key to get the preview text; it has a `num` variable available.
     */
    readonly previewTextKey: _angular_core.InputSignal<string>;
    /**
     * Limit the number of selectable elements to the value provided.
     * If this number is forced to `1`, the component turns into a single selection.
     */
    readonly limitSelectionToNum: _angular_core.InputSignal<number>;
    /**
     * If true, render the child component centered in the screen and show a header with a searchbar.
     */
    readonly withSearchbar: _angular_core.InputSignal<boolean>;
    /**
     * On change event.
     */
    readonly change: _angular_core.OutputEmitterRef<void>;
    isOpening: _angular_core.WritableSignal<boolean>;
    openChecker(theEvent: Event): Promise<void>;
    getPreview(): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IDEAInlineCheckerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IDEAInlineCheckerComponent, "idea-inline-checker", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "labelPlacement": { "alias": "labelPlacement"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; "isSignal": true; }; "noElementsFoundText": { "alias": "noElementsFoundText"; "required": false; "isSignal": true; }; "lines": { "alias": "lines"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "reorder": { "alias": "reorder"; "required": false; "isSignal": true; }; "sortData": { "alias": "sortData"; "required": false; "isSignal": true; }; "numMaxElementsInPreview": { "alias": "numMaxElementsInPreview"; "required": false; "isSignal": true; }; "previewTextKey": { "alias": "previewTextKey"; "required": false; "isSignal": true; }; "limitSelectionToNum": { "alias": "limitSelectionToNum"; "required": false; "isSignal": true; }; "withSearchbar": { "alias": "withSearchbar"; "required": false; "isSignal": true; }; }, { "change": "change"; }, never, never, true, never>;
}

/**
 * Translations service.
 */
declare class IDEATranslationsService {
    protected _env: any;
    private _appRef;
    /**
     * Base folder containing the translations.
     */
    protected basePath: string;
    /**
     * The modules for which to load the translations.
     */
    protected modulesPath: string[];
    /**
     * Template matcher to interpolate complex strings (e.g. `{{user}}`).
     */
    private templateMatcher;
    /**
     * The available languages.
     */
    private langs;
    /**
     * The current language.
     */
    private currentLang;
    /**
     * The fallback language.
     */
    private defaultLang;
    /**
     * The translations.
     */
    private translations;
    /**
     * Some default interpolation parameters to add to istant translations.
     */
    private defaultInterpolations;
    /**
     * To subscribe to language changes.
     */
    onLangChange: EventEmitter<string>;
    constructor();
    /**
     * Initialize the service.
     */
    init(languages?: string[], defaultLang?: string): Promise<void>;
    /**
     * Set the available languages.
     */
    setLangs(langs: string[]): void;
    /**
     * Returns an array of currently available languages.
     */
    getLangs(): string[];
    /**
     * Get the fallback language.
     */
    getDefaultLang(): string;
    /**
     * Sets the default language to use as a fallback.
     */
    setDefaultLang(lang: string): void;
    /**
     * Get the languages in IdeaX format.
     */
    languages(): Languages;
    /**
     * Returns the language code name from the browser, e.g. "it"
     */
    getBrowserLang(): string;
    /**
     * The lang currently used.
     */
    getCurrentLang(): string;
    /**
     * Set a language to use.
     */
    use(lang: string, force?: boolean): Promise<void>;
    /**
     * Set some parameters to automatically provide to translation actions.
     */
    setDefaultInterpolations(defaultParams: Record<string, string>): void;
    /**
     * Get a translated term by key in the current language, optionally interpolating variables (e.g. `{{user}}`).
     * If the term doesn't exist in the current language, it is searched in the default language.
     */
    instant(key: string, interpolateParams?: any): string;
    /**
     * Get a translated term by key in the selected language, optionally interpolating variables (e.g. `{{user}}`).
     * If the term doesn't exist in the current language, it is searched in the default language.
     */
    instantInLanguage(language: string, key: string, interpolateParams?: any): string;
    /**
     * Shortcut to instant.
     */
    _(key: string, interpolateParams?: any): string;
    /**
     * Translate (instant) and transform an expected markdown string into HTML.
     */
    _md(key: string, interpolateParams?: any): string;
    /**
     * Return a Label containing all the available translations of a key.
     */
    getLabelByKey(key: string, interpolateParams?: any): Label;
    /**
     * Return the translation in the current language of a label.
     */
    translateLabel(label: Label): string;
    /**
     * Shortcut to translateLabel.
     */
    _label(label: Label): string;
    /**
     * Load the translations from the files.
     */
    private loadTranlations;
    /**
     * Load a file into the translations.
     */
    private loadTranslationFileHelper;
    /**
     * Interpolates a string to replace parameters.
     * "This is a {{ key }}" ==> "This is a value", with params = { key: "value" }
     */
    private interpolate;
    /**
     * Gets a value from an object by composed key.
     * getValue({ key1: { keyA: 'valueI' }}, 'key1.keyA') ==> 'valueI'
     */
    private getValue;
    /**
     * Helper to quicly check if the value is defined.
     */
    private isDefined;
    /**
     * Format a date in the current locale (optionally forcing a timeZone).
     */
    formatDate(value: any, pattern?: string, timeZone?: string): string;
    /**
     * Get a readable string to represent the current language (standard ISO639).
     */
    getLanguageNameByKey(lang?: string): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IDEATranslationsService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<IDEATranslationsService>;
}

declare class IDEACustomBlockComponent {
    private _alert;
    _translate: IDEATranslationsService;
    /**
     * The custom sections to manage.
     */
    readonly sections: _angular_core.InputSignal<any>;
    /**
     * The CustomBlockMeta that describe the custom sections.
     */
    readonly blockMeta: _angular_core.InputSignal<CustomBlockMeta>;
    /**
     * Whether the component is enabled or not.
     */
    readonly disabled: _angular_core.InputSignal<boolean>;
    /**
     * Lines preferences for the component.
     */
    readonly lines: _angular_core.InputSignal<string>;
    /**
     * Whether to hide the descriptions (buttons).
     */
    readonly hideDescriptions: _angular_core.InputSignal<boolean>;
    /**
     * Show errors as reported from the parent component.
     */
    readonly errors: _angular_core.InputSignal<Set<string>>;
    /**
     * Add a custom prefix to the error string identifier.
     */
    readonly errorPrefix: _angular_core.InputSignal<string>;
    CFT: typeof CustomFieldTypes;
    hasFieldAnError(field: string): boolean;
    hasDescription(sectionKey: string, fieldKey: string): boolean;
    openDescription(sectionKey: string, fieldKey: string, event: any): Promise<void>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IDEACustomBlockComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IDEACustomBlockComponent, "idea-custom-block", never, { "sections": { "alias": "sections"; "required": false; "isSignal": true; }; "blockMeta": { "alias": "blockMeta"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "lines": { "alias": "lines"; "required": false; "isSignal": true; }; "hideDescriptions": { "alias": "hideDescriptions"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "errorPrefix": { "alias": "errorPrefix"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class IDEACustomBlockMetaComponent {
    private _modal;
    private _alert;
    private _message;
    private _translate;
    /**
     * The CustomBlockMeta to manage.
     */
    readonly block: _angular_core.InputSignal<CustomBlockMeta>;
    /**
     * Whether the custom sections should manage the display template or it should be hidden.
     */
    readonly useDisplayTemplate: _angular_core.InputSignal<boolean>;
    /**
     * Whether the component is enabled or not.
     */
    readonly disabled: _angular_core.InputSignal<boolean>;
    /**
     * Lines preferences for the component.
     */
    readonly lines: _angular_core.InputSignal<string>;
    reorderSectionsLegend(ev: any): void;
    openSection(s: string): Promise<void>;
    removeSection(s: string, ev: any): Promise<void>;
    addNewSection(): Promise<void>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IDEACustomBlockMetaComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IDEACustomBlockMetaComponent, "idea-custom-block-meta", never, { "block": { "alias": "block"; "required": false; "isSignal": true; }; "useDisplayTemplate": { "alias": "useDisplayTemplate"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "lines": { "alias": "lines"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class IDEACustomFieldMetaComponent implements OnInit {
    private _alert;
    private _modal;
    private _message;
    _translate: IDEATranslationsService;
    /**
     * The CustomFieldMeta to manage.
     */
    field?: CustomFieldMeta;
    /**
     * Whether the component is enabled or not.
     */
    disabled: boolean;
    /**
     * Lines preferences for the component.
     */
    lines?: string;
    _field: _angular_core.WritableSignal<CustomFieldMeta>;
    errors: Set<string>;
    FIELD_TYPES: string[];
    CFT: typeof CustomFieldTypes;
    ngOnInit(): void;
    hasFieldAnError(field: string): boolean;
    editLabel(title: string, label: Label): Promise<void>;
    editIcon(): Promise<void>;
    reorderOptions(ev: any): void;
    removeOptionByIndex(index: number): Promise<void>;
    addOption(): Promise<void>;
    editEnumLabel(theEnum: string): void;
    save(): Promise<void>;
    close(somethingChanged?: boolean): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IDEACustomFieldMetaComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IDEACustomFieldMetaComponent, "idea-custom-field-meta", never, { "field": { "alias": "field"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "lines": { "alias": "lines"; "required": false; }; }, {}, never, never, true, never>;
}

declare class IDEACustomSectionComponent {
    private _alert;
    _translate: IDEATranslationsService;
    /**
     * The custom fields to manage.
     */
    readonly fields: _angular_core.InputSignal<any>;
    /**
     * The CustomSectionMeta that describe the custom fields.
     */
    readonly sectionMeta: _angular_core.InputSignal<CustomSectionMeta>;
    /**
     * Whether the component is enabled or not.
     */
    readonly disabled: _angular_core.InputSignal<boolean>;
    /**
     * Lines preferences for the component.
     */
    readonly lines: _angular_core.InputSignal<string>;
    /**
     * Whether to hide the descriptions (buttons).
     */
    readonly hideDescriptions: _angular_core.InputSignal<boolean>;
    /**
     * Show errors as reported from the parent component.
     */
    readonly errors: _angular_core.InputSignal<Set<string>>;
    /**
     * Add a custom prefix to the error string identifier.
     */
    readonly errorPrefix: _angular_core.InputSignal<string>;
    CFT: typeof CustomFieldTypes;
    hasFieldAnError(field: string): boolean;
    openDescription(fieldKey: string, event: any): Promise<void>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IDEACustomSectionComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IDEACustomSectionComponent, "idea-custom-section", never, { "fields": { "alias": "fields"; "required": false; "isSignal": true; }; "sectionMeta": { "alias": "sectionMeta"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "lines": { "alias": "lines"; "required": false; "isSignal": true; }; "hideDescriptions": { "alias": "hideDescriptions"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "errorPrefix": { "alias": "errorPrefix"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class IDEACustomSectionMetaComponent implements OnInit {
    private _modal;
    private _alert;
    private _message;
    private _translate;
    /**
     * The CustomSectionMeta to manage.
     */
    section?: CustomSectionMeta;
    /**
     * Whether to hide the headers of the section (in case we just want to display/manage the fields).
     */
    hideHeaders: boolean;
    /**
     * Whether the CustomSectionMeta should manage the display template or it should be hidden.
     */
    useDisplayTemplate: boolean;
    /**
     * Whether the compoent is enabled or not.
     */
    disabled: boolean;
    /**
     * Lines preferences for the component.
     */
    lines?: string;
    _section: _angular_core.WritableSignal<CustomSectionMeta>;
    errors: Set<string>;
    DISPLAY_TEMPLATE_MAX_NUM_FIELD_PER_ROW: number;
    ngOnInit(): void;
    hasFieldAnError(field: string): boolean;
    editName(): Promise<void>;
    editDescription(): Promise<void>;
    private editLabel;
    reorderFieldsLegend(ev: any): void;
    openField(f: string): Promise<void>;
    removeField(f: string, ev: any): Promise<void>;
    addNewField(): Promise<void>;
    reorderDisplayTemplateRows(ev: any): void;
    isDisplayTemplateRowFull(row: number): boolean;
    addNewDisplayTemplateRow(): void;
    addFieldToDisplayTemplateRow(row: number): Promise<void>;
    removeFieldToDisplayTemplateRow(row: number, field: string): void;
    private cleanEmptyDisplayTemplateRows;
    save(): Promise<void>;
    close(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IDEACustomSectionMetaComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IDEACustomSectionMetaComponent, "idea-custom-section-meta", never, { "section": { "alias": "section"; "required": false; }; "hideHeaders": { "alias": "hideHeaders"; "required": false; }; "useDisplayTemplate": { "alias": "useDisplayTemplate"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "lines": { "alias": "lines"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * Configurator of EmailData.
 */
declare class IDEAEmailDataComponent implements OnInit {
    private _modal;
    /**
     * The email data to manage.
     */
    readonly emailData: _angular_core.InputSignal<EmailData>;
    /**
     * The variables the user can use for subject and content.
     */
    readonly variables: _angular_core.InputSignal<StringVariable[]>;
    /**
     * The label for the field.
     */
    readonly label: _angular_core.InputSignal<string>;
    /**
     * The icon for the field.
     */
    readonly icon: _angular_core.InputSignal<string>;
    /**
     * The color of the icon.
     */
    readonly iconColor: _angular_core.InputSignal<string>;
    /**
     * A placeholder for the field.
     */
    readonly placeholder: _angular_core.InputSignal<string>;
    /**
     * Lines preferences for the item.
     */
    readonly lines: _angular_core.InputSignal<string>;
    /**
     * The color for the component.
     */
    readonly color: _angular_core.InputSignal<string>;
    /**
     * If true, the component is disabled.
     */
    readonly disabled: _angular_core.InputSignal<boolean>;
    /**
     * On change event.
     */
    readonly change: _angular_core.OutputEmitterRef<void>;
    /**
     * Icon select.
     */
    readonly iconSelect: _angular_core.OutputEmitterRef<void>;
    /**
     * The list of variables codes to use for substitutions.
     */
    variablesPlain: string[];
    isOpening: _angular_core.WritableSignal<boolean>;
    ngOnInit(): void;
    openEmailDataConfiguration(): Promise<void>;
    doIconSelect(event: any): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IDEAEmailDataComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IDEAEmailDataComponent, "idea-email-data", never, { "emailData": { "alias": "emailData"; "required": false; "isSignal": true; }; "variables": { "alias": "variables"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconColor": { "alias": "iconColor"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "lines": { "alias": "lines"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "change": "change"; "iconSelect": "iconSelect"; }, never, never, true, never>;
}

declare class IDEAEmailDataConfigurationComponent implements OnInit {
    private _modal;
    /**
     * The emailData to configure.
     */
    emailData?: EmailData;
    /**
     * The variables the user can use for subject and content.
     */
    variables?: StringVariable[];
    /**
     * The title for the component.
     */
    title?: string;
    /**
     * Lines preferences for the item.
     */
    lines?: string;
    /**
     * If true, the component is disabled.
     */
    disabled?: boolean;
    emailDataWC: EmailData;
    variablesPlain: string[];
    ngOnInit(): void;
    mdToHtml(content: string): string;
    save(): void;
    close(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IDEAEmailDataConfigurationComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IDEAEmailDataConfigurationComponent, "idea-email-data-configuration", never, { "emailData": { "alias": "emailData"; "required": false; }; "variables": { "alias": "variables"; "required": false; }; "title": { "alias": "title"; "required": false; }; "lines": { "alias": "lines"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
}

declare class IDEASendEmailComponent implements OnInit {
    private _modal;
    private _translate;
    /**
     * The content and receivers of the email.
     */
    readonly email: _angular_core.InputSignal<EmailData>;
    /**
     * Visual indicators of the attachments that will be sent.
     */
    readonly attachments: _angular_core.InputSignal<string[]>;
    /**
     * The variables the user can use for subject and content.
     */
    variables: StringVariable[];
    /**
     * A map of the values to substitute to the variables.
     */
    values: {
        [variable: string]: string | number;
    };
    /**
     * The suggested contacts for the email composer.
     */
    readonly contacts: _angular_core.InputSignal<Suggestion[]>;
    /**
     * Lines preferences for the items.
     */
    readonly lines: _angular_core.InputSignal<string>;
    /**
     * Whether we want to prevent the user to change the addresses pre-set.
     */
    readonly disableChangeOfAddresses: _angular_core.InputSignal<boolean>;
    emailWC: _angular_core.WritableSignal<EmailData>;
    ngOnInit(): void;
    addAddressToList(list: string[]): Promise<void>;
    removeAddressFromList(list: string[], address: string): void;
    canSend(): boolean;
    send(): void;
    close(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IDEASendEmailComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IDEASendEmailComponent, "idea-send-email", never, { "email": { "alias": "email"; "required": false; "isSignal": true; }; "attachments": { "alias": "attachments"; "required": false; "isSignal": true; }; "variables": { "alias": "variables"; "required": false; }; "values": { "alias": "values"; "required": false; }; "contacts": { "alias": "contacts"; "required": false; "isSignal": true; }; "lines": { "alias": "lines"; "required": false; "isSignal": true; }; "disableChangeOfAddresses": { "alias": "disableChangeOfAddresses"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class IDEAIconsComponent implements OnInit {
    private _modal;
    /**
     * A placeholder for the searchbar.
     */
    readonly searchPlaceholder: _angular_core.InputSignal<string>;
    icons: Ionicons[];
    /**
     * Which icons to show, based on the current search. Note: this method is used instead of the usual, because the
     * icons take a lot to redraw (so it's better to just hide them when not needed).
     */
    shouldShowIcon: {
        [icon: string]: boolean;
    };
    ngOnInit(): void;
    search(toSearch?: string): void;
    select(selection: Ionicons): void;
    close(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IDEAIconsComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IDEAIconsComponent, "idea-icons", never, { "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Manage the content of a Label.
 */
declare class IDEALabelComponent implements OnInit {
    private _modal;
    private _translate;
    /**
     * The label to manage.
     * Note: the name is set to not overlap with IDEA's components typical use of the attribute `label`.
     */
    readonly content: _angular_core.InputSignal<Label>;
    /**
     * The languages preferences; if not set, it fallbacks to IDEATranslationsService's ones.
     */
    languages: Languages;
    /**
     * Whether to display the label in textareas instead of text fields.
     */
    readonly textarea: _angular_core.InputSignal<boolean>;
    /**
     * Whether the label supports markdown.
     */
    readonly markdown: _angular_core.InputSignal<boolean>;
    /**
     * The variables the user can use in the label.
     */
    readonly variables: _angular_core.InputSignal<StringVariable[]>;
    /**
     * The title (label) for the field.
     */
    label: string;
    /**
     * The icon for the field.
     */
    icon: string;
    /**
     * The color of the icon.
     */
    readonly iconColor: _angular_core.InputSignal<string>;
    /**
     * A placeholder for the field.
     */
    readonly placeholder: _angular_core.InputSignal<string>;
    /**
     * Lines preferences for the item.
     */
    readonly lines: _angular_core.InputSignal<string>;
    /**
     * The color for the component.
     */
    readonly color: _angular_core.InputSignal<string>;
    /**
     * If true, the component is disabled.
     */
    readonly disabled: _angular_core.InputSignal<boolean>;
    /**
     * If true, the label is validated on save.
     */
    readonly obligatory: _angular_core.InputSignal<boolean>;
    readonly change: _angular_core.OutputEmitterRef<void>;
    readonly iconSelect: _angular_core.OutputEmitterRef<void>;
    variableCodes: string[];
    htmlContent: _angular_core.WritableSignal<string>;
    isOpening: _angular_core.WritableSignal<boolean>;
    ngOnInit(): void;
    edit(): Promise<void>;
    private calcHTMLContent;
    doIconSelect(event: any): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IDEALabelComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IDEALabelComponent, "idea-label", never, { "content": { "alias": "content"; "required": false; "isSignal": true; }; "languages": { "alias": "languages"; "required": false; }; "textarea": { "alias": "textarea"; "required": false; "isSignal": true; }; "markdown": { "alias": "markdown"; "required": false; "isSignal": true; }; "variables": { "alias": "variables"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "iconColor": { "alias": "iconColor"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "lines": { "alias": "lines"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "obligatory": { "alias": "obligatory"; "required": false; "isSignal": true; }; }, { "change": "change"; "iconSelect": "iconSelect"; }, never, never, true, never>;
}

/**
 * A component for filling in an Label.
 */
declare class IDEALabelerComponent implements OnInit {
    private _platform;
    private _modal;
    private _message;
    private _translate;
    /**
     * The detail to highlight.
     */
    label?: Label;
    /**
     * The languages preferences; if not set, it fallbacks to IDEATranslationsService's ones.
     */
    languages: Languages;
    /**
     * The optional title for the component.
     */
    title: string;
    /**
     * Whether to display the label in textareas instead of text fields.
     */
    textarea?: boolean;
    /**
     * Whether the label supports markdown.
     */
    markdown?: boolean;
    /**
     * The variables the user can use for the label content.
     */
    variables: (StringVariable | LabelVariable)[];
    /**
     * If true, the component is disabled.
     */
    disabled?: boolean;
    /**
     * If true, the label is validated on save.
     */
    obligatory?: boolean;
    _label: Label;
    errors: Set<string>;
    ngOnInit(): void;
    hasFieldAnError(field: string): boolean;
    getFlagURL(lang: string): string;
    getVariableDescription(v: StringVariable | LabelVariable): string;
    save(): Promise<void>;
    close(): void;
    isLargeScreen(): boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IDEALabelerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IDEALabelerComponent, "idea-labeler", never, { "label": { "alias": "label"; "required": false; }; "languages": { "alias": "languages"; "required": false; }; "title": { "alias": "title"; "required": false; }; "textarea": { "alias": "textarea"; "required": false; }; "markdown": { "alias": "markdown"; "required": false; }; "variables": { "alias": "variables"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "obligatory": { "alias": "obligatory"; "required": false; }; }, {}, never, never, true, never>;
}

declare class IDEAListComponent {
    private _modal;
    private _translate;
    /**
     * The list to manage.
     */
    readonly data: _angular_core.InputSignal<(string | Label)[]>;
    /**
     * Whether the elements are labels or simple strings.
     */
    readonly labelElements: _angular_core.InputSignal<boolean>;
    /**
     * The label for the field.
     */
    readonly label: _angular_core.InputSignal<string>;
    /**
     * The icon for the field.
     */
    readonly icon: _angular_core.InputSignal<string>;
    /**
     * The color of the icon.
     */
    readonly iconColor: _angular_core.InputSignal<string>;
    /**
     * A placeholder for the searchbar.
     */
    readonly searchPlaceholder: _angular_core.InputSignal<string>;
    /**
     * Text to show when there isn't a result.
     */
    readonly noElementsFoundText: _angular_core.InputSignal<string>;
    /**
     * If true, show the string instead of the preview text.
     */
    readonly noPreviewText: _angular_core.InputSignal<string>;
    /**
     * A placeholder for the field.
     */
    readonly placeholder: _angular_core.InputSignal<string>;
    /**
     * Lines preferences for the item.
     */
    readonly lines: _angular_core.InputSignal<string>;
    /**
     * The color for the component.
     */
    readonly color: _angular_core.InputSignal<string>;
    /**
     * If true, the component is disabled.
     */
    readonly disabled: _angular_core.InputSignal<boolean>;
    /**
     * If true, the obligatory dot is shown.
     */
    readonly obligatory: _angular_core.InputSignal<boolean>;
    /**
     * How many elements to show in the preview before to generalize on the number.
     */
    readonly numMaxElementsInPreview: _angular_core.InputSignal<number>;
    /**
     * On change event.
     */
    readonly change: _angular_core.OutputEmitterRef<void>;
    /**
     * Icon select.
     */
    readonly iconSelect: _angular_core.OutputEmitterRef<void>;
    isOpening: _angular_core.WritableSignal<boolean>;
    openList(): Promise<void>;
    getPreview(): string;
    getElementName(x: Label | string): any;
    doIconSelect(event: any): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IDEAListComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IDEAListComponent, "idea-list", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; "labelElements": { "alias": "labelElements"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconColor": { "alias": "iconColor"; "required": false; "isSignal": true; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; "isSignal": true; }; "noElementsFoundText": { "alias": "noElementsFoundText"; "required": false; "isSignal": true; }; "noPreviewText": { "alias": "noPreviewText"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "lines": { "alias": "lines"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "obligatory": { "alias": "obligatory"; "required": false; "isSignal": true; }; "numMaxElementsInPreview": { "alias": "numMaxElementsInPreview"; "required": false; "isSignal": true; }; }, { "change": "change"; "iconSelect": "iconSelect"; }, never, never, true, never>;
}

declare class IDEAListElementsComponent implements OnInit {
    private _modal;
    private _alert;
    private _translate;
    /**
     * It should be read only until the component closure.
     */
    data?: (Label | string)[];
    /**
     * Whether the elements are labels or simple strings.
     */
    labelElements?: boolean;
    /**
     * A placeholder for the searchbar.
     */
    searchPlaceholder?: string;
    /**
     * The text to show in case no element is found after a search.
     */
    noElementsFoundText?: string;
    workingData: (Label | string)[];
    filteredList: _angular_core.WritableSignal<(string | Label)[]>;
    currentPage: number;
    readonly searchbar: _angular_core.Signal<IonSearchbar>;
    ngOnInit(): void;
    getElementName(x: Label | string): any;
    search(toSearch?: string, scrollToNextPage?: HTMLIonInfiniteScrollElement): void;
    addElement(): void;
    editElement(element: Label | string): void;
    removeElement(element: Label | string): void;
    addStrElement(): Promise<void>;
    editLabel(label: Label): Promise<void>;
    close(save?: boolean): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IDEAListElementsComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IDEAListElementsComponent, "idea-list-elements", never, { "data": { "alias": "data"; "required": false; }; "labelElements": { "alias": "labelElements"; "required": false; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; }; "noElementsFoundText": { "alias": "noElementsFoundText"; "required": false; }; }, {}, never, never, true, never>;
}

declare class IDEAPDFTemplateComponent implements OnInit {
    private _popover;
    private _modal;
    private _alert;
    private _actions;
    private _message;
    private _translate;
    /**
     * The blueprint to define the allowed sections and fields for this PDF template.
     */
    readonly blueprint: _angular_core.InputSignal<PDFTemplateBlueprint>;
    /**
     * The PDF template to manage, as list of sections.
     */
    readonly template: _angular_core.InputSignal<PDFTemplateSection[]>;
    /**
     * Language preferences.
     */
    readonly languages: _angular_core.InputSignal<Languages>;
    /**
     * If true, the component is disabled.
     */
    disabled: boolean;
    /**
     * The working copy of the PDF template to manage, to avoid touching the original until changes are saved.
     */
    _template: PDFTemplateSection[];
    /**
     * A stack of inner layers of the main template, to navigate and modify the inner sections, following a path.
     */
    stack: PDFTemplateLayer[];
    ST: typeof PDFTemplateSectionTypes;
    editSections: boolean;
    moveMode: MoveModeData;
    errors: Set<string>;
    ngOnInit(): void;
    getCurrentLayer(): PDFTemplateLayer;
    getCurrentTemplate(): PDFTemplateSection[];
    getCurrentVariables(): string[];
    openInnerSection(section: PDFTemplateSection): void;
    getBreadcrumb(): string[];
    isInnerLayer(): boolean;
    prevLayer(howMany?: number): void;
    addSection(): Promise<void>;
    private addSectionHelper;
    deleteSection(section: PDFTemplateSection): Promise<void>;
    moveSectionUpInTemplate(section: PDFTemplateSection): void;
    moveSectionDownInTemplate(section: PDFTemplateSection): void;
    private moveSectionInTemplateByNumPositions;
    getInnerSectionIcon(section: PDFTemplateSection): string;
    editHeaderLabel(label: Label): Promise<void>;
    editSectionTitleLabel(label: Label): Promise<void>;
    addField(section: PDFTemplateSection, indexCol: number): Promise<void>;
    private addSimpleField;
    private addComplexField;
    private pickVariableFromList;
    isColumnComplex(field: string | PDFTemplateSimpleField | PDFTemplateComplexField): boolean;
    displayField(section: PDFTemplateSection, colIndex: number, forceLabel?: boolean): string;
    manageField(section: PDFTemplateSection, colIndex: number, event?: any): Promise<void>;
    private openField;
    private moveField;
    private canFieldMoveAnywhere;
    completeMove(newSection: PDFTemplateSection, newColIndex: number): void;
    private resizeField;
    private deleteField;
    isViewLocked(): boolean;
    hasFieldAnError(field: string): boolean;
    private checkErrorsOnCurrentLayer;
    save(): Promise<void>;
    close(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IDEAPDFTemplateComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IDEAPDFTemplateComponent, "idea-pdf-template", never, { "blueprint": { "alias": "blueprint"; "required": false; "isSignal": true; }; "template": { "alias": "template"; "required": false; "isSignal": true; }; "languages": { "alias": "languages"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
}
/**
 * It represents the layer (inner level) of a template.
 */
interface PDFTemplateLayer {
    /**
     * The blueprint that the define the layer.
     */
    blueprint: PDFTemplateBlueprint | PDFTemplateSectionBlueprint;
    /**
     * The actual template, based on the blueprint.
     */
    template: PDFTemplateSection[];
    /**
     * The title of the level, in case of INNER_SECTION or REPEATED_INNER_SECTION.
     */
    title?: Label;
}
/**
 * Helper structure to move a field to another position.
 */
interface MoveModeData {
    /**
     * The section (ROW) containing the field to move.
     */
    section: PDFTemplateSection;
    /**
     * The position of the field in the columns (index).
     */
    colIndex: number;
}
/**
 * Helper component to resize a field in the template.
 */
declare class IDEAPDFTemplateFieldResizeComponent {
    /**
     * The columns of the section containing the field.
     */
    columns?: string[];
    /**
     * The current position of the field.
     */
    colIndex?: number;
    /**
     * The current size of the field.
     */
    size?: number;
    /**
     * The max size to which the field can grow.
     */
    max?: number;
    grow(): void;
    growToMax(): void;
    shrink(): void;
    shrinkToMin(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IDEAPDFTemplateFieldResizeComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IDEAPDFTemplateFieldResizeComponent, "idea-pdf-template-field-resize", never, { "columns": { "alias": "columns"; "required": false; }; "colIndex": { "alias": "colIndex"; "required": false; }; "size": { "alias": "size"; "required": false; }; "max": { "alias": "max"; "required": false; }; }, {}, never, never, true, never>;
}

declare class IDEASelectComponent implements OnChanges {
    private _modal;
    /**
     * The description to show in the field.
     * Set the property so it detects changes.
     */
    protected _description: _angular_core.WritableSignal<string>;
    get description(): string;
    set description(description: string);
    /**
     * The suggestions to show.
     */
    data: Suggestion[];
    /**
     * @deprecated Alternative to the case above; function that returns a Promise<Array<Suggestion>>.
     */
    readonly dataProvider: _angular_core.InputSignal<any>;
    /**
     * The label for the field.
     */
    label: string;
    /**
     * The icon for the field.
     */
    icon: string;
    /**
     * The color of the icon.
     */
    readonly iconColor: _angular_core.InputSignal<string>;
    /**
     * A placeholder for the field.
     */
    readonly placeholder: _angular_core.InputSignal<string>;
    /**
     * A placeholder for the searchbar.
     */
    readonly searchPlaceholder: _angular_core.InputSignal<string>;
    /**
     * Text to show when there isn't a result.
     */
    readonly noElementsFoundText: _angular_core.InputSignal<string>;
    /**
     * If true, the component is disabled.
     */
    disabled: boolean;
    /**
     * If true, the field has a tappable effect when disabled.
     */
    readonly tappableWhenDisabled: _angular_core.InputSignal<boolean>;
    /**
     * If true, the obligatory dot is shown.
     */
    readonly obligatory: _angular_core.InputSignal<boolean>;
    /**
     * Lines preferences for the item.
     */
    readonly lines: _angular_core.InputSignal<string>;
    /**
     * The color for the component.
     */
    readonly color: _angular_core.InputSignal<string>;
    /**
     * If true, allows to select a new custom value (outside the suggestions).
     */
    readonly allowUnlistedValues: _angular_core.InputSignal<boolean>;
    /**
     * If `allowUnlistedValues` is set, show this to help users understanding what happens by selecting the unlisted val.
     */
    readonly allowUnlistedValuesPrefix: _angular_core.InputSignal<string>;
    /**
     * If true, sort the suggestions alphabetically.
     */
    readonly sortData: _angular_core.InputSignal<boolean>;
    /**
     * If true, clear the value of the field after a selection.
     */
    readonly clearValueAfterSelection: _angular_core.InputSignal<boolean>;
    /**
     * If true, doesn't show the id in the UI.
     */
    readonly hideIdFromUI: _angular_core.InputSignal<boolean>;
    /**
     * If true, doesn't show the clear button in the header.
     */
    readonly hideClearButton: _angular_core.InputSignal<boolean>;
    /**
     * If true, the user doesn't have the option to cancel the selection: an option must be chosen.
     */
    readonly mustChoose: _angular_core.InputSignal<boolean>;
    /**
     * A pre-filter for the category1.
     */
    readonly category1: _angular_core.InputSignal<string>;
    /**
     * A pre-filter for the category2.
     */
    readonly category2: _angular_core.InputSignal<string>;
    /**
     * Whether tho show the categories filters in the suggestions component.
     */
    readonly showCategoriesFilters: _angular_core.InputSignal<boolean>;
    /**
     * If true, doesn't let the auto-selection in case there's only one element as possible selection.
     */
    readonly avoidAutoSelection: _angular_core.InputSignal<boolean>;
    /**
     * On select event.
     */
    readonly select: _angular_core.OutputEmitterRef<Suggestion>;
    /**
     * Icon select.
     */
    readonly iconSelect: _angular_core.OutputEmitterRef<void>;
    /**
     * On select (with the field disabled) event.
     */
    readonly selectWhenDisabled: _angular_core.OutputEmitterRef<void>;
    isOpening: _angular_core.WritableSignal<boolean>;
    ngOnChanges(changes: SimpleChanges): void;
    fetchDataAndOpenModal(): Promise<void>;
    private convertDataInSuggestions;
    private openSuggestions;
    doSelectWhenDisabled(): void;
    doIconSelect(event: any): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IDEASelectComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IDEASelectComponent, "idea-select", never, { "description": { "alias": "description"; "required": false; }; "data": { "alias": "data"; "required": false; }; "dataProvider": { "alias": "dataProvider"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "iconColor": { "alias": "iconColor"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; "isSignal": true; }; "noElementsFoundText": { "alias": "noElementsFoundText"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; }; "tappableWhenDisabled": { "alias": "tappableWhenDisabled"; "required": false; "isSignal": true; }; "obligatory": { "alias": "obligatory"; "required": false; "isSignal": true; }; "lines": { "alias": "lines"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "allowUnlistedValues": { "alias": "allowUnlistedValues"; "required": false; "isSignal": true; }; "allowUnlistedValuesPrefix": { "alias": "allowUnlistedValuesPrefix"; "required": false; "isSignal": true; }; "sortData": { "alias": "sortData"; "required": false; "isSignal": true; }; "clearValueAfterSelection": { "alias": "clearValueAfterSelection"; "required": false; "isSignal": true; }; "hideIdFromUI": { "alias": "hideIdFromUI"; "required": false; "isSignal": true; }; "hideClearButton": { "alias": "hideClearButton"; "required": false; "isSignal": true; }; "mustChoose": { "alias": "mustChoose"; "required": false; "isSignal": true; }; "category1": { "alias": "category1"; "required": false; "isSignal": true; }; "category2": { "alias": "category2"; "required": false; "isSignal": true; }; "showCategoriesFilters": { "alias": "showCategoriesFilters"; "required": false; "isSignal": true; }; "avoidAutoSelection": { "alias": "avoidAutoSelection"; "required": false; "isSignal": true; }; }, { "select": "select"; "iconSelect": "iconSelect"; "selectWhenDisabled": "selectWhenDisabled"; }, never, never, true, never>;
}

declare class IDEASuggestionsComponent implements OnInit {
    private _platform;
    private _modal;
    private _storage;
    /**
     * The suggestions to show.
     */
    data: Suggestion[];
    /**
     * If true, sort the suggestions alphabetically.
     */
    sortData?: boolean;
    /**
     * A placeholder for the searchbar.
     */
    searchPlaceholder?: string;
    /**
     * Text to show when there isn't a result.
     */
    noElementsFoundText?: string;
    /**
     * If true, allows to select a new custom value (outside the suggestions).
     */
    allowUnlistedValues?: boolean;
    /**
     * If `allowUnlistedValues` is set, show this to help users understanding what happens by selecting the unlisted val.
     */
    allowUnlistedValuesPrefix?: string;
    /**
     * If true, doesn't show the id in the UI.
     */
    hideIdFromUI?: boolean;
    /**
     * If true, doesn't show the clear button in the header.
     */
    hideClearButton?: boolean;
    /**
     * If true, the user doesn't have the option to cancel the selection: an option must be chosen.
     */
    mustChoose?: boolean;
    /**
     * A pre-filter for the category1.
     */
    category1?: string;
    /**
     * A pre-filter for the category2.
     */
    category2?: string;
    /**
     * Whether tho show the categories filters.
     */
    showCategoriesFilters?: boolean;
    /**
     * An arbitrary number of elements to show in each page; suggested: a multiple of 2, 3 and 4 (good for any UI size).
     */
    numPerPage?: number;
    suggestions: _angular_core.WritableSignal<Suggestion[]>;
    currentPage: number;
    activeCategories1: _angular_core.WritableSignal<Set<string>>;
    activeCategories2: _angular_core.WritableSignal<Set<string>>;
    readonly searchbar: _angular_core.Signal<IonSearchbar>;
    shouldShowDetails: _angular_core.WritableSignal<boolean>;
    detailsAreAvailable: _angular_core.WritableSignal<boolean>;
    ngOnInit(): Promise<void>;
    ionViewDidEnter(): void;
    private loadActiveCategories;
    private mapIntoSuggestions;
    search(toSearch?: string, scrollToNextPage?: HTMLIonInfiniteScrollElement): void;
    setFilterCategoryN(whichCategory: number): Promise<void>;
    resetFilterCategoryN(whichCategory: number): void;
    /**
     * Close the component propagating the choice:
     *    - selection === undefined -> cancel
     *    - selection === null -> clear
     *    - otherwise, a suggestion was selected
     */
    select(selection?: Suggestion | any): void;
    navigateComponent(event: KeyboardEvent): void;
    toggleDetailsVisibilityPreference(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IDEASuggestionsComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IDEASuggestionsComponent, "idea-suggestions", never, { "data": { "alias": "data"; "required": false; }; "sortData": { "alias": "sortData"; "required": false; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; }; "noElementsFoundText": { "alias": "noElementsFoundText"; "required": false; }; "allowUnlistedValues": { "alias": "allowUnlistedValues"; "required": false; }; "allowUnlistedValuesPrefix": { "alias": "allowUnlistedValuesPrefix"; "required": false; }; "hideIdFromUI": { "alias": "hideIdFromUI"; "required": false; }; "hideClearButton": { "alias": "hideClearButton"; "required": false; }; "mustChoose": { "alias": "mustChoose"; "required": false; }; "category1": { "alias": "category1"; "required": false; }; "category2": { "alias": "category2"; "required": false; }; "showCategoriesFilters": { "alias": "showCategoriesFilters"; "required": false; }; "numPerPage": { "alias": "numPerPage"; "required": false; }; }, {}, never, never, true, never>;
}

declare class IDEAShowHintButtonComponent {
    private _alert;
    private _translate;
    /**
     * The string to show as title of the alert.
     */
    readonly hint: _angular_core.InputSignal<string>;
    /**
     * The string to show as content of the alert.
     * If not specified, it's equal to `hint.concat('_I')`.
     */
    readonly message: _angular_core.InputSignal<string>;
    /**
     * The string to show as the alert's confirmation button.
     */
    readonly confirmationText: _angular_core.InputSignal<string>;
    /**
     * Whether the input strings need to be translated or they are already.
     */
    _shouldTranslate: boolean;
    get translate(): boolean | string;
    set translate(input: boolean | string);
    /**
     * A CSS class to apply to the alert box.
     */
    readonly cssClass: _angular_core.InputSignal<string>;
    /**
     * The slots where to put the button.
     */
    readonly slot: _angular_core.InputSignal<string>;
    /**
     * The fill attribute of the button.
     */
    readonly fill: _angular_core.InputSignal<string>;
    /**
     * The color of the button.
     */
    readonly color: _angular_core.InputSignal<string>;
    /**
     * The IonIcon to show for the button.
     */
    readonly icon: _angular_core.InputSignal<string>;
    showHint(event?: any): Promise<void>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IDEAShowHintButtonComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IDEAShowHintButtonComponent, "idea-show-hint-button", never, { "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; "confirmationText": { "alias": "confirmationText"; "required": false; "isSignal": true; }; "translate": { "alias": "translate"; "required": false; }; "cssClass": { "alias": "cssClass"; "required": false; "isSignal": true; }; "slot": { "alias": "slot"; "required": false; "isSignal": true; }; "fill": { "alias": "fill"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class IDEASignatureComponent {
    private _modal;
    private _message;
    private _translate;
    /**
     * An existing signature to use.
     */
    readonly existingSignature: _angular_core.InputSignal<Signature>;
    /**
     * Whether it is possible or not to edit an existing signature.
     */
    readonly preventEditing: _angular_core.InputSignal<boolean>;
    /**
     * A list of contacts that could be the signatory of this signature.
     */
    readonly contacts: _angular_core.InputSignal<string[]>;
    signature: _angular_core.WritableSignal<Signature>;
    canvas: HTMLCanvasElement | null;
    pad: SignaturePad | null;
    signatoryError: boolean;
    signatureError: boolean;
    ionViewDidEnter(): void;
    canEdit(): boolean;
    pickSignatory(): Promise<void>;
    setSignatory(signatory: string): void;
    clear(): void;
    save(): Promise<void>;
    undo(): void;
    close(): void;
    resizeCanvas(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IDEASignatureComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IDEASignatureComponent, "idea-signature", never, { "existingSignature": { "alias": "existingSignature"; "required": false; "isSignal": true; }; "preventEditing": { "alias": "preventEditing"; "required": false; "isSignal": true; }; "contacts": { "alias": "contacts"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class IDEATooltipComponent {
    /**
     * The tooltip title.
     */
    readonly title: _angular_core.InputSignal<string>;
    /**
     * The tooltip text.
     */
    readonly text: _angular_core.InputSignal<string>;
    /**
     * The tooltip link.
     */
    readonly link: _angular_core.InputSignal<string>;
    /**
     * The tooltip close event.
     */
    readonly closed: _angular_core.OutputEmitterRef<void>;
    onTooltipMouseLeave(): void;
    onClose(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IDEATooltipComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IDEATooltipComponent, "app-tooltip", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; "link": { "alias": "link"; "required": false; "isSignal": true; }; }, { "closed": "closed"; }, never, never, true, never>;
}

declare class IDEATooltipDirective implements OnDestroy {
    private _injector;
    private _elementRef;
    private _viewContainerRef;
    private _translate;
    /**
     * The key in the translations for the tooltip.
     * From this keys we also get the link ("_L") and title ("_T"), if any.
     */
    readonly hint: _angular_core.InputSignal<string>;
    /**
     * The delay before showing the tooltip.
     */
    readonly tooltipDelay: _angular_core.InputSignal<number>;
    private tooltipRef;
    private showTimeout;
    onMouseOver(): void;
    onMouseOut(): void;
    private showTooltip;
    private createTooltip;
    private clearTooltip;
    private hideTooltip;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IDEATooltipDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<IDEATooltipDirective, "[tooltip]", never, { "hint": { "alias": "tooltip"; "required": false; "isSignal": true; }; "tooltipDelay": { "alias": "tooltipDelay"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Handle dates with the locale loaded from IDEA's translation service.
 */
declare class IDEALocalizedDatePipe implements PipeTransform {
    private _translate;
    /**
     * Pipe function to format the date in the correct locale (optionally forcing a timeZone).
     */
    transform(value: any, pattern?: string, timeZone?: string): any;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IDEALocalizedDatePipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<IDEALocalizedDatePipe, "dateLocale", true>;
}

/**
 * Handle labels with the languages loaded from IDEA's translation service.
 */
declare class IDEALocalizedLabelPipe implements PipeTransform {
    private _translate;
    transform(label: any): any;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IDEALocalizedLabelPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<IDEALocalizedLabelPipe, "label", true>;
}

declare class IDEALanguagePickerComponent implements OnInit {
    private _translate;
    /**
     * Button fill preference.
     */
    readonly fill: _angular_core.InputSignal<string>;
    languages: {
        value: string;
        name: string;
    }[];
    ngOnInit(): void;
    getFlagURL(languageCode?: string): string;
    pickLanguage(languageCode: string, popover: IonPopover): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IDEALanguagePickerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IDEALanguagePickerComponent, "idea-language-picker", never, { "fill": { "alias": "fill"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class IDEATranslatePipe implements PipeTransform, OnDestroy {
    private _translate;
    private _ref;
    /**
     * The value to display.
     */
    private value;
    /**
     * The last key requested.
     */
    private lastKey;
    /**
     * The last params requested.
     */
    private lastParams;
    /**
     * Subscription to the (current) language changes.
     */
    private onLangChange;
    updateValue(key: string, interpolateParams?: any): void;
    transform(query: string, ...args: any[]): any;
    private _dispose;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IDEATranslatePipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<IDEATranslatePipe, "translate", true>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<IDEATranslatePipe>;
}
/**
 * Determines if two objects or two values are equivalent.
 *
 * Two objects or values are considered equivalent if at least one of the following is true:
 *
 * * Both objects or values pass `===` comparison.
 * * Both objects or values are of the same type and all of their properties are equal by
 *   comparing them with `equals`.
 *
 * @param o1 Object or value to compare.
 * @param o2 Object or value to compare.
 * @returns true if arguments are equal.
 */
declare function equals(o1: any, o2: any): boolean;

/**
 * @deprecated use standalone imports instead
 * TODO to remove in future releases
 */
declare class IDEATranslationsModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IDEATranslationsModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<IDEATranslationsModule, never, [typeof IDEATranslatePipe, typeof IDEALocalizedDatePipe, typeof IDEALocalizedLabelPipe, typeof IDEALanguagePickerComponent], [typeof IDEATranslatePipe, typeof IDEALocalizedDatePipe, typeof IDEALocalizedLabelPipe, typeof IDEALanguagePickerComponent]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<IDEATranslationsModule>;
}

declare class IDEAUserAvatarComponent implements OnInit {
    /**
     * The link to the avatar media to show.
     */
    src?: string;
    /**
     * The full name of the user (to use as fallback in case the media isn't available).
     */
    readonly name: _angular_core.InputSignal<string>;
    /**
     * The size of the avatar.
     */
    readonly size: _angular_core.InputSignal<"small" | "default" | "mini" | "large" | "extraLarge">;
    /**
     * The HEX color of the avatar's background.
     */
    color?: string;
    initials: string;
    fontColor: string;
    borderColor: string;
    ngOnInit(): void;
    private setInitialsFromName;
    fallbackToInitials(): void;
    setFontColorBasedOnBackground(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IDEAUserAvatarComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IDEAUserAvatarComponent, "idea-user-avatar", never, { "src": { "alias": "src"; "required": false; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * The change-detection "bridge".
 *
 * WHAT IT IS
 *   A best-effort helper that forces change detection on the currently visible Ionic page after
 *   library async work that, by itself, does NOT trigger Angular change detection.
 *
 * THE PROBLEM IT SOLVES
 *   On Angular 22, Ionic's `StackController` detaches a page/overlay from the root change-detection
 *   tree, so `ApplicationRef.tick()` never reaches its view (verified empirically). A page/overlay is
 *   then only rendered when its OWN view is marked dirty — by a template event or a signal. So any
 *   state assigned to it from a non-template context stays unrendered until the next user interaction:
 *     - a native `fetch` (IDEAApiService, IDEAAttachmentsService S3 upload, IDEAAppStatusService,
 *       IDEATranslationsService) resolves OUTSIDE the Angular zone — no tick at all on a Zone app;
 *     - **data read from a CACHE / storage / any non-fetch async** (e.g. a service `getList()` that
 *       returns an already-loaded list, a `Promise.resolve`, a `setTimeout`) — even when a Zone tick
 *       DOES fire, it cannot reach the detached view, so the page/overlay still stays stale;
 *     - an Ionic overlay dismiss callback runs outside the template event flow;
 *     - a WebSocket message arrives from the native/socket layer.
 *   On a ZONELESS app the same holds for an even wider set (only a signal / markForCheck / DOM event
 *   schedules CD). The classic symptom: a page/modal stays on its skeletons — or a chained form does
 *   not advance — until you touch a control (whose event finally ticks the view).
 *
 *   Because the gap is the DETACHED VIEW, not the data source, the bridge is wired to two kinds of
 *   trigger: (a) the moment a view ENTERS / an overlay PRESENTS — which catches state populated around
 *   open time regardless of source (fetch, cache, storage); and (b) the late async events (fetch
 *   finally / websocket / overlay dismiss) — which catch data that lands well after open.
 *
 * WHAT IT DOES
 *   Finds the visible Ionic page(s) in the DOM and runs a LOCAL `detectChanges()` on each page's own
 *   component view (which a global tick can't reach). It ALSO refreshes the content of open Ionic
 *   popovers (whose projected component is NOT wrapped in an `.ion-page`, so the page selector misses
 *   it) — this covers an overlay that loads its own data via a native-fetch service in `ngOnInit`.
 *   Modals are already covered by the page pass: Ionic wraps modal content in an `.ion-page`.
 *   This makes the library render correctly on BOTH Zone and zoneless consumer apps WITHOUT any fix
 *   code in the apps themselves.
 *
 * WHAT IT DOES NOT (and structurally cannot) COVER
 *   The bridge runs a correct `detectChanges()` on a visible page/overlay view; it cannot cross two
 *   boundaries that are normal OnPush semantics, so these still need app-side care:
 *     - an object/array MUTATED IN PLACE and passed as `@Input` to an OnPush CHILD — the child is
 *       legitimately skipped because its input reference is unchanged (`Object.is`); rebuild the
 *       reference instead;
 *     - external/third-party mutable state read DIRECTLY in a template (e.g. a Swiper's `activeIndex`)
 *       — there is no view state to detect a change on; capture it into a field on the event.
 *   These bite a fully-migrated zoneless app identically; they are not bridge gaps.
 *
 * WHO CALLS IT (the bridge surface)
 *   - the global enter/present/dismiss Ionic listeners installed lazily below: `ionViewDidEnter` (a
 *     page entered), `didPresent` (an overlay opened), `didDismiss` (an overlay closed). These cover
 *     state populated around navigation/open time from ANY source, cache included;
 *   - the 4 native-fetch services, in a `finally`: api.service / attachments.service /
 *     appStatus.service / translations.service (for data that lands well after open);
 *   - webSocketApi.service, after each `onMessage` (opt out per connection with `refreshOnMessage:false`).
 *
 * IF / WHEN IT CAN BE REMOVED
 *   This is a TRANSITIONAL bridge for consumer apps whose page state is not (yet) signal-based. The
 *   library's OWN components are signal-based and do not depend on it. It becomes dead weight — and can
 *   be deleted — once EVERY consumer app is zoneless + signals, i.e. every template-read page state is
 *   a signal that self-renders. Removal = delete this file, the `refreshVisibleIonicPages()` calls in
 *   the 4 services + webSocketApi, and the `didDismiss` listener. (Keep it as long as any consumer is
 *   Zone-based, or has non-signal page state populated by an async library call.)
 *
 * IMPLEMENTATION NOTE
 *   Uses the published-but-internal `ɵViewRef`/`ɵgetLContext` plus numeric LView indexes (stable under
 *   minification). This couples the bridge to the Angular major the library targets — acceptable for an
 *   internal library, and it is the only way to reach a detached Ionic page view from outside it.
 */

/**
 * Force change detection on the currently visible Ionic page(s). See the file header for the why.
 * Best-effort: never throws.
 */
declare function refreshVisibleIonicPages(): void;
/**
 * The change-detection PUMP — the complete, source-agnostic form of the bridge for ZONE consumers.
 *
 * Angular 20 rendered every Ionic page because the zone, on going stable after each async turn, ran
 * `ApplicationRef.tick()`, which reached every attached view. Angular 22 still goes stable after each
 * turn, but `tick()` no longer reaches the views Ionic's `StackController` detaches — so ANY state
 * assigned off the template-event path (a cached read, a fetch, a dynamic `import()`, a chained await)
 * stays unrendered until the next interaction. This is independent of the component's strategy: it bites
 * a plain CheckAlways page just as much as an OnPush one, and a simple page just as much as a complex one.
 *
 * The pump restores the old behavior: on `NgZone.onStable` — the SAME moment Angular 20 ticked — it runs
 * the bridge's LOCAL `detectChanges()` (which DOES reach detached views). Net effect: Angular 22 + Zone
 * renders like Angular 20 + Zone, for data from ANY source, on EVERY page, with no per-page work. Because
 * it is global and uniform, page complexity is irrelevant — Shifts/Planning/Sequencer are covered by the
 * same restoration as a trivial list, not case by case.
 *
 * Cost equals the CheckAlways these apps already run: one local CD of the visible page(s) per async turn,
 * coalesced to a single pass per animation frame, executed outside the Angular zone so it can never loop.
 * It is a NO-OP on a zoneless app (`onStable` does not fire there — zoneless consumers render via signals),
 * so it is dual-mode safe.
 */
declare function startIonicCDPump(zone: NgZone): void;
/**
 * Starts the change-detection pump. Add ONE line to a Zone-based app's bootstrap providers:
 *   bootstrapApplication(AppComponent, { providers: [ ..., provideIDEAChangeDetectionBridge() ] });
 * Uniform across every project, no signals knowledge required, and a harmless no-op on a zoneless app.
 */
declare function provideIDEAChangeDetectionBridge(): EnvironmentProviders;

/**
 * Bolds the beggining of the matching string in the item.
 */
declare class IDEABoldPrefix implements PipeTransform {
    transform(value: string, keyword: string): any;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IDEABoldPrefix, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<IDEABoldPrefix, "boldprefix", true>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<IDEABoldPrefix>;
}

/**
 * Higlighted variables.
 */
declare class IDEAHiglightedVariablesPipe implements PipeTransform {
    transform(value: string, variables: string[]): any;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IDEAHiglightedVariablesPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<IDEAHiglightedVariablesPipe, "highlight", true>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<IDEAHiglightedVariablesPipe>;
}

/**
 * Checks a string for URLs and if so, makes them clickable and returns the sanitized html.
 */
declare class IDEALinkifyPipe implements PipeTransform {
    private _sanitizer;
    transform(text: string): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IDEALinkifyPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<IDEALinkifyPipe, "linkify", true>;
}

declare class IDEALoadingService {
    private _loading;
    private _translate;
    private _router;
    private loadingElement;
    constructor();
    /**
     * Show a loading animation.
     * @param content loading message
     */
    show(content?: string): Promise<void>;
    /**
     * Change the content of the loading animation, while it's already on.
     * @param content new loading message
     */
    setContent(content: string): void;
    /**
     * Hide the loading animation.
     */
    hide(): Promise<boolean>;
    /**
     * Force-hide the loading animation when the page changes, to avoid leaving pending (infinite) loading.
     */
    private hideOnPageChange;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IDEALoadingService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<IDEALoadingService>;
}

declare class IDEAMessageService {
    private _toast;
    private _translate;
    /**
     * Show a generic message toast.
     * @param message message to show (i18n key to translate, if `dontTranslate === false`)
     * @param color among Ionic colors defined in the theme
     * @param dontTranslate whether the message is already a translated text
     * @param serverMessage some untranslatable text from the back-end, to add as detail after the message
     */
    private show;
    /**
     * Show an info message toast.
     * @param message message to show
     * @param options for translations and additional text to show
     */
    info(message: string, options?: {
        dontTranslate?: boolean;
        serverMessage?: string;
    }): Promise<void>;
    /**
     * Show a success message toast.
     * @param message message to show
     * @param options for translations and additional text to show
     */
    success(message: string, options?: {
        dontTranslate?: boolean;
        serverMessage?: string;
    }): Promise<void>;
    /**
     * Show an error message toast.
     * @param message message to show
     * @param options for translations and additional text to show
     */
    error(message: string, options?: {
        dontTranslate?: boolean;
        serverMessage?: string;
    }): Promise<void>;
    /**
     * Show a warning message toast.
     * @param message message to show
     * @param options for translations and additional text to show
     */
    warning(message: string, options?: {
        dontTranslate?: boolean;
        serverMessage?: string;
    }): Promise<void>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IDEAMessageService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<IDEAMessageService>;
}

declare class IDEAStorageService {
    private _storage;
    private theStorage;
    constructor();
    init(): Promise<void>;
    ready(): Promise<void>;
    private readyHelper;
    set(key: string, value: any): Promise<void>;
    get(key: string): Promise<any>;
    remove(key: string): Promise<void>;
    clear(): Promise<void>;
    keys(): Promise<string[]>;
    length(): Promise<number>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IDEAStorageService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<IDEAStorageService>;
}

/**
 * To communicate with an AWS API Gateway websocket istance.
 * Lighter, alternative version of _IDEAAWSAPISocketService_.
 */
declare class IDEAWebSocketApiService {
    protected _env: any;
    /**
     * The URL to connect for socket communication.
     */
    apiURL: string;
    /**
     * Passed as `Authorization` header.
     */
    authToken: string;
    /**
     * 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;
    /**
     * The current websocket connection.
     */
    protected connection: WebSocket;
    /**
     * The options with which we opened a connection, to re-open it if needed.
     */
    protected options: IDEAWebSocketApiServiceOpenOptions;
    /**
     * 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;
    constructor();
    /**
     * Open a connection to the websocket API.
     */
    open(options?: IDEAWebSocketApiServiceOpenOptions): void;
    /**
     * Close the current connection to the web socket 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: _angular_core.ɵɵFactoryDeclaration<IDEAWebSocketApiService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<IDEAWebSocketApiService>;
}
/**
 * The options to open a socket connection and handle its events.
 */
interface IDEAWebSocketApiServiceOpenOptions {
    /**
     * Optional parameters needed to be passed to the socket's authorizer to open the connection.
     */
    openParams?: {
        [key: string]: any;
    };
    /**
     * 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;
    /**
     * Whether to refresh the visible Ionic page after each message so the `onMessage` state renders on
     * Zone-based and zoneless consumers without app-side change detection. Defaults to `true`; set to
     * `false` for high-frequency streams where you handle rendering yourself (e.g. via signals).
     */
    refreshOnMessage?: boolean;
    /**
     * Action to execute when an error occurs.
     */
    onError?: (event: any) => void;
    /**
     * Whether to show debug messages.
     */
    debug?: boolean;
}

/**
 * The token to inject the app configurations in the module.
 */
declare const IDEAEnvironment: InjectionToken<any>;
/**
 * The environment variables used by IDEA Ionic Extra's modules.
 */
interface IDEAEnvironmentConfiguration {
    idea: {
        project: string;
        ionicExtraModules: string[];
        app?: {
            version: string;
            bundle: string;
            appleStoreURL?: string;
            googleStoreURL?: string;
            maxFileUploadSizeMB?: number;
            statusFileURL?: string;
        };
        api?: {
            url: string;
            stage?: string;
        };
        ideaApi?: {
            url: string;
            stage?: string;
        };
        socket?: {
            url: string;
            stage?: string;
        };
        auth?: {
            title?: string;
            website?: string;
            hasIntroPage?: boolean;
            registrationIsPossible: boolean;
            singleSimultaneousSession: boolean;
            forceLoginWithMFA: boolean;
            passwordPolicy?: {
                minLength: number;
                requireLowercase: boolean;
                requireDigits: boolean;
                requireSymbols: boolean;
                requireUppercase: boolean;
                advancedPasswordCheck?: boolean;
            };
        };
    };
    aws?: {
        cognito?: {
            userPoolId: string;
            userPoolClientId: string;
            domain?: string;
            externalProviders?: {
                type: 'okta';
                name: string;
                emailDomains: string[];
            }[];
        };
    };
    google?: {
        apiClientId: string;
        apiScope: string;
    };
    microsoft?: {
        apiClientId: string;
        apiScope: string;
    };
    auth0?: {
        domain: string;
        clientId: string;
        callbackUri: string;
        storeRefreshToken: boolean;
    };
}

export { IDEAActionSheetComponent, IDEAActionSheetController, IDEAApiService, IDEAAppStatusPage, IDEAAppStatusService, IDEAAttachmentSectionsComponent, IDEAAttachmentsComponent, IDEAAttachmentsService, IDEABoldPrefix, IDEACheckerComponent, IDEAChecksComponent, IDEAChipCheckerComponent, IDEACustomBlockComponent, IDEACustomBlockMetaComponent, IDEACustomFieldMetaComponent, IDEACustomSectionComponent, IDEACustomSectionMetaComponent, IDEAEmailDataComponent, IDEAEmailDataConfigurationComponent, IDEAEnvironment, IDEAHiglightedVariablesPipe, IDEAIconsComponent, IDEAInlineCheckerComponent, IDEALabelComponent, IDEALabelerComponent, IDEALanguagePickerComponent, IDEALinkifyPipe, IDEAListComponent, IDEAListElementsComponent, IDEALoadingService, IDEALocalizedDatePipe, IDEALocalizedLabelPipe, IDEAManageAttachmentsSectionComponent, IDEAMessageService, IDEAPDFTemplateComponent, IDEAPDFTemplateFieldResizeComponent, IDEASelectComponent, IDEASendEmailComponent, IDEAShowHintButtonComponent, IDEASignatureComponent, IDEAStorageService, IDEASuggestionsComponent, IDEATooltipComponent, IDEATooltipDirective, IDEATranslatePipe, IDEATranslationsModule, IDEATranslationsService, IDEAUserAvatarComponent, IDEAWebSocketApiService, bytesToMegaBytes, equals, ideaAppStatusRoutes, provideIDEAChangeDetectionBridge, refreshVisibleIonicPages, startIonicCDPump };
export type { IDEAActionSheetOptions, IDEAEnvironmentConfiguration, IDEAWebSocketApiServiceOpenOptions, MoveModeData, PDFTemplateLayer };