@dsivd/prestations-ng 18.8.0-beta.13 → 19.0.0-beta.2

package/types/dsivd-prestations-ng.d.ts

@@ -0,0 +1,3699 @@
+import * as _angular_core from '@angular/core';
+import { OnInit, AfterViewInit, Signal, ElementRef, DestroyRef, OnDestroy, OnChanges, SimpleChanges, EnvironmentProviders, SimpleChange, PipeTransform, TemplateRef, TrackByFunction, InjectionToken, ErrorHandler, NgZone } from '@angular/core';
+import { Params, Route, ActivatedRoute, ActivatedRouteSnapshot, CanActivateFn, Router, QueryParamsHandling } from '@angular/router';
+import { Observable, Subject, BehaviorSubject } from 'rxjs';
+import { NgModel, NgForm } from '@angular/forms';
+import { Location } from '@angular/common';
+import dayjs from 'dayjs';
+import { CdkVirtualScrollViewport } from '@angular/cdk/scrolling';
+import { HttpClient, HttpEvent } from '@angular/common/http';
+import * as _fortawesome_fontawesome_common_types from '@fortawesome/fontawesome-common-types';
+import { IconDefinition } from '@fortawesome/fontawesome-common-types';
+import { ImageCroppedEvent } from 'ngx-image-cropper';
+
+declare class BreadcrumbItem {
+    url: string;
+    routerLink: string;
+    label: string;
+    skipLeavingAlert?: boolean;
+    routerLinkQueryParams?: Params;
+    urlTarget?: '_blank' | '_self' | '_parent' | '_top';
+}
+declare class Breadcrumb {
+    breadcrumbItems: BreadcrumbItem[];
+    current: BreadcrumbItem;
+}
+interface BreadcrumbConfiguration {
+    prestationCode?: string;
+    vdChUrl?: string;
+    descriptionPageBaseUrl?: string;
+    espaceSecuriseUrl?: string;
+    allPrestationsUrl?: string;
+}
+
+declare class BreadcrumbEventService {
+    private readonly sessionInfo;
+    private readonly applicationInfoService;
+    private _breadcrumbOverride;
+    private _breadcrumbConfiguration;
+    private _currentBreadcrumbItem;
+    private readonly _breadcrumbObservable;
+    private readonly _neverConnectedBreadcrumbObservable;
+    private _skipLeavingAlertBecauseDemandIsTransmitted;
+    constructor();
+    get skipLeavingAlertBecauseDemandIsTransmitted(): boolean;
+    set skipLeavingAlertBecauseDemandIsTransmitted(value: boolean);
+    /**
+     * Set the breadcrumb. This value will override any configuration injected with
+     * `setConfiguration`. Only use if you want to handle the breadcrumb manually.
+     * @param breadcrumb as Breadcrumb
+     */
+    setBreadcrumb(breadcrumb: Breadcrumb): void;
+    /**
+     * The breadcrumb value.
+     * @returns Observable<Breadcrumb>
+     */
+    breadcrumbObservable(): Observable<Breadcrumb>;
+    /**
+     * The breadcrumb value if never connected.
+     * @returns Observable<Breadcrumb>
+     */
+    neverConnectedBreadcrumbObservable(): Observable<Breadcrumb>;
+    /**
+     * Set the current item. Used for accessibility purposes.
+     * @param currentItem as BreadcrumbItem
+     */
+    setCurrentBreadcrumb(currentItem: BreadcrumbItem): void;
+    /**
+     * Set the current breadcrumb configuration.
+     *
+     * Set to `null` to disable the breadcrumb.
+     * @param configuration as BreadcrumbConfiguration
+     */
+    setConfiguration(configuration: BreadcrumbConfiguration): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BreadcrumbEventService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<BreadcrumbEventService>;
+}
+
+interface HelpModal {
+    buttonTitle?: string;
+    title: string;
+    body?: string;
+    images?: Image[];
+    modalSize?: string;
+}
+interface Image {
+    src?: string;
+    alt?: string;
+    width?: string;
+    height?: string;
+}
+
+interface FormError {
+    name: string;
+    code: string;
+    message: string;
+}
+
+/**
+ * Interface representing a component that has custom error messages.
+ * Used to break the dependency cycle between ValidationHandlerService and FoehnInputComponent.
+ */
+interface HasCustomErrors {
+    customErrors: Record<string, string> | (() => Record<string, string>);
+}
+
+declare class ValidationHandlerService {
+    private _validationErrorsSubject;
+    private _validationDisplaySubject;
+    get validationErrorsSubject(): Observable<FormError[]>;
+    get validationDisplaySubject(): Observable<boolean>;
+    updateErrors(errors: FormError[]): void;
+    shouldDisplayErrors(display: boolean): void;
+    getMessage(component: HasCustomErrors, error: FormError): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ValidationHandlerService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ValidationHandlerService>;
+}
+
+declare const GESDEM_MAX_DATA_LENGTH = 10000;
+declare abstract class FoehnInputComponent<T> implements OnInit, AfterViewInit {
+    readonly model: _angular_core.ModelSignal<T>;
+    readonly pattern: _angular_core.ModelSignal<string>;
+    readonly helpModal: _angular_core.ModelSignal<HelpModal>;
+    readonly standardHelpText: _angular_core.ModelSignal<string>;
+    readonly helpText: _angular_core.ModelSignal<string>;
+    readonly disabled: _angular_core.ModelSignal<boolean>;
+    readonly id: _angular_core.InputSignal<string>;
+    readonly name: _angular_core.InputSignal<string>;
+    readonly overrideGesdemMaxlength: _angular_core.InputSignal<boolean>;
+    readonly min: _angular_core.InputSignal<number>;
+    readonly max: _angular_core.InputSignal<number>;
+    readonly preventPaste: _angular_core.InputSignal<boolean>;
+    /**
+     * The autocapitalize attribute never causes autocapitalization to be enabled for
+     * an <input> element with a type attribute whose value is url, email, or password.
+     * https://developer.mozilla.org/fr/docs/Web/HTML/Global_attributes/autocapitalize
+     */
+    readonly autocapitalize: _angular_core.InputSignal<string>;
+    /**
+     * When set to TRUE: Allows model update to be emitted
+     */
+    readonly updateModelWhenDisabled: _angular_core.InputSignal<boolean>;
+    /**
+     * When set to TRUE: Shows error even if input is disabled
+     */
+    readonly showErrorWhenDisabled: _angular_core.InputSignal<boolean>;
+    readonly labelStyleModifier: _angular_core.InputSignal<string>;
+    readonly customErrors: _angular_core.InputSignal<Record<string, string>>;
+    /**
+     * Hide the 'facultatif' extra label.
+     */
+    readonly hideNotRequiredExtraLabel: _angular_core.InputSignal<boolean>;
+    readonly isErrorInherited: _angular_core.InputSignal<boolean>;
+    readonly hidden: _angular_core.ModelSignal<boolean>;
+    readonly maxlength: _angular_core.InputSignal<number>;
+    /**
+     * The attribute must take one of the following values:
+     * See https://developer.mozilla.org/fr/docs/Web/HTML/Attributes/autocomplete
+     */
+    readonly autocomplete: _angular_core.InputSignal<string | boolean>;
+    readonly clearButton: _angular_core.InputSignal<boolean>;
+    /**
+     * Exclude the component from the error summary if the component has an error.
+     */
+    readonly excludeFromErrorSummary: _angular_core.InputSignal<boolean>;
+    /**
+     * When TRUE, adds class 'visually-hidden' (only for screen readers) on tag <label> or <legend>
+     * depending on component extending this class
+     */
+    readonly isLabelSrOnly: _angular_core.InputSignal<boolean>;
+    readonly required: _angular_core.InputSignal<boolean>;
+    readonly label: _angular_core.InputSignal<string>;
+    readonly inputModelList: Signal<readonly NgModel[]>;
+    readonly inputElement: Signal<ElementRef<any>>;
+    readonly subComponents: Signal<readonly FoehnInputComponent<any>[]>;
+    /**
+     * Fired when the user changes a value, after the model is updated.
+     */
+    readonly userInput: _angular_core.OutputEmitterRef<T>;
+    readonly blurHandler: _angular_core.OutputEmitterRef<FocusEvent>;
+    readonly focusHandler: _angular_core.OutputEmitterRef<FocusEvent>;
+    displayClearButton: Signal<boolean>;
+    model_: T;
+    type: string;
+    readonly validationHandlerService: ValidationHandlerService;
+    /**
+     * linkedSignal est un WritableSignal dont la valeur par défaut est recalculée si les dépendances changent,
+     * mais qui peut être écrasé manuellement avec .set().
+     */
+    protected readonly hostId: _angular_core.WritableSignal<string>;
+    /**
+     * computed() — valeur dérivée
+     * Quand le résultat est une valeur qui dépend d'autres signals. C'est une transformation pure, synchrone, sans side effect.
+     */
+    protected readonly hostHidden: Signal<string>;
+    protected readonly _destroyRef: DestroyRef;
+    private readonly registerNgModelService;
+    private _errors;
+    private userInputSubject;
+    private readonly subComponentsEffect;
+    private readonly modelEffect;
+    constructor();
+    get errors(): FormError[];
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    onModelChange(value: T): void;
+    handleChange(value: T): void;
+    updateNgModel(value: T): void;
+    hasErrorsToDisplay(): boolean;
+    hasErrors(): boolean;
+    hasInheritErrorFromParent(): boolean;
+    isPristine(): boolean;
+    markAsDirty(): void;
+    markAsPristine(): void;
+    getNativeInputList(): NgModel[];
+    getMeAndSubComponents(): FoehnInputComponent<any>[];
+    refreshErrors(results: any[]): void;
+    focus(scrollIntoView?: boolean): void;
+    getMaxLength(): number;
+    buildId(suffix?: string): string;
+    buildChildId(suffix?: string): string;
+    buildChildName(suffix?: string): string;
+    onKeydown(_key: KeyboardEvent): void;
+    reset(): void;
+    onPaste(e: ClipboardEvent): void;
+    onBlur(e: FocusEvent): void;
+    onFocus(e: FocusEvent): void;
+    onClear(): void;
+    getDescribedBy(): string;
+    getAutoComplete(): string;
+    protected getFirstInputComponentEnabled(subComponents: readonly FoehnInputComponent<any>[]): FoehnInputComponent<any>;
+    protected findFirstHtmlInputElementEnabled(elementNodeListOf: NodeListOf<Element>): HTMLInputElement;
+    protected isEmpty(data: any): boolean;
+    protected isEmptyWhenTrimmedIfString(data: any): boolean;
+    protected triggerUserInput(value: T): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnInputComponent<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FoehnInputComponent<any>, never, never, { "model": { "alias": "model"; "required": false; "isSignal": true; }; "pattern": { "alias": "pattern"; "required": false; "isSignal": true; }; "helpModal": { "alias": "helpModal"; "required": false; "isSignal": true; }; "standardHelpText": { "alias": "standardHelpText"; "required": false; "isSignal": true; }; "helpText": { "alias": "helpText"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "overrideGesdemMaxlength": { "alias": "overrideGesdemMaxlength"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "preventPaste": { "alias": "preventPaste"; "required": false; "isSignal": true; }; "autocapitalize": { "alias": "autocapitalize"; "required": false; "isSignal": true; }; "updateModelWhenDisabled": { "alias": "updateModelWhenDisabled"; "required": false; "isSignal": true; }; "showErrorWhenDisabled": { "alias": "showErrorWhenDisabled"; "required": false; "isSignal": true; }; "labelStyleModifier": { "alias": "labelStyleModifier"; "required": false; "isSignal": true; }; "customErrors": { "alias": "customErrors"; "required": false; "isSignal": true; }; "hideNotRequiredExtraLabel": { "alias": "hideNotRequiredExtraLabel"; "required": false; "isSignal": true; }; "isErrorInherited": { "alias": "isErrorInherited"; "required": false; "isSignal": true; }; "hidden": { "alias": "hidden"; "required": false; "isSignal": true; }; "maxlength": { "alias": "maxlength"; "required": false; "isSignal": true; }; "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; "clearButton": { "alias": "clearButton"; "required": false; "isSignal": true; }; "excludeFromErrorSummary": { "alias": "excludeFromErrorSummary"; "required": false; "isSignal": true; }; "isLabelSrOnly": { "alias": "isLabelSrOnly"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, { "model": "modelChange"; "pattern": "patternChange"; "helpModal": "helpModalChange"; "standardHelpText": "standardHelpTextChange"; "helpText": "helpTextChange"; "disabled": "disabledChange"; "hidden": "hiddenChange"; "userInput": "userInput"; "blurHandler": "blur"; "focusHandler": "focus"; }, never, never, true, never>;
+}
+
+declare class FoehnFormComponent implements AfterViewInit {
+    readonly shouldDisplayAlertSummary: _angular_core.InputSignal<boolean>;
+    readonly ngFormComponent: _angular_core.Signal<NgForm>;
+    private readonly childrenInputComponents;
+    private registeredNgModels;
+    private readonly registerNgModelService;
+    private readonly destroyRef;
+    private readonly childrenInputComponentsEffect;
+    constructor();
+    reset(resetChildrenValues?: boolean): void;
+    ngAfterViewInit(): void;
+    updateRegisteredNgModels(): void;
+    getAllNativeModels(): NgModel[];
+    getAllComponents(): FoehnInputComponent<any>[];
+    isValid(): boolean;
+    focusFirstInError(): void;
+    focusFirst(scrollIntoView?: boolean): void;
+    focusErrorSummary(): void;
+    private registerNgModel;
+    private deleteNgModel;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnFormComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnFormComponent, "foehn-form", never, { "shouldDisplayAlertSummary": { "alias": "shouldDisplayAlertSummary"; "required": false; "isSignal": true; }; }, {}, ["childrenInputComponents"], ["*"], true, never>;
+}
+
+declare class GrowlMessage {
+    type: string;
+    content: string;
+    isCloseable: boolean;
+    isVisible: boolean;
+    timeToDisplayInSeconds: number;
+}
+
+declare class GrowlBrokerService {
+    private _messageAddedSubject;
+    get messageAddedSubject(): Observable<GrowlMessage>;
+    addMessage(message: GrowlMessage): void;
+    addWithType(type: string, content: string): void;
+    addWithTypeAndTimeToDisplayInSeconds(type: string, content: string, timeToDisplayInSeconds: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GrowlBrokerService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<GrowlBrokerService>;
+}
+
+declare enum NavigationDirection {
+    FORWARD = 1,
+    BACKWARD = -1
+}
+declare class FoehnNavigationService {
+    currentRouteOrder: number;
+    orderedRoutes: Route[];
+    private router;
+    private gesdemService;
+    private gesdemActionRecoveryService;
+    private route;
+    private location;
+    private demandeTransmitInterceptor;
+    private eventsLoggerService;
+    private _activatedRoute;
+    private isInit;
+    private initializedAndRouteActivated;
+    private linearRouting;
+    get initialized(): boolean;
+    set activatedRoute(value: ActivatedRoute);
+    static getRootRouteRecursive(route: ActivatedRouteSnapshot): Route;
+    initRoute(route: Route): void;
+    throwIfNotInit(): void;
+    updateRouteInformations(): void;
+    getFirstRoute(): Route;
+    current(): Promise<boolean>;
+    hasBeenInitialized(): Observable<boolean>;
+    getQueryParamsToForwardAsString(): string;
+    getQueryParamsToForward(): Params;
+    next(): Promise<boolean>;
+    previous(): Promise<boolean>;
+    last(): Promise<boolean>;
+    recap(): Promise<boolean>;
+    redirect(newPath: string): Promise<boolean>;
+    getAvailableRoutes(): Route[];
+    getCurrentRouteIndex(): number;
+    getTotalRoutesSize(): number;
+    getLastRouteOrder(): number;
+    getNextAvailableRoute(direction: NavigationDirection): Route;
+    isFirstFormPage(): boolean;
+    isForcedOnRecapForPendingPayment(): boolean;
+    isLastFormPage(): boolean;
+    getNextRouteIndex(): number;
+    getPreviousRouteIndex(): number;
+    isLinearRouting(): boolean;
+    private getCurrentRoute;
+    private redirectToAvailableRoute;
+    private isRouteAvailable;
+    private evaluateGuard;
+    /**
+     * reindexe les routes par "order"
+     * @param applicationRoute as route
+     * @returns Route[]
+     */
+    private indexRoutesByOrder;
+    private flattenRoutes;
+    private setFocusOnPageTitle;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnNavigationService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<FoehnNavigationService>;
+}
+
+declare class RepriseInfo {
+    mobile: string;
+    email: string;
+    referenceInterne?: string;
+    lastUpdate?: number[];
+}
+
+declare class I18nForm {
+    language: string;
+    acceptDecisionElectronique: boolean;
+    referenceInterne: string;
+}
+
+declare class FormMetadata {
+    reference: string;
+    currentAction: number;
+    referenceInterne: string;
+    critical: boolean;
+    initialisationDateTime: string;
+    transfertDateTime: string;
+    modificationDateTime: string;
+    draftDemandeDeletionDate: number[];
+    draftDemRetentionDays: number;
+    statut: string;
+    infoReprise: RepriseInfo;
+}
+declare class FormPostResponse<T extends I18nForm> {
+    form: T;
+    errors: FormError[];
+    meta: FormMetadata;
+}
+
+declare class FoehnPageService {
+    private _foehnPageSubject;
+    private _saveFormRequestSubject;
+    private _currentEtapeId;
+    private readonly _appVersionMismatch;
+    private currentEtapeIdObs;
+    constructor();
+    foehnPageObservable(): Observable<string>;
+    setAppVersionMismatch(): void;
+    onAppVersionMismatch(): Observable<boolean>;
+    setPageTitle(title: string): void;
+    requestFormSave(displaySuccessMessage?: boolean): void;
+    saveFormRequest(): Observable<boolean>;
+    setCurrentEtapeId(etapeId: string): void;
+    onEtapeIdChange(): Observable<string>;
+    isUserCategoryVisible(isFirstPage: boolean, isLastPage: boolean, isUserCategoryEnabled: boolean, isInitialStep: boolean, isUserNeverConnected: boolean, backendResponse: FormPostResponse<any>, isCurrentRouteDefined: boolean): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnPageService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<FoehnPageService>;
+}
+
+declare class GesdemEventService {
+    private _formInitializationSubject;
+    private _formTransmittedSubject;
+    private _formSentSubject;
+    get formInitializationSubject(): Subject<any>;
+    get formTransmittedSubject(): Subject<FormPostResponse<any>>;
+    get formSentSubject(): Subject<FormPostResponse<any>>;
+    formInitializationObservable(): Observable<any>;
+    formTransmittedObservable(): Observable<FormPostResponse<any>>;
+    formSentObservable(): Observable<FormPostResponse<any>>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GesdemEventService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<GesdemEventService>;
+}
+
+declare enum ActionStatut {
+    DRAFT = "DRAFT",
+    INITIAL = "INITIAL",
+    PENDING_PAYMENT = "PENDING_PAYMENT",
+    TRANSFERRED = "TRANSFERRED",
+    ABANDONED = "ABANDONED",
+    REOPENED = "REOPENED"
+}
+declare class GesdemStatutUtils {
+    static isFinal(actionStatut: ActionStatut): boolean;
+    static isPendingPayment(actionStatut: ActionStatut): boolean;
+}
+
+declare class GesdemHandlerService {
+    _prefix: string;
+    private http;
+    private growlService;
+    private validationHandlerService;
+    private route;
+    private errorHandlerService;
+    private sessionInfo;
+    private dictionaryService;
+    private dateHelper;
+    private _updateFormDataSubject;
+    private _lastResponse;
+    private _captchaToken;
+    get lastResponse(): FormPostResponse<any>;
+    get updateFormDataSubject(): Observable<any>;
+    get prefix(): string;
+    set prefix(prefix: string);
+    isPendingPayment(): boolean;
+    save(form: any, canCreateDemande?: boolean, displaySuccessMessage?: boolean): Observable<any>;
+    pdf(form: any): Observable<any>;
+    setCaptchaToken(token: string): void;
+    getCaptchaToken(): string;
+    /**
+     *
+     * @param reference de la demande
+     * @param reCaptchaByPassUUID unique identifier
+     * @param forceRefreshIfNew allows to force the cleaning if reference is null
+     * @param byPassEmitResponse boolean used to emit or not gesdem last response (default is false)
+     * @returns Observable
+     */
+    require(reference?: string, reCaptchaByPassUUID?: string, forceRefreshIfNew?: boolean, byPassEmitResponse?: boolean): Observable<any>;
+    transmit(): Observable<any>;
+    retrieve(reference: any, reCaptchaByPassUUID: string, shouldDispatchErrors?: boolean): Observable<any>;
+    retrieveActionStatut(reference: any): Observable<ActionStatut>;
+    validate(form: any): Observable<any>;
+    private postToUrl;
+    private emitResponse;
+    private handleGesdemError;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GesdemHandlerService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<GesdemHandlerService>;
+}
+
+type PlaceholderType = Record<string, string>;
+type DictionaryType = Record<string, string>;
+interface Language {
+    code: string;
+    label: string;
+}
+
+declare const DICTIONARY_BASE_URL = "api/dictionary";
+/**
+ * @param value to search in
+ * @param placeholders to be replaced
+ * @returns string
+ */
+declare const replaceAll: (value: string, placeholders?: PlaceholderType) => string;
+declare class SdkDictionaryService {
+    private readonly httpClient;
+    private readonly growlService;
+    private readonly validationService;
+    private dictionary;
+    private defaultLanguageCode;
+    private readonly dictionaryObservable;
+    private readonly availableLanguagesObservable;
+    private readonly languageCodeSubject;
+    constructor();
+    getDictionary(): Observable<DictionaryType>;
+    getAvailableLanguages(): Observable<Language[]>;
+    getKey(key: string, placeholders?: PlaceholderType): Observable<string>;
+    getKeySync(key: string, placeholders?: PlaceholderType): string;
+    getPluralMarkerSync(count: number): string;
+    changeLanguage(code: string): void;
+    getCurrentLanguageCode(): Observable<string>;
+    setDefaultLanguageCode(code: string): void;
+    private getNavigatorLanguageCodeOrDefault;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SdkDictionaryService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SdkDictionaryService>;
+}
+
+declare enum SdkEventType {
+    PDF_RECAP_DOWNLOAD = "PDF_RECAP_DOWNLOAD",
+    RECOVERY_MODAL_OPENED = "RECOVERY_MODAL_OPENED",
+    RECOVERY_REGISTERED = "RECOVERY_REGISTERED",
+    RECOVERY_LOGIN_STARTED = "RECOVERY_LOGIN_STARTED",
+    RECOVERY_LOGIN_SUCCESS = "RECOVERY_LOGIN_SUCCESS",
+    RECOVERY_LOGIN_FAILED = "RECOVERY_LOGIN_FAILED",
+    NAVIGATION_FORWARD = "NAVIGATION_FORWARD",
+    NAVIGATION_BACKWARD = "NAVIGATION_BACKWARD",
+    TRANSMIT = "TRANSMIT",
+    BREADCRUMB_CLICK = "BREADCRUMB_CLICK"
+}
+
+declare class SdkEvent {
+    timestamp: Date;
+    reference: string;
+    sessionInfoContext?: string;
+    type: SdkEventType | string;
+    detail?: string;
+}
+
+declare class SdkEventsLoggerService {
+    private activatedRoute;
+    private gesdemService;
+    private sessionInfo;
+    private _events;
+    get events(): Observable<SdkEvent>;
+    addEvent(type: SdkEventType | string, detail?: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SdkEventsLoggerService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SdkEventsLoggerService>;
+}
+
+declare abstract class AbstractPageComponent<T extends I18nForm> implements OnInit, AfterViewInit {
+    readonly foehnFormComponent: _angular_core.Signal<FoehnFormComponent>;
+    form: T;
+    reference: string;
+    protected _destroyRef: DestroyRef;
+    protected _gesdemService: GesdemHandlerService;
+    protected _gesdemEventService: GesdemEventService;
+    protected _navigation: FoehnNavigationService;
+    protected _activatedRoute: ActivatedRoute;
+    protected _growlService: GrowlBrokerService;
+    protected _validationHandlerService: ValidationHandlerService;
+    protected _breadcrumbEventService: BreadcrumbEventService;
+    protected _foehnPageService: FoehnPageService;
+    protected _dictionaryService: SdkDictionaryService;
+    protected _eventsLoggerService: SdkEventsLoggerService;
+    private _pendingUploadService;
+    private _transmitConcurrentSafe;
+    private _gesdemSaveSubscription;
+    private readonly _registerNgModelService;
+    private readonly _pageTitle;
+    constructor();
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    send(goToNextPage?: boolean, displaySuccessMessage?: boolean): void;
+    transmit(): void;
+    sendAndTransmit(displaySuccessMessage?: boolean): void;
+    previous(): void;
+    protected setPageTitle(pageTitle: string): void;
+    protected setPageTitleAsync(pageTitle: Observable<string>): void;
+    protected onFormSent(goToNextPage: boolean): void;
+    private checkHasPendingsFilesBeforeTransmit;
+    private gotToTop;
+    abstract newForm(): T;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AbstractPageComponent<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AbstractPageComponent<any>, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class FoehnNotfoundComponent implements OnInit, OnDestroy {
+    readonly shouldRedirect: _angular_core.InputSignal<boolean>;
+    readonly setPageTitle: _angular_core.InputSignal<boolean>;
+    seconds: number;
+    private router;
+    private foehnPageService;
+    private intervalId;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private redirect;
+    private cancelSetInterval;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnNotfoundComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnNotfoundComponent, "foehn-notfound", never, { "shouldRedirect": { "alias": "shouldRedirect"; "required": false; "isSignal": true; }; "setPageTitle": { "alias": "setPageTitle"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const gesdemLoaderGuard: CanActivateFn;
+
+declare class ApplicationInfo {
+    version: string;
+    buildtime: string;
+    contextPath: string;
+    environment: string;
+    environmentLabel: string;
+    appProperties: Record<string, string>;
+    etapeInfos: Record<string, EtapeInfo>;
+    configuration: Configuration;
+    mockedServices: string[];
+}
+declare class EtapeInfo {
+    titreEtape: string;
+    idMetierEtape: string;
+    reprisePossible: boolean;
+    titrePrestation: string;
+    idMetierPrestation: string;
+    publicCible: string[];
+    decisionElectroniqueAvailable: boolean;
+    deployeeCyber: boolean;
+    lienAcces: string;
+    draftDemRetentionDaysPublic: number;
+    draftDemRetentionDaysConnected: number;
+    userFeedbackRequested?: boolean;
+    alertePerteDonnees: boolean;
+}
+declare class Configuration {
+    captcha?: Captcha;
+    portail: Portail;
+    document?: Document;
+    session?: Session;
+}
+declare class Session {
+    sessionTokenMessageDelayInMinutes: number;
+    iamMessageDelayInMinutes: number;
+}
+declare class Document {
+    fileMaxSizeInBytesByFormKey: Record<string, number>;
+    maxFileNameLength: string;
+    fileExtensions: string;
+    illegalCharacters: string;
+}
+declare class Captcha {
+    publickey?: string;
+    captchaUrlToken?: string;
+}
+declare class Portail {
+    baseVdChUrl?: string;
+    cyberLoginUrl?: string;
+    supportFormUrl?: string;
+    espaceSecuriseUrl?: string;
+    portailTitlesByPrestaCode?: Record<string, string>;
+    baseUrl?: string;
+}
+
+declare const APP_INFO_API_URL = "api/applicationInfo";
+declare const PORTAIL_BASE_URL_INT = "https://int-prestations.vd.ch/";
+declare const PORTAIL_BASE_URL_VAL = "https://val-prestations.vd.ch/";
+declare const PORTAIL_BASE_URL_PROD = "https://prestations.vd.ch/";
+declare const FORM_SUPPORT_CYBER_TITLE_FALLBACK = "Demander de l'aide pour l'utilisation du portail s\u00E9curis\u00E9";
+declare class ApplicationInfoService {
+    private readonly http;
+    private foehnPageService;
+    private applicationInfo;
+    private pulling_;
+    private data_;
+    private firstEtapeInfo_;
+    private currentEtapeInfo_;
+    constructor();
+    get data(): Observable<ApplicationInfo>;
+    get firstEtapeInfo(): Observable<EtapeInfo>;
+    get currentEtapeInfo(): Observable<EtapeInfo>;
+    getSafeCyberLoginUrl(): Observable<string>;
+    getSafeSupportFormUrl(reference?: string, errors?: FormError[]): Observable<string>;
+    getSafeSupportFormTitle(): Observable<string>;
+    getSafeEspacesSecuriseUrl(): Observable<string>;
+    private setApplicationInfo;
+    private getPortailBaseUrl;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ApplicationInfoService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ApplicationInfoService>;
+}
+
+declare class Street {
+    estrid?: string;
+    longName: string;
+}
+declare class Locality {
+    postalLocalityHistoryId?: string;
+    zipCode?: string;
+    longName?: string;
+    zipCodeId?: string;
+    municipalityId?: number;
+    cantonCode?: string;
+}
+declare class Country {
+    iso2Id: string;
+    shortNameFr: string;
+}
+declare class Address {
+    addressLine1?: string;
+    addressLine2?: string;
+    postOfficeBoxText?: string;
+    postOfficeBoxNumber?: string;
+    street?: Street;
+    houseNumber?: string;
+    dwellingNumber?: string;
+    locality?: Locality;
+    country?: Country;
+}
+
+declare class SessionInfoData {
+    lastLogin: number[];
+    context: string;
+    iup: string;
+    gender: string;
+    firstName: string;
+    fullFirstNames: string;
+    lastName: string;
+    birthDate: string;
+    birthDateAsLocalDate: number[];
+    espaceId: string;
+    espaceLabel: string;
+    businessId: string;
+    categories: string[];
+    type: string;
+    prestationsRoles: string[];
+    preferences: Preferences;
+    sessionTimeout: number;
+    ofs?: number;
+    nogaCode?: string;
+}
+declare class Preferences {
+    email: string;
+    phone: string;
+    adresseCourrier: Address;
+    adresseFacturation: Address;
+    adresseLivraison: Address;
+}
+
+declare const SESSION_INFO_API_URL = "api/sessionInfo/data";
+declare class SessionInfo {
+    private http;
+    private neverConnected_;
+    private sessionData;
+    private pulling_;
+    get data(): Observable<SessionInfoData>;
+    get neverConnected(): boolean;
+    set neverConnected(neverConnected: boolean);
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SessionInfo, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SessionInfo>;
+}
+
+declare class GesdemConfirmationComponent implements OnInit, OnChanges {
+    readonly reference: _angular_core.ModelSignal<string>;
+    readonly hasEmailSent: _angular_core.ModelSignal<boolean>;
+    readonly showDownloadPdfRecapButton: _angular_core.ModelSignal<boolean>;
+    readonly showLinkToMyDemandes: _angular_core.ModelSignal<boolean>;
+    readonly demandeIsClosedOnTransmit: _angular_core.ModelSignal<boolean>;
+    readonly actionStatut: _angular_core.ModelSignal<ActionStatut>;
+    readonly connectedConfirmationMessage: _angular_core.ModelSignal<string>;
+    readonly connectedConfirmationMessageIfAbandoned: _angular_core.ModelSignal<string>;
+    readonly downloadPdfRecapButtonText: _angular_core.ModelSignal<string>;
+    readonly closeButtonText: _angular_core.ModelSignal<string>;
+    readonly closeButtonConnectedText: _angular_core.ModelSignal<string>;
+    readonly baseUrlPdf: _angular_core.ModelSignal<string>;
+    readonly hideReference: _angular_core.ModelSignal<boolean>;
+    readonly hideFeedbackNotificationOverride: _angular_core.ModelSignal<boolean>;
+    readonly successLabelDicoKeyFirstStep: _angular_core.ModelSignal<string>;
+    readonly successLabelDicoAdditionalSteps: _angular_core.ModelSignal<string>;
+    readonly closeHref: _angular_core.InputSignal<string>;
+    readonly closeHrefConnected: _angular_core.InputSignal<string>;
+    readonly setPageTitle: _angular_core.InputSignal<boolean>;
+    isConnectedCyber: Observable<boolean>;
+    firstPageLink: string;
+    urlPdf: string;
+    closeLinkNotConnected: BehaviorSubject<string>;
+    closeLinkConnected: BehaviorSubject<string>;
+    protected _breadcrumbEventService: BreadcrumbEventService;
+    protected _foehnPageService: FoehnPageService;
+    protected _sessionInfo: SessionInfo;
+    protected _navigation: FoehnNavigationService;
+    protected _eventsLoggerService: SdkEventsLoggerService;
+    protected _applicationInfoService: ApplicationInfoService;
+    protected gesdemService: GesdemHandlerService;
+    protected foehnPageService: FoehnPageService;
+    protected activatedRoute: ActivatedRoute;
+    protected dictionaryService: SdkDictionaryService;
+    protected location: Location;
+    protected destroyRef: DestroyRef;
+    constructor();
+    get isTransferred(): boolean;
+    get isAbandoned(): boolean;
+    get isInProgress(): boolean;
+    get successLabelDicoKey(): string;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnInit(): void;
+    hasConnectedContent(): boolean;
+    logPdfDownloadedEvent(): void;
+    private getFirstPageLink;
+    private gotToTop;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GesdemConfirmationComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GesdemConfirmationComponent, "gesdem-confirmation", never, { "reference": { "alias": "reference"; "required": false; "isSignal": true; }; "hasEmailSent": { "alias": "hasEmailSent"; "required": false; "isSignal": true; }; "showDownloadPdfRecapButton": { "alias": "showDownloadPdfRecapButton"; "required": false; "isSignal": true; }; "showLinkToMyDemandes": { "alias": "showLinkToMyDemandes"; "required": false; "isSignal": true; }; "demandeIsClosedOnTransmit": { "alias": "demandeIsClosedOnTransmit"; "required": false; "isSignal": true; }; "actionStatut": { "alias": "actionStatut"; "required": false; "isSignal": true; }; "connectedConfirmationMessage": { "alias": "connectedConfirmationMessage"; "required": false; "isSignal": true; }; "connectedConfirmationMessageIfAbandoned": { "alias": "connectedConfirmationMessageIfAbandoned"; "required": false; "isSignal": true; }; "downloadPdfRecapButtonText": { "alias": "downloadPdfRecapButtonText"; "required": false; "isSignal": true; }; "closeButtonText": { "alias": "closeButtonText"; "required": false; "isSignal": true; }; "closeButtonConnectedText": { "alias": "closeButtonConnectedText"; "required": false; "isSignal": true; }; "baseUrlPdf": { "alias": "baseUrlPdf"; "required": false; "isSignal": true; }; "hideReference": { "alias": "hideReference"; "required": false; "isSignal": true; }; "hideFeedbackNotificationOverride": { "alias": "hideFeedbackNotificationOverride"; "required": false; "isSignal": true; }; "successLabelDicoKeyFirstStep": { "alias": "successLabelDicoKeyFirstStep"; "required": false; "isSignal": true; }; "successLabelDicoAdditionalSteps": { "alias": "successLabelDicoAdditionalSteps"; "required": false; "isSignal": true; }; "closeHref": { "alias": "closeHref"; "required": false; "isSignal": true; }; "closeHrefConnected": { "alias": "closeHrefConnected"; "required": false; "isSignal": true; }; "setPageTitle": { "alias": "setPageTitle"; "required": false; "isSignal": true; }; }, { "reference": "referenceChange"; "hasEmailSent": "hasEmailSentChange"; "showDownloadPdfRecapButton": "showDownloadPdfRecapButtonChange"; "showLinkToMyDemandes": "showLinkToMyDemandesChange"; "demandeIsClosedOnTransmit": "demandeIsClosedOnTransmitChange"; "actionStatut": "actionStatutChange"; "connectedConfirmationMessage": "connectedConfirmationMessageChange"; "connectedConfirmationMessageIfAbandoned": "connectedConfirmationMessageIfAbandonedChange"; "downloadPdfRecapButtonText": "downloadPdfRecapButtonTextChange"; "closeButtonText": "closeButtonTextChange"; "closeButtonConnectedText": "closeButtonConnectedTextChange"; "baseUrlPdf": "baseUrlPdfChange"; "hideReference": "hideReferenceChange"; "hideFeedbackNotificationOverride": "hideFeedbackNotificationOverrideChange"; "successLabelDicoKeyFirstStep": "successLabelDicoKeyFirstStepChange"; "successLabelDicoAdditionalSteps": "successLabelDicoAdditionalStepsChange"; }, never, ["*"], true, never>;
+}
+
+declare class GesdemErrorComponent implements OnInit {
+    readonly setPageTitle: _angular_core.InputSignal<boolean>;
+    link: string;
+    reference: string;
+    supportLink: Observable<string>;
+    hasSessionExpired: boolean;
+    demandeShouldExist: boolean;
+    wrongEtapeRequested: boolean;
+    demandeNotFound: boolean;
+    isPendingPayment: Observable<boolean>;
+    private activatedRoute;
+    private navigation;
+    private gesdemService;
+    private dictionaryService;
+    private foehnPageService;
+    private supportAlertService;
+    private applicationInfoService;
+    constructor();
+    ngOnInit(): void;
+    private getFirstPage;
+    private getBasePath;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GesdemErrorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GesdemErrorComponent, "gesdem-error", never, { "setPageTitle": { "alias": "setPageTitle"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Provides the core PrestationsNg configuration (HTTP interceptors, error handler, FontAwesome config).
+ * Replaces the old PrestationsNgCoreModule.
+ *
+ * Usage in bootstrapApplication:
+ * ```ts
+ * bootstrapApplication(AppComponent, {
+ *     providers: [providePrestationsNgCore()]
+ * });
+ * ```
+ */
+declare function providePrestationsNgCore(): EnvironmentProviders;
+
+declare class SessionInfoWithApplicationService {
+    private sessionInfo;
+    private gesdemEventService;
+    private gesdemService;
+    private sessionInfoWithNoReference;
+    private referenceObservable;
+    constructor();
+    get isUserConnected(): Observable<boolean>;
+    get isReady(): Observable<boolean>;
+    initSessionInfo(): void;
+    prefillForm(mappingFunction?: (info: SessionInfoData) => void): Observable<SessionInfoData>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SessionInfoWithApplicationService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SessionInfoWithApplicationService>;
+}
+
+declare class FoehnConfirmModalContent {
+    title?: string;
+    htmlContent: string;
+    okButtonLabel?: string;
+    showOkButton?: boolean;
+    cancelButtonLabel?: string;
+    showCancelButton?: boolean;
+    closeable?: boolean;
+    draggable?: boolean;
+    hideable?: boolean;
+}
+
+declare class FooterLink {
+    url: string;
+    label: string;
+}
+
+declare class FoehnPageComponent implements OnChanges, OnInit {
+    readonly supportAlertEnabled: _angular_core.InputSignal<boolean>;
+    readonly supportAlertUrl: _angular_core.InputSignal<string>;
+    /**
+     * If set to 'false', hide the default Contact link in the footer.
+     */
+    readonly showDefaultContactFooterLink: _angular_core.InputSignal<boolean>;
+    /**
+     * If set to 'false', hide the default Guide link in the footer.
+     */
+    readonly showDefaultGuideFooterLink: _angular_core.InputSignal<boolean>;
+    /**
+     * If set to 'false', hide the default Terms of use link.
+     */
+    readonly showDefaultTermOfUseLink: _angular_core.InputSignal<boolean>;
+    /**
+     * If set to 'false', hide the default Security Best Practice link.
+     */
+    readonly showDefaultSecurityBestPracticeLink: _angular_core.InputSignal<boolean>;
+    readonly appTitle: _angular_core.InputSignal<string>;
+    readonly footerLinks: _angular_core.InputSignal<FooterLink[]>;
+    readonly draftsEnabled: _angular_core.InputSignal<boolean>;
+    readonly draftsUrl: _angular_core.InputSignal<string>;
+    readonly etapeId: _angular_core.InputSignal<string>;
+    readonly userConnectedAsDisplayed: _angular_core.InputSignal<boolean>;
+    readonly statusProgressBarHidden: _angular_core.InputSignal<boolean>;
+    /**
+     * Alert message displayed when navigating internally (Angular router) to another page while having unsaved data.
+     */
+    readonly confirmLeavingAlert: _angular_core.InputSignal<FoehnConfirmModalContent>;
+    readonly showAppVersionMismatchAlert: _angular_core.InputSignal<boolean>;
+    readonly routerLinkAppTitle: _angular_core.InputSignal<string>;
+    /**
+     * If set to 'false', does not display native browser alert message when closing the tab, closing the browser or
+     * reloading the page while having unsaved data.
+     */
+    readonly showBeforeUnloadNativeConfirmAlert: _angular_core.InputSignal<boolean>;
+    pageTitle: string;
+    hasBlockingSupportAlert: Observable<boolean>;
+    displayUserCategory: Observable<boolean>;
+    showSecuredAreaLoginButton: Observable<boolean>;
+    loginMessagesHidden: boolean;
+    isBrowserSupported: boolean;
+    isApplePlatform: boolean;
+    browserLinkTitlePrefix: string;
+    browserNotSupportedBypass: boolean;
+    displayDemandeExpirationTimer: Observable<boolean>;
+    private _titleService;
+    private foehnPageService;
+    private supportAlertService;
+    private foehnNavigationService;
+    private applicationInfoService;
+    private gesdemEventService;
+    private breadcrumbService;
+    private router;
+    private sessionInfo;
+    private foehnPageModalService;
+    private sdkDictionaryService;
+    private statisticsService;
+    private readonly demandeExpirationService;
+    private readonly registerNgModelService;
+    private destroyRef;
+    private readonly showBeforeUnloadNativeConfirmAlertInternal;
+    private readonly showBeforeUnloadNativeConfirmAlert$;
+    constructor();
+    unloadNotification($event: BeforeUnloadEvent): void;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    getFullLoginUrl(): Observable<string>;
+    getFullLoginMessage(decisionElectroniqueAvailable: boolean): Observable<string>;
+    private setPageTitle;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnPageComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnPageComponent, "foehn-page", never, { "supportAlertEnabled": { "alias": "supportAlertEnabled"; "required": false; "isSignal": true; }; "supportAlertUrl": { "alias": "supportAlertUrl"; "required": false; "isSignal": true; }; "showDefaultContactFooterLink": { "alias": "showDefaultContactFooterLink"; "required": false; "isSignal": true; }; "showDefaultGuideFooterLink": { "alias": "showDefaultGuideFooterLink"; "required": false; "isSignal": true; }; "showDefaultTermOfUseLink": { "alias": "showDefaultTermOfUseLink"; "required": false; "isSignal": true; }; "showDefaultSecurityBestPracticeLink": { "alias": "showDefaultSecurityBestPracticeLink"; "required": false; "isSignal": true; }; "appTitle": { "alias": "appTitle"; "required": false; "isSignal": true; }; "footerLinks": { "alias": "footerLinks"; "required": false; "isSignal": true; }; "draftsEnabled": { "alias": "draftsEnabled"; "required": false; "isSignal": true; }; "draftsUrl": { "alias": "draftsUrl"; "required": false; "isSignal": true; }; "etapeId": { "alias": "etapeId"; "required": false; "isSignal": true; }; "userConnectedAsDisplayed": { "alias": "userConnectedAsDisplayed"; "required": false; "isSignal": true; }; "statusProgressBarHidden": { "alias": "statusProgressBarHidden"; "required": false; "isSignal": true; }; "confirmLeavingAlert": { "alias": "confirmLeavingAlert"; "required": false; "isSignal": true; }; "showAppVersionMismatchAlert": { "alias": "showAppVersionMismatchAlert"; "required": false; "isSignal": true; }; "routerLinkAppTitle": { "alias": "routerLinkAppTitle"; "required": false; "isSignal": true; }; "showBeforeUnloadNativeConfirmAlert": { "alias": "showBeforeUnloadNativeConfirmAlert"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class FoehnPageCounterComponent {
+    readonly textTemplate: _angular_core.InputSignal<string>;
+    isStable: Observable<boolean>;
+    private foehnNavigationService;
+    private ngZone;
+    constructor();
+    get placeholders(): PlaceholderType;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnPageCounterComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnPageCounterComponent, "foehn-page-counter", never, { "textTemplate": { "alias": "textTemplate"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class CurrentSessionExpiration {
+    expiration: dayjs.Dayjs;
+    type: 'IAM' | 'SESSION-TOKEN';
+}
+
+declare class DemandeExpirationService {
+    private interval;
+    private readonly PULLING_IN_MILLISECONDS;
+    private _demandeExpirationDateTimeSubject;
+    private intervalSubject;
+    shouldDisplayExpirationTimerMessage(): Observable<boolean>;
+    setDemandeExpirationDateTime(expiration: CurrentSessionExpiration): void;
+    getDemandeExpirationDateTime(): Observable<CurrentSessionExpiration>;
+    private startPulling;
+    private clearPulling;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DemandeExpirationService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DemandeExpirationService>;
+}
+
+declare class FoehnPageExpirationTimerComponent implements OnDestroy {
+    isVisible: Observable<boolean>;
+    countDownTimeToDisplay: Observable<string>;
+    sessionExpired: Observable<boolean>;
+    srAnnouncements: Observable<string>;
+    private applicationInfoService;
+    private dictionaryService;
+    private demandeExpirationService;
+    private countDownTimeInSeconds;
+    private sessionHasExpired;
+    private srAnnouncementsSubject;
+    private interval;
+    private dateHelper;
+    private readonly PULLING_IN_MILLISECONDS;
+    private srAnnouncementClearTimer;
+    private readonly SR_ANNOUNCEMENT_CLEAR_TIMEOUT_INTERVAL_MS;
+    private sessionExpirationDateTimeInMilliseconds;
+    constructor();
+    ngOnDestroy(): void;
+    private getAccurateCountDownTimeInSeconds;
+    private startTimer;
+    private clearTimer;
+    private formatTime;
+    private announceSrMessage;
+    private getReadableTimerForScreenReader;
+    private manageScreenReaderAnnouncement;
+    private getMessageDelayInMinutes;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnPageExpirationTimerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnPageExpirationTimerComponent, "foehn-page-expiration-timer", never, {}, {}, never, never, true, never>;
+}
+
+declare class IntervalHelper {
+    static accurateInterval(callBack: Function, intervalInMilliseconds: number, errorCallBack?: Function): unknown;
+}
+
+declare class DropdownMenuItem {
+    title: string;
+    label: string;
+    routerLink?: string;
+    queryParams?: Params;
+    href?: string;
+    target?: '_self' | '_blank' | '_parent' | '_top';
+}
+
+declare class DropdownMenuGroup {
+    title?: string;
+    items: DropdownMenuItem[];
+}
+
+declare class FoehnHeaderComponent implements OnInit {
+    readonly title: _angular_core.InputSignal<string>;
+    readonly showSecuredAreaLoginButton: _angular_core.InputSignal<boolean>;
+    readonly routerLinkAppTitle: _angular_core.InputSignal<string>;
+    readonly userInfo: _angular_core.ModelSignal<SessionInfoData>;
+    readonly isConnected: _angular_core.Signal<boolean>;
+    readonly beneficiaire: _angular_core.Signal<string>;
+    readonly isIamCyber: _angular_core.Signal<boolean>;
+    readonly isIamAcv: _angular_core.Signal<boolean>;
+    readonly isParticulier: _angular_core.Signal<boolean>;
+    readonly prenomNom: _angular_core.Signal<string>;
+    id: string;
+    connectedEsMenu: DropdownMenuGroup[];
+    isProduction: Observable<boolean>;
+    mockedServices: Observable<string[]>;
+    availableLanguages: Observable<Language[]>;
+    currentLanguageCode: Observable<string>;
+    baseVdChUrl: Observable<string>;
+    applicationInfoService: ApplicationInfoService;
+    private sessionInfo;
+    private dictionaryService;
+    private foehnPageModalService;
+    private gesdemHandlerService;
+    private destroyRef;
+    private readonly ENV_PROD;
+    private readonly AVS;
+    constructor();
+    ngOnInit(): void;
+    getEnvironmentLabel(info: ApplicationInfo): string;
+    languageChanged(languageCode: string): void;
+    getFullLoginUrl(): Observable<string>;
+    isSecuredAreaLoginButtonAllowed(): boolean;
+    private createEspaceSecuriseDropDownMenu;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnHeaderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnHeaderComponent, "foehn-header", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "showSecuredAreaLoginButton": { "alias": "showSecuredAreaLoginButton"; "required": false; "isSignal": true; }; "routerLinkAppTitle": { "alias": "routerLinkAppTitle"; "required": false; "isSignal": true; }; "userInfo": { "alias": "userInfo"; "required": false; "isSignal": true; }; }, { "userInfo": "userInfoChange"; }, never, never, true, never>;
+}
+
+declare class FoehnSkipLinkComponent implements OnInit {
+    readonly targetAnchor: _angular_core.InputSignal<string>;
+    readonly accesskey: _angular_core.InputSignal<string>;
+    readonly title: _angular_core.InputSignal<string>;
+    readonly content: _angular_core.InputSignal<string>;
+    /**
+     * The skip link path MUST take the router into account, otherwise the user is send back to
+     * the first page when the skip link is activated.
+     */
+    skipLinkPath: Observable<string>;
+    private platformLocation;
+    private router;
+    ngOnInit(): void;
+    private computeUrl;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnSkipLinkComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnSkipLinkComponent, "foehn-skip-link", never, { "targetAnchor": { "alias": "targetAnchor"; "required": false; "isSignal": true; }; "accesskey": { "alias": "accesskey"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "content": { "alias": "content"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class FoehnStatusProgressBarComponent implements OnInit {
+    readonly hidden: _angular_core.InputSignal<boolean>;
+    isTransmitted: boolean;
+    protected activatedRoute: ActivatedRoute;
+    private navigation;
+    private gesdemHand;
+    private destroyRef;
+    isEnabled(): boolean;
+    isStep2Active(): boolean;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnStatusProgressBarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnStatusProgressBarComponent, "foehn-status-progress-bar", never, { "hidden": { "alias": "hidden"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare global {
+    interface Window {
+        _paq: any;
+    }
+}
+declare class SdkStatisticsService {
+    private ngZone;
+    private _router;
+    private _applicationInfoService;
+    track(): void;
+    private send;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SdkStatisticsService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SdkStatisticsService>;
+}
+
+declare class FoehnDisplayAddressComponent {
+    readonly address: _angular_core.InputSignal<Address>;
+    /**
+     * Get the address lines formatted.
+     *
+     * ref. https://portail.etat-de-vaud.ch/outils/dsiwiki/display/Cyberadministration/Gestion+des+adresses+dans+ES
+     * Model Address explication: https://portail.etat-de-vaud.ch/outils/dsiwiki/pages/viewpage.action?pageId=747765834
+     * @param address as Address
+     * @returns any[]
+     */
+    static getLines(address: Address): string[];
+    getLines(address: Address): string[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnDisplayAddressComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnDisplayAddressComponent, "foehn-display-address", never, { "address": { "alias": "address"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class FormSelectOptionGroup {
+    groupTitle: string | null | undefined;
+    elements: any;
+}
+
+declare abstract class FoehnCheckableGroupComponent extends FoehnInputComponent<any> implements OnInit, OnChanges {
+    readonly elements: _angular_core.ModelSignal<any>;
+    readonly elementsUrl: _angular_core.InputSignal<string>;
+    /**
+     * The value in the object. Can be a string or a function.
+     * Defaults to `value`
+     */
+    readonly elementValue: _angular_core.InputSignal<any>;
+    /**
+     * The label in the object. Can be a string or a function
+     * Defaults to `label`
+     */
+    readonly elementLabel: _angular_core.InputSignal<any>;
+    /**
+     * The identify value to match the value to the list of elements.
+     * By default `x => x`
+     */
+    readonly elementValueIdentity: _angular_core.InputSignal<(element: any) => any>;
+    readonly elementDisabled: _angular_core.InputSignal<any>;
+    readonly elementGroup: _angular_core.InputSignal<any>;
+    readonly autocomplete: _angular_core.InputSignalWithTransform<string | boolean, string | boolean>;
+    readonly defaultElementValue: _angular_core.InputSignal<string>;
+    readonly elementsLoaded: _angular_core.OutputEmitterRef<any>;
+    groupedElements: FormSelectOptionGroup[];
+    protected readonly httpClient: HttpClient;
+    protected readonly multiple: Signal<boolean>;
+    private readonly ngZone;
+    private pulling_;
+    private _onInitSubject;
+    constructor();
+    get onInitSubject(): Subject<void>;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    getElements(): Observable<any>;
+    getGroup(element: any): string;
+    setElements(elements: any[]): void;
+    getValue(element: any): string;
+    getLabel(element: any): string;
+    getElementIdentifier(element: any): string;
+    getDisabled(element: any): string;
+    onCheck(element: any, valueEmitted: any, fireModelChange?: boolean): void;
+    isElementSelected(element: any): boolean;
+    reset(): void;
+    refreshElementsUrl(): void;
+    protected findIndexInModel(value: any): number;
+    protected areValuesEquals(value1: any, value2: any): boolean;
+    protected onElementsRetrieved(): void;
+    private getGroupedElements;
+    private getValueIdentityFunction;
+    private fetchData;
+    private fetchElementsFromUrl;
+    private onElementsChange;
+    private onElementsUrlChange;
+    private onCheckMultiple;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnCheckableGroupComponent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FoehnCheckableGroupComponent, never, never, { "elements": { "alias": "elements"; "required": false; "isSignal": true; }; "elementsUrl": { "alias": "elementsUrl"; "required": false; "isSignal": true; }; "elementValue": { "alias": "elementValue"; "required": false; "isSignal": true; }; "elementLabel": { "alias": "elementLabel"; "required": false; "isSignal": true; }; "elementValueIdentity": { "alias": "elementValueIdentity"; "required": false; "isSignal": true; }; "elementDisabled": { "alias": "elementDisabled"; "required": false; "isSignal": true; }; "elementGroup": { "alias": "elementGroup"; "required": false; "isSignal": true; }; "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; "defaultElementValue": { "alias": "defaultElementValue"; "required": false; "isSignal": true; }; }, { "elements": "elementsChange"; "elementsLoaded": "elementsLoaded"; }, never, never, true, never>;
+}
+
+declare class FoehnAutocompleteComponent extends FoehnCheckableGroupComponent implements OnInit, OnChanges {
+    readonly searchValueMinCharsCount: _angular_core.InputSignal<number>;
+    /**
+     * Allow to provide custom values to the autocomplete.
+     *
+     * A custom value is a value that is not in the `elements` set.
+     */
+    readonly allowCustomValue: _angular_core.InputSignal<boolean>;
+    /**
+     * Specifies if suggestion elements list is being retrieved dynamically while user inputs in search field.
+     */
+    readonly isSuggestionListDynamic: _angular_core.InputSignal<boolean>;
+    /**
+     * Allow to provide a generator to create the model with custom values.
+     *
+     * This is useful when the type of the model is an object and not just
+     * a string. Use this is `allowCustomValue` is true and `elementValue`
+     * is a function.
+     */
+    readonly customValueModelGenerator: _angular_core.InputSignal<(input: string) => any>;
+    readonly itemHeightInSuggestionListInPx: _angular_core.InputSignal<number>;
+    /**
+     * The suggestion label used in the displayed list. Can be a string or a function
+     * fallback on 'elementLabel'
+     */
+    readonly elementSuggestionLabel: _angular_core.InputSignal<any>;
+    readonly caseSensitiveSearch: _angular_core.InputSignal<boolean>;
+    /**
+     * Fired when user changes search input value
+     */
+    readonly userSearchInput: _angular_core.OutputEmitterRef<string>;
+    readonly virtualScrollViewport: _angular_core.Signal<CdkVirtualScrollViewport>;
+    readonly suggestionsList: _angular_core.Signal<any>;
+    readonly inputElement: _angular_core.Signal<any>;
+    readonly inputValue: _angular_core.WritableSignal<string>;
+    searchValue: string;
+    inputHasFocus: boolean;
+    hideSuggestions: boolean;
+    currentBlurTimer: any;
+    placeholder: string;
+    VIEW_PORT_HEIGHT: number;
+    displayedElements: any[];
+    notificationMessageUpdated: boolean;
+    disabledSubject: Observable<string>;
+    private currentItemGlobalIndex;
+    private readonly NB_ITEMS_VISIBLE;
+    private filterSubject;
+    private listHasFocus;
+    private activeDescendantId;
+    private readonly SUGGESTION_SELECTED_CLASS;
+    private readonly EXCLUDE_HTML_TAGS_REGEX;
+    private readonly SUGGESTION_CUSTOM_ATTRIBUTE_LABEL_VALUE;
+    private userSearchInputSubject;
+    private readonly model$;
+    constructor();
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    onInputFocus(): void;
+    onInputClick(): void;
+    setFocusOnInput(): void;
+    onInputBlur(): void;
+    onKeyDown(keyEvent: KeyboardEvent): boolean;
+    onKeyDownInner(keyEvent: KeyboardEvent): boolean;
+    onListOptionMouseDown(event: any): void;
+    onListOptionFocus(): void;
+    onListOptionBlur(): void;
+    filterElements(hideSuggestions?: boolean): void;
+    getSuggestionLabel(element: any): string;
+    getLabelWithEmphasis(elem: any): string;
+    onClear(): void;
+    onClickSuggestion(element: any): void;
+    reset(): void;
+    shouldDisplayListbox(): boolean;
+    getActiveDescendantId(): string;
+    showSuggestionsWhenInputHasFocusAndIsEmpty(val: string): void;
+    handleSearchInputChange(value: string): void;
+    onDynamicElementsChange(change: SimpleChange): void;
+    private clearOnBlurTimeout;
+    private setSelectedElement;
+    private setInputValue;
+    /**
+     * Verifies if value in input matches a value from suggestions. If not, empty the input if the custom value
+     * option is not set.
+     */
+    private checkAndSetInputValue;
+    private setSuggestionsDisplayed;
+    private setDisplayedElements;
+    private resizeDisplayViewPort;
+    private getSelectedElement;
+    private selectNextElement;
+    private getSuggestionList;
+    private unselectItem;
+    private selectItem;
+    private isVisible;
+    private suggestionsDisplayed;
+    private getFirstSuggestion;
+    private notifyScreenReaderUsers;
+    private getMatchingValue;
+    private matchResult;
+    private manuallyUpdateValue;
+    private getCustomValue;
+    private getModelValueDisplayValue;
+    private selectValueToDisplay;
+    private matchValueOnModelChangeSubscription;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnAutocompleteComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnAutocompleteComponent, "foehn-autocomplete", never, { "searchValueMinCharsCount": { "alias": "searchValueMinCharsCount"; "required": false; "isSignal": true; }; "allowCustomValue": { "alias": "allowCustomValue"; "required": false; "isSignal": true; }; "isSuggestionListDynamic": { "alias": "isSuggestionListDynamic"; "required": false; "isSignal": true; }; "customValueModelGenerator": { "alias": "customValueModelGenerator"; "required": false; "isSignal": true; }; "itemHeightInSuggestionListInPx": { "alias": "itemHeightInSuggestionListInPx"; "required": false; "isSignal": true; }; "elementSuggestionLabel": { "alias": "elementSuggestionLabel"; "required": false; "isSignal": true; }; "caseSensitiveSearch": { "alias": "caseSensitiveSearch"; "required": false; "isSignal": true; }; }, { "userSearchInput": "userSearchInput"; }, never, ["*"], true, never>;
+}
+
+declare abstract class FoehnInputStringComponent extends FoehnInputComponent<string> {
+    readonly trimOnBlur: _angular_core.InputSignal<boolean>;
+    readonly sanitizeOnBlur: _angular_core.InputSignal<boolean>;
+    private readonly inputSanitizerService;
+    onBlur(e: FocusEvent): void;
+    onModelChange(value: string): void;
+    private replaceTabWithWhiteSpace;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnInputStringComponent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FoehnInputStringComponent, never, never, { "trimOnBlur": { "alias": "trimOnBlur"; "required": false; "isSignal": true; }; "sanitizeOnBlur": { "alias": "sanitizeOnBlur"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class FoehnInputTextComponent extends FoehnInputStringComponent {
+    readonly numberOnly: _angular_core.InputSignal<boolean>;
+    onKeydown(event: KeyboardEvent): void;
+    private acceptedKeysForNumber;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnInputTextComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnInputTextComponent, "foehn-input-text", never, { "numberOnly": { "alias": "numberOnly"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class FoehnInputForeignLocalityComponent extends FoehnInputComponent<Locality> {
+    readonly localityRequired: _angular_core.InputSignal<boolean>;
+    readonly zipCodeRequired: _angular_core.InputSignal<boolean>;
+    zipCode: string;
+    longName: string;
+    updateLocality(): void;
+    handleUserInput(): void;
+    onModelChange(value: Locality): void;
+    isRequired(): boolean;
+    private getValidValue;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnInputForeignLocalityComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnInputForeignLocalityComponent, "foehn-input-foreign-locality", never, { "localityRequired": { "alias": "localityRequired"; "required": false; "isSignal": true; }; "zipCodeRequired": { "alias": "zipCodeRequired"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class FoehnInputForeignStreetComponent extends FoehnInputComponent<Street> {
+    longName: string;
+    updateStreet(): void;
+    handleUserInput(): void;
+    onModelChange(value: Street): void;
+    private getValidValue;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnInputForeignStreetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnInputForeignStreetComponent, "foehn-input-foreign-street", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare const SWISS_ISO_ID = "CH";
+declare class StreetNumber {
+    name: string;
+}
+declare class FoehnInputAddressComponent extends FoehnInputComponent<Address> implements OnInit, OnChanges {
+    readonly isOnlySwiss: _angular_core.InputSignal<boolean>;
+    readonly showPostOfficeBoxText: _angular_core.InputSignal<boolean>;
+    readonly showAdressLines: _angular_core.InputSignal<boolean>;
+    readonly showAdressLine1: _angular_core.InputSignal<boolean>;
+    readonly showAdressLine2: _angular_core.InputSignal<boolean>;
+    readonly countryRequired: _angular_core.InputSignal<boolean>;
+    readonly swissNpaLocalityRequired: _angular_core.InputSignal<boolean>;
+    readonly streetRequired: _angular_core.InputSignal<boolean>;
+    readonly streetNumberRequired: _angular_core.InputSignal<boolean>;
+    readonly hideNotRequiredExtraLabelStreetNumber: _angular_core.InputSignal<boolean>;
+    readonly foreignZipCodeRequired: _angular_core.InputSignal<boolean>;
+    readonly foreignLocalityRequired: _angular_core.InputSignal<boolean>;
+    readonly foreignStreetRequired: _angular_core.InputSignal<boolean>;
+    readonly foreignStreetNumberRequired: _angular_core.InputSignal<boolean>;
+    readonly postOfficeBoxTextRequired: _angular_core.InputSignal<boolean>;
+    readonly addressLine1Required: _angular_core.InputSignal<boolean>;
+    readonly addressLine2Required: _angular_core.InputSignal<boolean>;
+    readonly withCompanyLocalities: _angular_core.InputSignal<boolean>;
+    readonly withDefaultCountry: _angular_core.InputSignal<boolean>;
+    readonly specifiedCanton: _angular_core.InputSignal<string>;
+    readonly countriesUrl: _angular_core.InputSignal<string>;
+    readonly foreignLocalityComponent: _angular_core.Signal<FoehnInputForeignLocalityComponent>;
+    readonly foreignStreetComponent: _angular_core.Signal<FoehnInputForeignStreetComponent>;
+    readonly foreignHouseNumber: _angular_core.Signal<FoehnInputTextComponent>;
+    readonly countryAutocomplete: _angular_core.Signal<FoehnAutocompleteComponent>;
+    country: Country;
+    locality: Locality;
+    street: Street;
+    houseNumber: string;
+    postOfficeBoxText: string;
+    addressLine1: string;
+    addressLine2: string;
+    countries: Observable<Country[]>;
+    localities: Observable<Locality[]>;
+    streets: Observable<Street[]>;
+    streetNumbers: Observable<StreetNumber[]>;
+    streetCustomErrors: Record<string, string>;
+    private readonly httpClient;
+    private readonly dictionaryService;
+    private iso2IdSubject;
+    private zipCodeIdSubject;
+    private estrIdSubject;
+    private countryModelChangeSubject;
+    private isOnlySwissChangeSubject;
+    constructor();
+    identity: <T>(n: T) => T;
+    countryIdentity: (country: Country) => string;
+    localityIdentity: (loc: Locality) => string;
+    streetIdentity: (street: Street) => string;
+    streetGenerator: (longName: string) => Street;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    updateAddress(): void;
+    handleUserInput(): void;
+    onModelChange(value: Address): void;
+    isSwiss(): boolean;
+    userInputCountry(country: unknown): void;
+    userInputLocality(locality: unknown): void;
+    userInputStreet(street: unknown): void;
+    countryUpdated(country: Country): void;
+    getLocalityDisplayedName(locality: Locality): string | void;
+    localityUpdated(locality: Locality): void;
+    streetUpdated(street: Street): void;
+    isStreetRequired(): boolean;
+    isForeignStreetRequired(): boolean;
+    isPostOfficeBoxTextRequired(): boolean;
+    private sanitizeAddress;
+    private replaceAtLeastOneNotNull;
+    private getCountries;
+    private getLocalities;
+    private getStreetNumberFor;
+    private getStreetsFor;
+    private clearAutocompletesWhenCountryIsUnappropriatedToComponentConfiguration;
+    private getSwissCountry;
+    private setDefaultCountry;
+    private clearAutocompletes;
+    private extractLocalityZipCodeId;
+    private extractStreetEstrid;
+    private getValidCountry;
+    private getValidValue;
+    private isModelEmpty;
+    private manageDefaultCountry;
+    private isCountryInputDirty;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnInputAddressComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnInputAddressComponent, "foehn-input-address", never, { "isOnlySwiss": { "alias": "isOnlySwiss"; "required": false; "isSignal": true; }; "showPostOfficeBoxText": { "alias": "showPostOfficeBoxText"; "required": false; "isSignal": true; }; "showAdressLines": { "alias": "showAdressLines"; "required": false; "isSignal": true; }; "showAdressLine1": { "alias": "showAdressLine1"; "required": false; "isSignal": true; }; "showAdressLine2": { "alias": "showAdressLine2"; "required": false; "isSignal": true; }; "countryRequired": { "alias": "countryRequired"; "required": false; "isSignal": true; }; "swissNpaLocalityRequired": { "alias": "swissNpaLocalityRequired"; "required": false; "isSignal": true; }; "streetRequired": { "alias": "streetRequired"; "required": false; "isSignal": true; }; "streetNumberRequired": { "alias": "streetNumberRequired"; "required": false; "isSignal": true; }; "hideNotRequiredExtraLabelStreetNumber": { "alias": "hideNotRequiredExtraLabelStreetNumber"; "required": false; "isSignal": true; }; "foreignZipCodeRequired": { "alias": "foreignZipCodeRequired"; "required": false; "isSignal": true; }; "foreignLocalityRequired": { "alias": "foreignLocalityRequired"; "required": false; "isSignal": true; }; "foreignStreetRequired": { "alias": "foreignStreetRequired"; "required": false; "isSignal": true; }; "foreignStreetNumberRequired": { "alias": "foreignStreetNumberRequired"; "required": false; "isSignal": true; }; "postOfficeBoxTextRequired": { "alias": "postOfficeBoxTextRequired"; "required": false; "isSignal": true; }; "addressLine1Required": { "alias": "addressLine1Required"; "required": false; "isSignal": true; }; "addressLine2Required": { "alias": "addressLine2Required"; "required": false; "isSignal": true; }; "withCompanyLocalities": { "alias": "withCompanyLocalities"; "required": false; "isSignal": true; }; "withDefaultCountry": { "alias": "withDefaultCountry"; "required": false; "isSignal": true; }; "specifiedCanton": { "alias": "specifiedCanton"; "required": false; "isSignal": true; }; "countriesUrl": { "alias": "countriesUrl"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class FoehnBreadcrumbComponent implements OnInit {
+    readonly breadcrumbItems: _angular_core.InputSignal<BreadcrumbItem[]>;
+    readonly currentNav: _angular_core.InputSignal<string>;
+    readonly confirmLeavingAlert: _angular_core.InputSignal<FoehnConfirmModalContent>;
+    readonly breadcrumbItemsInternal: _angular_core.WritableSignal<BreadcrumbItem[]>;
+    readonly currentNavInternal: _angular_core.WritableSignal<string>;
+    private readonly breadcrumbService;
+    private readonly router;
+    private readonly foehnConfirmModalService;
+    private readonly sessionInfo;
+    private readonly sdkEventsLoggerService;
+    private readonly destroyRef;
+    reset(): void;
+    ngOnInit(): void;
+    confirmAndLeave(item: BreadcrumbItem): void;
+    redirect(item: BreadcrumbItem): void;
+    private navigate;
+    private addBreadcrumbClickEventToLogger;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnBreadcrumbComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnBreadcrumbComponent, "foehn-breadcrumb", never, { "breadcrumbItems": { "alias": "breadcrumbItems"; "required": false; "isSignal": true; }; "currentNav": { "alias": "currentNav"; "required": false; "isSignal": true; }; "confirmLeavingAlert": { "alias": "confirmLeavingAlert"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class FoehnCheckboxComponent extends FoehnCheckableGroupComponent implements OnInit {
+    readonly multiple: _angular_core.WritableSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnCheckboxComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnCheckboxComponent, "foehn-checkbox", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class FoehnRadioComponent extends FoehnCheckableGroupComponent implements OnInit {
+    inputValue: string;
+    ngOnInit(): void;
+    onModelChange(value: any): void;
+    getValueOrObject(element: any): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnRadioComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnRadioComponent, "foehn-radio", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class FoehnSelectComponent extends FoehnCheckableGroupComponent implements OnInit {
+    readonly multiple: _angular_core.InputSignal<boolean>;
+    readonly noSelectionLabel: _angular_core.InputSignal<string>;
+    readonly showEmptyOption: _angular_core.Signal<boolean>;
+    /**
+     * Angular uses object identity to select option. It's possible for the identities of items to change while the data does not.
+     * This can happen, for example, if the items are produced from an RPC to the server, and that RPC is re-run.
+     * Even if the data hasn't changed, the second response will produce objects with different identities.
+     * (see: https://angular.io/api/forms/SelectControlValueAccessor#customizing-option-selection)
+     * @param value1 as first value to compare to
+     * @param value2 as value to be compared to
+     * @returns boolean
+     */
+    compareFn(value1: any, value2: any): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnSelectComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnSelectComponent, "foehn-select", never, { "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "noSelectionLabel": { "alias": "noSelectionLabel"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class FormSelectOption {
+    label: string;
+    value: string;
+    disabled?: boolean;
+}
+
+declare class FoehnMultiselectAutocompleteComponent extends FoehnAutocompleteComponent implements OnInit {
+    hostName: string;
+    /**
+     * The label in the object. Can be a string or a function
+     * Defaults to `label`
+     */
+    readonly elementBadgeLabel: _angular_core.InputSignal<any>;
+    readonly selectedItemsListLegend: _angular_core.InputSignal<string>;
+    readonly noElementsSelectedLabel: _angular_core.InputSignal<string>;
+    readonly excludeFromErrorSummary: _angular_core.InputSignalWithTransform<boolean, boolean>;
+    readonly multiple: _angular_core.WritableSignal<boolean>;
+    readonly defaultElementValues: _angular_core.InputSignal<unknown[]>;
+    readonly autocompleteComponent: _angular_core.Signal<FoehnAutocompleteComponent>;
+    readonly alertMessageContainer: _angular_core.Signal<ElementRef<any>>;
+    readonly selectedElemRef: _angular_core.Signal<readonly ElementRef<any>[]>;
+    readonly defaultElemRef: _angular_core.Signal<readonly ElementRef<any>[]>;
+    readonly defaultDeleteFocusArea: _angular_core.Signal<ElementRef<any>>;
+    readonly defaultElementValuesComputed: _angular_core.Signal<unknown[]>;
+    autocompleteInputValue: string;
+    showEmptyListMessage: boolean;
+    srAnnouncements: string;
+    private readonly dictionaryService;
+    private srAnnouncementClearTimer;
+    private readonly SR_ANNOUNCEMENT_CLEAR_TIMEOUT_INTERVAL_MS;
+    private pendingRemovedIndexForFocus;
+    private readonly selectedElemRefEffect;
+    ngOnInit(): void;
+    onModelChange(value: any): void;
+    hasErrorsToDisplay(): boolean;
+    getLabel(value: any): string;
+    updateMultiselectAutocomplete(currentModel: unknown[]): void;
+    handleUserInput(currentModel: unknown[]): void;
+    addItem(item: unknown): void;
+    removeItem(item: unknown, index: number): void;
+    trackByFn(index: number): number;
+    canBeDeleted(index: number): boolean;
+    onAutocompleteElementsLoaded(elements: []): void;
+    getDeleteButtonAriaLabel(element: unknown): string;
+    hasDefaultDeleteFocusArea(): boolean;
+    getBadgeLabel(element: any): string;
+    private manageListWhenElementsAreLoaded;
+    private findElementByModelItem;
+    private getValidValue;
+    private focusNextAreaAfterDelete;
+    private filterAutocompleteElements;
+    private manageSuggestionListAndFocusAfterAddingAnItem;
+    private manageSuggestionListAndFocusAfterRemovingAnItem;
+    private showAlertMessageAndHideAutocomplete;
+    private manageScreenReaderAnnouncement;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnMultiselectAutocompleteComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnMultiselectAutocompleteComponent, "foehn-multiselect-autocomplete", never, { "elementBadgeLabel": { "alias": "elementBadgeLabel"; "required": false; "isSignal": true; }; "selectedItemsListLegend": { "alias": "selectedItemsListLegend"; "required": false; "isSignal": true; }; "noElementsSelectedLabel": { "alias": "noElementsSelectedLabel"; "required": false; "isSignal": true; }; "excludeFromErrorSummary": { "alias": "excludeFromErrorSummary"; "required": false; "isSignal": true; }; "defaultElementValues": { "alias": "defaultElementValues"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class FoehnInputEmailComponent extends FoehnInputStringComponent implements OnInit {
+    timeoutReference: any;
+    readonly autocomplete: _angular_core.InputSignalWithTransform<string | boolean, string | boolean>;
+    private dictionaryService;
+    ngOnInit(): void;
+    onModelChange(value: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnInputEmailComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnInputEmailComponent, "foehn-input-email", never, { "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class FoehnInputHiddenComponent extends FoehnInputStringComponent implements OnInit {
+    timeoutReference: any;
+    constructor();
+    ngOnInit(): void;
+    onModelChange(value: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnInputHiddenComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnInputHiddenComponent, "foehn-input-hidden", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class FoehnInputNumberComponent extends FoehnInputStringComponent implements OnInit, OnChanges {
+    readonly hideStandardHelpText: _angular_core.InputSignal<boolean>;
+    readonly allowDecimal: _angular_core.InputSignal<boolean>;
+    readonly allowNegative: _angular_core.InputSignal<boolean>;
+    readonly maxDecimalCount: _angular_core.InputSignal<number>;
+    readonly allowFreeInput: _angular_core.InputSignal<boolean>;
+    readonly allowLeadingZero: _angular_core.InputSignal<boolean>;
+    readonly maxlength: _angular_core.InputSignalWithTransform<number, number>;
+    private readonly dictionaryService;
+    private initialHelpText;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    getMaxLength(): number;
+    updateNgModel(value: string): void;
+    /**
+     * To be used for post-formatting by directives.
+     * @param value of model
+     */
+    forceUpdateNgModel(value: string): void;
+    private isStringAValidNumber;
+    private isModelValid;
+    private getValidationRegex;
+    private replaceCommaWithDot;
+    private removeNonNumericCharacters;
+    private cleanDecimals;
+    private getCleanNumber;
+    private updateInputElementValue;
+    private setToEmpty;
+    private manageHelpText;
+    private formatValue;
+    private removeLeadingZero;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnInputNumberComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnInputNumberComponent, "foehn-input-number", never, { "hideStandardHelpText": { "alias": "hideStandardHelpText"; "required": false; "isSignal": true; }; "allowDecimal": { "alias": "allowDecimal"; "required": false; "isSignal": true; }; "allowNegative": { "alias": "allowNegative"; "required": false; "isSignal": true; }; "maxDecimalCount": { "alias": "maxDecimalCount"; "required": false; "isSignal": true; }; "allowFreeInput": { "alias": "allowFreeInput"; "required": false; "isSignal": true; }; "allowLeadingZero": { "alias": "allowLeadingZero"; "required": false; "isSignal": true; }; "maxlength": { "alias": "maxlength"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class FoehnInputPasswordComponent extends FoehnInputStringComponent implements OnInit {
+    timeoutReference: any;
+    readonly autocomplete: _angular_core.InputSignalWithTransform<string | boolean, string | boolean>;
+    ngOnInit(): void;
+    onModelChange(value: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnInputPasswordComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnInputPasswordComponent, "foehn-input-password", never, { "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare const DEFAULT_INTERNATIONAL_AND_NO_SWISS = "foehn-input-phone.DEFAULT_INTERNATIONAL_AND_NO_SWISS";
+declare const DEFAULT_INTERNATIONAL_AND_NO_SWISS_PHONE = "foehn-input-phone.DEFAULT_INTERNATIONAL_AND_NO_SWISS_PHONE";
+declare const DEFAULT_INTERNATIONAL_AND_NO_SWISS_MOBILE = "foehn-input-phone.DEFAULT_INTERNATIONAL_AND_NO_SWISS_MOBILE";
+declare const DEFAULT_INTERNATIONAL_HELP_TEXT = "foehn-input-phone.DEFAULT_INTERNATIONAL_HELP_TEXT";
+declare const DEFAULT_SWISS_HELP_TEXT = "foehn-input-phone.DEFAULT_SWISS_HELP_TEXT";
+declare const DEFAULT_SWISS_PHONE_HELP_TEXT = "foehn-input-phone.DEFAULT_SWISS_PHONE_HELP_TEXT";
+declare const DEFAULT_SWISS_MOBILE_PHONE_HELP_TEXT = "foehn-input-phone.DEFAULT_SWISS_MOBILE_PHONE_HELP_TEXT";
+declare const BAD_PARAMS_HELP_TEXT = "Mauvais param\u00E9trage du composant. Un t\u00E9l\u00E9phone est soit international, mobile, fixe ou les deux mais pas rien";
+declare class FoehnInputPhoneComponent extends FoehnInputStringComponent implements OnInit {
+    readonly acceptInternational: _angular_core.InputSignal<boolean>;
+    readonly acceptMobilePhone: _angular_core.InputSignal<boolean>;
+    readonly acceptPhone: _angular_core.InputSignal<boolean>;
+    readonly autocomplete: _angular_core.InputSignalWithTransform<string | boolean, string | boolean>;
+    private dictionaryService;
+    ngOnInit(): void;
+    private getStandardHelpTextDicoKey;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnInputPhoneComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnInputPhoneComponent, "foehn-input-phone", never, { "acceptInternational": { "alias": "acceptInternational"; "required": false; "isSignal": true; }; "acceptMobilePhone": { "alias": "acceptMobilePhone"; "required": false; "isSignal": true; }; "acceptPhone": { "alias": "acceptPhone"; "required": false; "isSignal": true; }; "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare const DEFAULT_PREFIX = "prefix ";
+declare class FoehnInputPrefixedTextComponent extends FoehnInputStringComponent {
+    readonly prefix: _angular_core.InputSignal<string>;
+    readonly prefixColClass: _angular_core.InputSignal<string>;
+    readonly textColClass: _angular_core.InputSignal<string>;
+    readonly text: _angular_core.Signal<string>;
+    private previousPrefix;
+    constructor();
+    onTextChange(value: string): void;
+    updateFullText(text: string): void;
+    handleUserInput(text: string): void;
+    private getValidValue;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnInputPrefixedTextComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnInputPrefixedTextComponent, "foehn-input-prefixed-text", never, { "prefix": { "alias": "prefix"; "required": false; "isSignal": true; }; "prefixColClass": { "alias": "prefixColClass"; "required": false; "isSignal": true; }; "textColClass": { "alias": "textColClass"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class FoehnInputTextareaComponent extends FoehnInputStringComponent implements OnInit {
+    readonly rows: _angular_core.InputSignal<number>;
+    readonly displayCharCount: _angular_core.InputSignal<boolean>;
+    isCharCountExceeded: boolean;
+    charCountLeft: number;
+    charCountLabel: string;
+    ariaLiveStatus: string;
+    private dictionary;
+    ngOnInit(): void;
+    onModelChange(value: string): void;
+    countCharLeft(): void;
+    checkCharCountExceeded(): void;
+    private getCharCountLabel;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnInputTextareaComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnInputTextareaComponent, "foehn-input-textarea", never, { "rows": { "alias": "rows"; "required": false; "isSignal": true; }; "displayCharCount": { "alias": "displayCharCount"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class FoehnDateComponent extends FoehnInputComponent<number[]> {
+    readonly disableDay: _angular_core.InputSignal<boolean>;
+    readonly disableMonth: _angular_core.InputSignal<boolean>;
+    readonly disableYear: _angular_core.InputSignal<boolean>;
+    readonly hideDatePickerButton: _angular_core.InputSignal<boolean>;
+    readonly minDate: _angular_core.InputSignal<number[]>;
+    readonly maxDate: _angular_core.InputSignal<number[]>;
+    readonly childrenLabelSrOnly: _angular_core.InputSignal<boolean>;
+    readonly clearButton: _angular_core.InputSignal<boolean>;
+    day: string;
+    month: string;
+    year: string;
+    datePickerModel: number[];
+    readonly disabledComputed: Signal<boolean>;
+    constructor();
+    updateDate(): void;
+    updateDateFromDatePicker(date: number[]): void;
+    handleUserInput(): void;
+    handleDatePickerUserInput(date: number[]): void;
+    onModelChange(value: number[]): void;
+    getValidValue(): number[] | null | undefined;
+    shouldDisplayDatePicker(): boolean;
+    resetModel(): void;
+    isEmpty(): boolean;
+    isEmptyDependingOnDisabled(): boolean;
+    private toNumber;
+    private numberToString;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnDateComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnDateComponent, "foehn-input-date", never, { "disableDay": { "alias": "disableDay"; "required": false; "isSignal": true; }; "disableMonth": { "alias": "disableMonth"; "required": false; "isSignal": true; }; "disableYear": { "alias": "disableYear"; "required": false; "isSignal": true; }; "hideDatePickerButton": { "alias": "hideDatePickerButton"; "required": false; "isSignal": true; }; "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; "childrenLabelSrOnly": { "alias": "childrenLabelSrOnly"; "required": false; "isSignal": true; }; "clearButton": { "alias": "clearButton"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class FoehnDateTimeComponent extends FoehnInputComponent<number[]> {
+    readonly disableDay: _angular_core.InputSignal<boolean>;
+    readonly disableMonth: _angular_core.InputSignal<boolean>;
+    readonly disableYear: _angular_core.InputSignal<boolean>;
+    readonly minDate: _angular_core.InputSignal<number[]>;
+    readonly maxDate: _angular_core.InputSignal<number[]>;
+    readonly hideDatePickerButton: _angular_core.InputSignal<boolean>;
+    readonly childrenLabelSrOnly: _angular_core.InputSignal<boolean>;
+    readonly clearButton: _angular_core.InputSignal<boolean>;
+    date: number[];
+    time: string;
+    private userInputTimeSubject;
+    private timeModelChangeSubject;
+    private dateHelper;
+    constructor();
+    updateDateTime(): void;
+    handleUserInput(): void;
+    timeModelChange(value: string): void;
+    handleUserInputTime(value: string): void;
+    handleUserInputDate(): void;
+    onModelChange(value: number[]): void;
+    getValidValue(): number[] | null | undefined;
+    resetModel(): void;
+    isEmpty(): boolean;
+    isEmptyDependingOnDisabled(): boolean;
+    private isTimeEmpty;
+    private isDateEmpty;
+    private isDateEmptyDependingOnDisabled;
+    private toNumber;
+    private numberToString;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnDateTimeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnDateTimeComponent, "foehn-input-date-time", never, { "disableDay": { "alias": "disableDay"; "required": false; "isSignal": true; }; "disableMonth": { "alias": "disableMonth"; "required": false; "isSignal": true; }; "disableYear": { "alias": "disableYear"; "required": false; "isSignal": true; }; "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; "hideDatePickerButton": { "alias": "hideDatePickerButton"; "required": false; "isSignal": true; }; "childrenLabelSrOnly": { "alias": "childrenLabelSrOnly"; "required": false; "isSignal": true; }; "clearButton": { "alias": "clearButton"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class FoehnTimeComponent extends FoehnInputStringComponent {
+    readonly childrenLabelSrOnly: _angular_core.InputSignal<boolean>;
+    readonly clearButton: _angular_core.InputSignal<boolean>;
+    hour: string;
+    minute: string;
+    private dateHelper;
+    constructor();
+    updateTime(): void;
+    handleUserInput(): void;
+    onModelChange(value: string): void;
+    resetModel(): void;
+    isEmpty(): boolean;
+    private getValidValue;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnTimeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnTimeComponent, "foehn-input-time", never, { "childrenLabelSrOnly": { "alias": "childrenLabelSrOnly"; "required": false; "isSignal": true; }; "clearButton": { "alias": "clearButton"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class FoehnInputNav13Component extends FoehnInputStringComponent implements OnInit {
+    PREFIX_NAVS: string;
+    part2: string;
+    part3: string;
+    part4: string;
+    readonly label: _angular_core.InputSignalWithTransform<string, string>;
+    constructor();
+    ngOnInit(): void;
+    updateNavs(): void;
+    handleUserInput(): void;
+    onModelChange(value: string): void;
+    onPaste(event: ClipboardEvent): void;
+    private splitValue;
+    private getValidValue;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnInputNav13Component, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnInputNav13Component, "foehn-input-nav13", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class FoehnBooleanCheckboxComponent extends FoehnInputComponent<boolean> {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnBooleanCheckboxComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnBooleanCheckboxComponent, "foehn-boolean-checkbox", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class FoehnBooleanRadioComponent extends FoehnInputComponent<boolean> {
+    readonly trueLabel: _angular_core.InputSignal<string>;
+    readonly falseLabel: _angular_core.InputSignal<string>;
+    readonly verticalDisplay: _angular_core.InputSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnBooleanRadioComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnBooleanRadioComponent, "foehn-boolean-radio", never, { "trueLabel": { "alias": "trueLabel"; "required": false; "isSignal": true; }; "falseLabel": { "alias": "falseLabel"; "required": false; "isSignal": true; }; "verticalDisplay": { "alias": "verticalDisplay"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class DisplayCurrencyPipe implements PipeTransform {
+    private currencyHelper;
+    transform(value: number | string, currency?: string, fixedDecimalCount?: number, showZero?: boolean): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DisplayCurrencyPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<DisplayCurrencyPipe, "displayCurrency", true>;
+}
+
+declare class DisplayDatePipe implements PipeTransform {
+    private readonly dateHelper;
+    transform(value: Date | number[], showTime?: boolean): any;
+    private transformFromDate;
+    private transformFromArray;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DisplayDatePipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<DisplayDatePipe, "displayDate", true>;
+}
+
+declare class FormatIdePipe implements PipeTransform {
+    transform(value: string, _args: string[]): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormatIdePipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<FormatIdePipe, "formatIde", true>;
+}
+
+declare const GrowlType: {
+    SUCCESS: string;
+    INFO: string;
+    WARNING: string;
+    DANGER: string;
+};
+
+declare class SdkDictionaryPipe implements PipeTransform {
+    private dictionaryService;
+    private ref;
+    private asyncPipe;
+    constructor();
+    transform(key: any, placeHolderType?: PlaceholderType): any;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SdkDictionaryPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<SdkDictionaryPipe, "fromDictionary", true>;
+}
+
+declare abstract class AbstractFoehnNavigationComponent {
+    readonly showContinueLaterButton: _angular_core.InputSignal<boolean>;
+    readonly showNextButton: _angular_core.InputSignal<boolean>;
+    readonly nextLabel: _angular_core.InputSignal<string>;
+    readonly prevLabel: _angular_core.InputSignal<string>;
+    readonly continueLaterLabel: _angular_core.InputSignal<string>;
+    readonly continueLaterAlreadyRegisteredLabel: _angular_core.InputSignal<string>;
+    readonly continueLaterConnectedLabel: _angular_core.InputSignal<string>;
+    readonly triggerRecoveryOnPageChange: _angular_core.InputSignal<boolean>;
+    readonly onNext: _angular_core.OutputEmitterRef<void>;
+    readonly onPrevious: _angular_core.OutputEmitterRef<void>;
+    goToNext(): void;
+    goToPrevious(): void;
+    canShowNextButton(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AbstractFoehnNavigationComponent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AbstractFoehnNavigationComponent, never, never, { "showContinueLaterButton": { "alias": "showContinueLaterButton"; "required": false; "isSignal": true; }; "showNextButton": { "alias": "showNextButton"; "required": false; "isSignal": true; }; "nextLabel": { "alias": "nextLabel"; "required": false; "isSignal": true; }; "prevLabel": { "alias": "prevLabel"; "required": false; "isSignal": true; }; "continueLaterLabel": { "alias": "continueLaterLabel"; "required": false; "isSignal": true; }; "continueLaterAlreadyRegisteredLabel": { "alias": "continueLaterAlreadyRegisteredLabel"; "required": false; "isSignal": true; }; "continueLaterConnectedLabel": { "alias": "continueLaterConnectedLabel"; "required": false; "isSignal": true; }; "triggerRecoveryOnPageChange": { "alias": "triggerRecoveryOnPageChange"; "required": false; "isSignal": true; }; }, { "onNext": "onNext"; "onPrevious": "onPrevious"; }, never, never, true, never>;
+}
+
+declare class FoehnNavigationComponent extends AbstractFoehnNavigationComponent implements OnInit {
+    readonly transmitLabel: _angular_core.InputSignal<string>;
+    private navigationService;
+    private activatedRoute;
+    ngOnInit(): void;
+    canShowNextButton(): boolean;
+    canShowPreviousButton(): boolean;
+    isForcedOnRecapForPendingPayment(): boolean;
+    isLastFormPage(): boolean;
+    getNextRouteIndex(): number;
+    getPreviousRouteIndex(): number;
+    getTotalRoutesSize(): number;
+    isLinearRouting(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnNavigationComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnNavigationComponent, "foehn-navigation", never, { "transmitLabel": { "alias": "transmitLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class FoehnSimpleNavigationComponent extends AbstractFoehnNavigationComponent {
+    readonly showPreviousButton: _angular_core.InputSignal<boolean>;
+    canShowPreviousButton(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnSimpleNavigationComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnSimpleNavigationComponent, "foehn-simple-navigation", never, { "showPreviousButton": { "alias": "showPreviousButton"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class FoehnRemainingAlertsSummaryComponent {
+    readonly remainingErrorNamesToIgnore: _angular_core.InputSignal<string[]>;
+    readonly remainingErrorsLabel: _angular_core.InputSignal<string>;
+    showDebugData: Observable<boolean>;
+    hasRemainingErrors: Observable<boolean>;
+    remainingErrors: Observable<FormError[]>;
+    remainingErrorsMessage: Observable<string>;
+    private gesdemService;
+    private applicationInfoService;
+    private dictionaryService;
+    private readonly DEFAULT_REMAINING_ERRORS_MSG_KEY;
+    private reference;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnRemainingAlertsSummaryComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnRemainingAlertsSummaryComponent, "foehn-remaining-alerts-summary", never, { "remainingErrorNamesToIgnore": { "alias": "remainingErrorNamesToIgnore"; "required": false; "isSignal": true; }; "remainingErrorsLabel": { "alias": "remainingErrorsLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class FoehnValidationAlertSummaryComponent {
+    readonly form: _angular_core.InputSignal<FoehnFormComponent>;
+    private readonly validationHandlerService;
+    get shouldDisplayAlertSummary(): boolean;
+    get errors(): ComponentError[];
+    scrollToError(event: Event, errorId: string): void;
+    trackByError(index: number, e: ComponentError): string;
+    protected findFirstHtmlInputElementEnabled(elementNodeListOf: NodeListOf<Element>): HTMLInputElement;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnValidationAlertSummaryComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnValidationAlertSummaryComponent, "foehn-validation-alert-summary", never, { "form": { "alias": "form"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class ComponentError {
+    name: string;
+    message: string;
+    componentLabel: string;
+}
+
+declare class FoehnValidationAlertsComponent {
+    component: _angular_core.InputSignal<FoehnInputComponent<any>>;
+    readonly shouldErrorsBeLive: _angular_core.InputSignal<boolean>;
+    private validationHandlerService;
+    get errorMessages(): FormError[];
+    getMessage(error: FormError): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnValidationAlertsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnValidationAlertsComponent, "foehn-validation-alerts", never, { "component": { "alias": "component"; "required": false; "isSignal": true; }; "shouldErrorsBeLive": { "alias": "shouldErrorsBeLive"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare abstract class AbstractIconComponent {
+    readonly title: _angular_core.InputSignal<string>;
+    abstract iconName: IconDefinition;
+    abstract defaultTitle: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AbstractIconComponent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AbstractIconComponent, never, never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class FoehnIconCalendarComponent extends AbstractIconComponent {
+    iconName: _fortawesome_fontawesome_common_types.IconDefinition;
+    defaultTitle: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnIconCalendarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnIconCalendarComponent, "foehn-icon-calendar", never, {}, {}, never, never, true, never>;
+}
+
+declare class FoehnIconCheckComponent extends AbstractIconComponent {
+    iconName: _fortawesome_fontawesome_common_types.IconDefinition;
+    defaultTitle: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnIconCheckComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnIconCheckComponent, "foehn-icon-check", never, {}, {}, never, never, true, never>;
+}
+
+declare class FoehnIconCheckSquareOComponent extends AbstractIconComponent {
+    iconName: _fortawesome_fontawesome_common_types.IconDefinition;
+    defaultTitle: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnIconCheckSquareOComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnIconCheckSquareOComponent, "foehn-icon-check-square-o", never, {}, {}, never, never, true, never>;
+}
+
+declare class FoehnIconChevronDownComponent extends AbstractIconComponent {
+    iconName: _fortawesome_fontawesome_common_types.IconDefinition;
+    defaultTitle: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnIconChevronDownComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnIconChevronDownComponent, "foehn-icon-chevron-down", never, {}, {}, never, never, true, never>;
+}
+
+declare class FoehnIconChevronLeftComponent extends AbstractIconComponent {
+    iconName: _fortawesome_fontawesome_common_types.IconDefinition;
+    defaultTitle: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnIconChevronLeftComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnIconChevronLeftComponent, "foehn-icon-chevron-left", never, {}, {}, never, never, true, never>;
+}
+
+declare class FoehnIconChevronRightComponent extends AbstractIconComponent {
+    iconName: _fortawesome_fontawesome_common_types.IconDefinition;
+    defaultTitle: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnIconChevronRightComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnIconChevronRightComponent, "foehn-icon-chevron-right", never, {}, {}, never, never, true, never>;
+}
+
+declare class FoehnIconChevronUpComponent extends AbstractIconComponent {
+    iconName: _fortawesome_fontawesome_common_types.IconDefinition;
+    defaultTitle: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnIconChevronUpComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnIconChevronUpComponent, "foehn-icon-chevron-up", never, {}, {}, never, never, true, never>;
+}
+
+declare class FoehnIconClockComponent extends AbstractIconComponent {
+    iconName: _fortawesome_fontawesome_common_types.IconDefinition;
+    defaultTitle: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnIconClockComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnIconClockComponent, "foehn-icon-clock", never, {}, {}, never, never, true, never>;
+}
+
+declare class FoehnIconCommentDotsComponent extends AbstractIconComponent {
+    iconName: _fortawesome_fontawesome_common_types.IconDefinition;
+    defaultTitle: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnIconCommentDotsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnIconCommentDotsComponent, "foehn-icon-comment-dots", never, {}, {}, never, never, true, never>;
+}
+
+declare class FoehnIconEditComponent extends AbstractIconComponent {
+    iconName: _fortawesome_fontawesome_common_types.IconDefinition;
+    defaultTitle: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnIconEditComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnIconEditComponent, "foehn-icon-edit", never, {}, {}, never, never, true, never>;
+}
+
+declare class FoehnIconExternalLinkAltComponent extends AbstractIconComponent {
+    iconName: _fortawesome_fontawesome_common_types.IconDefinition;
+    defaultTitle: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnIconExternalLinkAltComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnIconExternalLinkAltComponent, "foehn-icon-external-link-alt", never, {}, {}, never, never, true, never>;
+}
+
+declare class FoehnIconFilePdfComponent extends AbstractIconComponent {
+    iconName: _fortawesome_fontawesome_common_types.IconDefinition;
+    defaultTitle: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnIconFilePdfComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnIconFilePdfComponent, "foehn-icon-file-pdf", never, {}, {}, never, never, true, never>;
+}
+
+declare class FoehnIconInfoCircleComponent extends AbstractIconComponent {
+    iconName: _fortawesome_fontawesome_common_types.IconDefinition;
+    defaultTitle: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnIconInfoCircleComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnIconInfoCircleComponent, "foehn-icon-info-circle", never, {}, {}, never, never, true, never>;
+}
+
+declare class FoehnIconLockComponent extends AbstractIconComponent {
+    iconName: _fortawesome_fontawesome_common_types.IconDefinition;
+    defaultTitle: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnIconLockComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnIconLockComponent, "foehn-icon-lock", never, {}, {}, never, never, true, never>;
+}
+
+declare class FoehnIconMapMarkerComponent extends AbstractIconComponent {
+    iconName: _fortawesome_fontawesome_common_types.IconDefinition;
+    defaultTitle: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnIconMapMarkerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnIconMapMarkerComponent, "foehn-icon-map-marker", never, {}, {}, never, never, true, never>;
+}
+
+declare class FoehnIconMinusCircleComponent extends AbstractIconComponent {
+    iconName: _fortawesome_fontawesome_common_types.IconDefinition;
+    defaultTitle: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnIconMinusCircleComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnIconMinusCircleComponent, "foehn-icon-minus-circle", never, {}, {}, never, never, true, never>;
+}
+
+declare class FoehnIconPencilComponent extends AbstractIconComponent {
+    iconName: _fortawesome_fontawesome_common_types.IconDefinition;
+    defaultTitle: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnIconPencilComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnIconPencilComponent, "foehn-icon-pencil", never, {}, {}, never, never, true, never>;
+}
+
+declare class FoehnIconPlusCircleComponent extends AbstractIconComponent {
+    iconName: _fortawesome_fontawesome_common_types.IconDefinition;
+    defaultTitle: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnIconPlusCircleComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnIconPlusCircleComponent, "foehn-icon-plus-circle", never, {}, {}, never, never, true, never>;
+}
+
+declare class FoehnIconPlusSquareComponent extends AbstractIconComponent {
+    iconName: _fortawesome_fontawesome_common_types.IconDefinition;
+    defaultTitle: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnIconPlusSquareComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnIconPlusSquareComponent, "foehn-icon-plus-square", never, {}, {}, never, never, true, never>;
+}
+
+declare class FoehnIconSearchComponent extends AbstractIconComponent {
+    iconName: _fortawesome_fontawesome_common_types.IconDefinition;
+    defaultTitle: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnIconSearchComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnIconSearchComponent, "foehn-icon-search", never, {}, {}, never, never, true, never>;
+}
+
+declare class FoehnIconTimesComponent extends AbstractIconComponent {
+    iconName: _fortawesome_fontawesome_common_types.IconDefinition;
+    defaultTitle: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnIconTimesComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnIconTimesComponent, "foehn-icon-times", never, {}, {}, never, never, true, never>;
+}
+
+declare class FoehnIconTrashAltComponent extends AbstractIconComponent {
+    iconName: _fortawesome_fontawesome_common_types.IconDefinition;
+    defaultTitle: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnIconTrashAltComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnIconTrashAltComponent, "foehn-icon-trash-alt", never, {}, {}, never, never, true, never>;
+}
+
+declare class FoehnIconUnlockAltComponent extends AbstractIconComponent {
+    iconName: _fortawesome_fontawesome_common_types.IconDefinition;
+    defaultTitle: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnIconUnlockAltComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnIconUnlockAltComponent, "foehn-icon-unlock-alt", never, {}, {}, never, never, true, never>;
+}
+
+declare class FoehnIconUserComponent extends AbstractIconComponent {
+    iconName: _fortawesome_fontawesome_common_types.IconDefinition;
+    defaultTitle: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnIconUserComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnIconUserComponent, "foehn-icon-user", never, {}, {}, never, never, true, never>;
+}
+
+declare class PageChangeEvent {
+    previousPage: number;
+    currentPage: number;
+    pageCount: number;
+}
+
+declare class FoehnListComponent implements OnChanges {
+    readonly itemsPerPage: _angular_core.InputSignal<number>;
+    readonly fixedPageCount: _angular_core.InputSignal<number>;
+    readonly list: _angular_core.InputSignal<unknown[]>;
+    readonly id: _angular_core.InputSignal<string>;
+    readonly previousLabel: _angular_core.InputSignal<string>;
+    readonly nextLabel: _angular_core.InputSignal<string>;
+    readonly trackByFn: _angular_core.InputSignal<(index: number, _item: unknown) => number>;
+    templateVariable: _angular_core.Signal<TemplateRef<any>>;
+    readonly pageChange: _angular_core.OutputEmitterRef<PageChangeEvent>;
+    currentPage: number;
+    filteredList: unknown[];
+    ngOnChanges(changes: SimpleChanges): void;
+    previousPage(): void;
+    hasPreviousPage(): boolean;
+    nextPage(): void;
+    hasNextPage(): boolean;
+    showPage(page: number, emitPageChangeEvent?: boolean): void;
+    pagesCount(): number;
+    private buildFilteredList;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnListComponent, "foehn-list", never, { "itemsPerPage": { "alias": "itemsPerPage"; "required": false; "isSignal": true; }; "fixedPageCount": { "alias": "fixedPageCount"; "required": false; "isSignal": true; }; "list": { "alias": "list"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "previousLabel": { "alias": "previousLabel"; "required": false; "isSignal": true; }; "nextLabel": { "alias": "nextLabel"; "required": false; "isSignal": true; }; "trackByFn": { "alias": "trackByFn"; "required": false; "isSignal": true; }; }, { "pageChange": "pageChange"; }, ["templateVariable"], never, true, never>;
+}
+
+declare class FoehnTableColumnConfiguration<T> {
+    id: string;
+    columnLabelKey: string;
+    isImportant?: (item: T) => boolean;
+    iconGetter?: (item: T) => {
+        icon: IconDefinition;
+        label: string;
+    };
+    valueGetter?: (item: T) => string;
+    template?: TemplateRef<unknown>;
+    sortAttribute?: string;
+}
+
+declare class FoehnTablePageChangeEvent {
+    previousPage: number;
+    currentPage: number;
+    pageCount: number;
+}
+
+declare class RowElement {
+    indexInArray: number;
+    element: HTMLTableRowElement;
+}
+
+declare class TableSort {
+    sortDirection: 'DESC' | 'ASC';
+    sortAttribute?: string;
+}
+
+declare class FoehnTableComponent extends FoehnInputComponent<unknown[]> implements OnChanges {
+    readonly columnsConfiguration: _angular_core.ModelSignal<FoehnTableColumnConfiguration<unknown>[]>;
+    readonly itemsPerPage: _angular_core.InputSignal<number>;
+    readonly fixedPageCount: _angular_core.InputSignal<number>;
+    readonly sort: _angular_core.InputSignal<TableSort>;
+    readonly title: _angular_core.InputSignal<string>;
+    readonly totalElements: _angular_core.InputSignal<number>;
+    readonly titleSrOnly: _angular_core.InputSignal<boolean>;
+    readonly previousLabel: _angular_core.InputSignal<string>;
+    readonly nextLabel: _angular_core.InputSignal<string>;
+    readonly tableClass: _angular_core.InputSignal<string>;
+    readonly trackByFn: _angular_core.InputSignal<TrackByFunction<unknown>>;
+    readonly sortChange: _angular_core.OutputEmitterRef<TableSort>;
+    readonly pageChange: _angular_core.OutputEmitterRef<FoehnTablePageChangeEvent>;
+    readonly rowClick: _angular_core.OutputEmitterRef<RowElement>;
+    currentPage: number;
+    filteredList: unknown[];
+    private _list;
+    onModelChange(value: unknown[]): void;
+    trackFoehnTableColumnConfiguration: TrackByFunction<FoehnTableColumnConfiguration<unknown>>;
+    ngOnChanges(changes: SimpleChanges): void;
+    previousPage(): void;
+    hasPreviousPage(): boolean;
+    nextPage(): void;
+    hasNextPage(): boolean;
+    showPage(page: number, emitPageChangeEvent?: boolean): void;
+    pagesCount(): number;
+    triggerSort(sortAttribute: string): void;
+    manageRowClick(rowElem: HTMLTableRowElement, item: unknown): void;
+    private buildFilteredList;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnTableComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnTableComponent, "foehn-table", never, { "columnsConfiguration": { "alias": "columnsConfiguration"; "required": false; "isSignal": true; }; "itemsPerPage": { "alias": "itemsPerPage"; "required": false; "isSignal": true; }; "fixedPageCount": { "alias": "fixedPageCount"; "required": false; "isSignal": true; }; "sort": { "alias": "sort"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "totalElements": { "alias": "totalElements"; "required": false; "isSignal": true; }; "titleSrOnly": { "alias": "titleSrOnly"; "required": false; "isSignal": true; }; "previousLabel": { "alias": "previousLabel"; "required": false; "isSignal": true; }; "nextLabel": { "alias": "nextLabel"; "required": false; "isSignal": true; }; "tableClass": { "alias": "tableClass"; "required": false; "isSignal": true; }; "trackByFn": { "alias": "trackByFn"; "required": false; "isSignal": true; }; }, { "columnsConfiguration": "columnsConfigurationChange"; "sortChange": "sortChange"; "pageChange": "pageChange"; "rowClick": "rowClick"; }, never, ["*"], true, never>;
+}
+
+declare class RegisterNgModelService {
+    private readonly _updateRegisteredNgModelsSubject;
+    private readonly _hasInteractions;
+    get updateRegisteredNgModelsSubject(): Observable<void>;
+    updateRegisteredNgModels(): void;
+    setHasInteractions(value: boolean): void;
+    hasInteractions(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RegisterNgModelService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<RegisterNgModelService>;
+}
+
+declare class FoehnUserConnectedAsComponent implements OnInit {
+    connectedAs: Observable<string>;
+    private sessionInfo;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnUserConnectedAsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnUserConnectedAsComponent, "foehn-user-connected-as", never, {}, {}, never, never, true, never>;
+}
+
+declare const HTTP_LOADER_FILTERED_URL: string[];
+
+declare const OIDC_ENABLED: InjectionToken<boolean>;
+
+declare const RECAPTCHA_API_URL = "api/recaptcha";
+declare const CAPTCHA_ERROR_NAME = "recaptcha";
+declare class RecaptchaService {
+    private http;
+    private sessionInfo;
+    private route;
+    private validationHandlerService;
+    private gesdemService;
+    private gesdemEventService;
+    private readonly applicationInfoService;
+    private readonly sdkLogsService;
+    private readonly errors;
+    private readonly errorsSubject;
+    private readonly shouldDisplay;
+    private readonly publicKey;
+    private readonly captchaScriptUrl;
+    private token;
+    constructor();
+    onSuccess(token: string): void;
+    addError(message: string): void;
+    clearErrors(): void;
+    getErrors(): Observable<FormError[]>;
+    getShouldDisplay(): Observable<boolean>;
+    getPublicKey(): Observable<string>;
+    getToken(): string;
+    getCaptchaScriptUrl(): Observable<string>;
+    private initErrorObservable;
+    private initShouldDisplayObservable;
+    private checkBypassProperty;
+    private initPublicKeyObservable;
+    private initCaptchaScriptUrlObservable;
+    private getPublicKeyOrNull;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RecaptchaService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<RecaptchaService>;
+}
+
+declare global {
+    interface Window {
+        grecaptcha: any;
+        reCaptchaLoad: () => void;
+    }
+}
+/**
+ * Integration with Google Recaptcha.
+ *
+ * All the quirks and weirdness of this integration should be done in this
+ * component.
+ *
+ */
+declare class GrecaptchaComponent implements OnInit, OnDestroy {
+    readonly siteKey: _angular_core.InputSignal<string>;
+    readonly loaded: _angular_core.OutputEmitterRef<boolean>;
+    readonly scriptError: _angular_core.OutputEmitterRef<boolean>;
+    readonly tokenOnSuccess: _angular_core.OutputEmitterRef<string>;
+    readonly destroyed: _angular_core.OutputEmitterRef<boolean>;
+    readonly recaptchaContainer: _angular_core.Signal<ElementRef<any>>;
+    readonly recaptchaScriptContainer: _angular_core.Signal<ElementRef<any>>;
+    private readonly recaptchaService;
+    private readonly sdkLogsService;
+    private readonly destroyRef;
+    private widgetId;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    reset(): void;
+    private renderCaptcha;
+    private appendScriptTag;
+    private removeScript;
+    private loadCaptcha;
+    private safeCaptchaReset;
+    private onError;
+    private onTimeout;
+    private onExpired;
+    private onUnsupported;
+    private getErrorDescription;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GrecaptchaComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GrecaptchaComponent, "app-grecaptcha", never, { "siteKey": { "alias": "siteKey"; "required": false; "isSignal": true; }; }, { "loaded": "loaded"; "scriptError": "scriptError"; "tokenOnSuccess": "tokenOnSuccess"; "destroyed": "destroyed"; }, never, never, true, never>;
+}
+
+declare class SdkRecaptchaComponent implements OnInit, OnDestroy {
+    readonly grecaptcha: _angular_core.Signal<GrecaptchaComponent>;
+    shouldDisplay: Observable<boolean>;
+    isLoaded: boolean;
+    hasLoadingError: boolean;
+    errors: Observable<FormError[]>;
+    publicKey: Observable<string>;
+    recaptchaUrlForUserError: Observable<string>;
+    private recaptchaService;
+    private cdr;
+    private destroyRef;
+    private forceDetectChange;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    setIsLoaded(isLoaded: boolean): void;
+    setScriptError(scriptError: boolean): void;
+    tokenOnSuccess(token: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SdkRecaptchaComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SdkRecaptchaComponent, "captcha", never, {}, {}, never, never, true, never>;
+}
+
+declare class ChunkLoadErrorHandler implements ErrorHandler {
+    private readonly iamExpiredInterceptorService;
+    handleError(error: any): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChunkLoadErrorHandler, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ChunkLoadErrorHandler>;
+}
+
+declare const IAM_ACV_REDIRECT_LOCATION_REGEX: InjectionToken<RegExp>;
+declare const IAM_ACV_OIDC_REDIRECT_LOCATION_REGEX: InjectionToken<RegExp>;
+
+declare class RedirectComponent implements OnDestroy {
+    isModalVisible: Observable<boolean>;
+    counter: number;
+    redirectUrl: string;
+    private iamInterceptor;
+    private foehnPageModalService;
+    private sessionInfo;
+    private registerNgModelService;
+    private intervalId;
+    constructor();
+    ngOnDestroy(): void;
+    reloadPage(): void;
+    private startTimer;
+    private cancelSetInterval;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RedirectComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RedirectComponent, "redirector", never, {}, {}, never, never, true, never>;
+}
+
+declare class FoehnConfirmModalService {
+    private content;
+    private readonly visible;
+    private resolveCallback;
+    private rejectCallback;
+    constructor();
+    getIsVisible(): Observable<boolean>;
+    getContent(): Observable<FoehnConfirmModalContent>;
+    close(): void;
+    ok(): void;
+    openConfirmModal(content: FoehnConfirmModalContent): Promise<boolean>;
+    private reset;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnConfirmModalService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<FoehnConfirmModalService>;
+}
+
+declare class DocumentReference {
+    reference: string;
+    filename: string;
+    key: string;
+    label: string;
+    mimeType: string;
+    fileSize: number;
+    readonly?: boolean;
+}
+declare class DocumentReferenceWithFile extends DocumentReference {
+    file: File;
+}
+
+declare class UploaderHelper {
+    private dictionaryService;
+    private applicationInfoService;
+    private _accept;
+    private _fileMaxSizeInBytesByFormKey;
+    private _maxFileNameLength;
+    private _illegalCharacters;
+    private _fileMinSizeInBytes;
+    private readonly CHAR_TO_REPLACE;
+    private destroyRef;
+    constructor(dictionaryService: SdkDictionaryService, applicationInfoService: ApplicationInfoService);
+    get fileMinSizeInBytes(): number;
+    set fileMinSizeInBytes(value: number);
+    get illegalCharacters(): string;
+    set illegalCharacters(value: string);
+    get maxFileNameLength(): number;
+    set maxFileNameLength(value: number);
+    get accept(): string;
+    set accept(value: string);
+    getMaxFileSizeInBytesForFormKey(formKey: string): number;
+    isFileTooBig(formKey: string, fileSizeInBytes: number): boolean;
+    isFileTooSmall(fileSizeInBytes: number): boolean;
+    isFileNameLengthValid(filename: string, overrideMaxFileNameLength: number): boolean;
+    isFileNameNameValid(filename: string, overrideIllegalCharacters: string): boolean;
+    getFileExtension(filename: string): string;
+    isFileExtensionValid(fileExtension: string, overrideAcceptedExtensions: string): boolean;
+    getUniqueErrorByCode(name: string, errorCode: string, fileName: string, customErrors: Record<string, string>, overrideAcceptedExtensions: string, overrideMaxFileNameLength: number, overrideIllegalCharacters: string): FormError;
+    addCustomErrorOrDefault(name: string, destinationErrors: FormError[], errorCode: string, fileName: string, customErrors: Record<string, string>, overrideAcceptedExtensions: string, overrideMaxFileNameLength: number, overrideIllegalCharacters: string): void;
+    createDefaultCustomErrors(customErrors: Record<string, string>): void;
+    getLocalErrors(name: string, files: File[], customErrors: Record<string, string>, overrideAcceptedExtensions: string, overrideMaxFileNameLength: number, overrideIllegalCharacters: string): FormError[];
+    hasLiveUploadErrors(errors: FormError[]): boolean;
+    preventAndStop(event: any): void;
+    getAllFilesCount(data: any): string;
+    getAllFilesSizeInMo(data: any): string;
+    toMegaOctets(size: number): string;
+    getTransfer(event: any): FileList;
+    getGlobalInfos(data: any): string;
+    showGlobalInfos(data: any, hideGlobalInfos: boolean): boolean;
+    mapToDocumentReference(file: File, label: string, key: string, isMultiple: boolean, uniqPrefix: number, globalSequence: number): DocumentReferenceWithFile;
+    mapToFormData(documents: DocumentReferenceWithFile[], formKey: string, language: string): FormData;
+    removeCommasInLabel(label: string): string;
+    private isTooBig;
+    private replaceErrorMessageKeys;
+    private getDefaultUnknownErrorMessage;
+    private normalizeKey;
+}
+
+interface UploaderRegistration {
+    key: unknown;
+    addedFiles: unknown[];
+    getTotalFilesSize(): number;
+}
+
+declare abstract class AbstractFoehnUploaderComponent<T> extends FoehnInputComponent<T> implements OnInit, UploaderRegistration {
+    readonly showUploadButton: _angular_core.InputSignal<boolean>;
+    readonly readonly: _angular_core.InputSignal<boolean>;
+    readonly hideGlobalInfos: _angular_core.InputSignal<boolean>;
+    readonly multiple: _angular_core.InputSignal<boolean>;
+    readonly key: _angular_core.InputSignal<string>;
+    readonly overrideAcceptedExtensions: _angular_core.InputSignal<string>;
+    readonly overrideMaxFileNameLength: _angular_core.InputSignal<number>;
+    readonly overrideIllegalCharacters: _angular_core.InputSignal<string>;
+    readonly showDeleteConfirmationMessage: _angular_core.InputSignal<boolean>;
+    readonly maxSimultaneousSelectedFiles: _angular_core.InputSignal<number>;
+    readonly maxFilesCount: _angular_core.InputSignal<number>;
+    readonly maxFilesSizeInMo: _angular_core.InputSignal<number>;
+    readonly dragAndDrop: _angular_core.InputSignal<boolean>;
+    readonly shouldDisplayFileSavedConfirmation: _angular_core.InputSignal<boolean>;
+    readonly chooseButtonLabel: _angular_core.InputSignal<string>;
+    readonly chooseButtonLabelMultiple: _angular_core.InputSignal<string>;
+    readonly dropZoneLabel: _angular_core.InputSignal<string>;
+    readonly dropZoneLabelMultiple: _angular_core.InputSignal<string>;
+    readonly deleteConfirmationMessage: _angular_core.InputSignal<string>;
+    uploaderHelper: UploaderHelper;
+    showDropZone: boolean;
+    protected applicationInfoService: ApplicationInfoService;
+    protected confirmModalService: FoehnConfirmModalService;
+    protected dictionaryService: SdkDictionaryService;
+    protected growlService: GrowlBrokerService;
+    protected deleteDocumentSubject: BehaviorSubject<DocumentReference>;
+    protected uploadFilesSubject: BehaviorSubject<File[]>;
+    protected currentLanguage: string;
+    protected readonly resolvedChooseButtonLabel: _angular_core.Signal<string>;
+    protected readonly resolvedChooseButtonLabelMultiple: _angular_core.Signal<string>;
+    protected readonly resolvedDropZoneLabel: _angular_core.Signal<string>;
+    protected readonly resolvedDropZoneLabelMultiple: _angular_core.Signal<string>;
+    protected readonly resolvedDeleteConfirmationMessage: _angular_core.Signal<string>;
+    constructor();
+    abstract get addedFiles(): unknown[];
+    onDocumentDragOver(event: any): void;
+    onDocumentDragLeave(event: any): void;
+    onDocumentDrop(event: any): void;
+    ngOnInit(): void;
+    trackByDocument(index: number, document: DocumentReference): string;
+    removeFile(document: any): void;
+    showGlobalInfos(data: any): boolean;
+    getGlobalInfos(data: any): string;
+    toMegaOctets(size: number): string;
+    onDragenter(event: any): void;
+    onDragleave(event: any): void;
+    onDragover(event: any): void;
+    hasLiveUploadErrors(): boolean;
+    protected removeFileOnConfirmation(document: any): void;
+    protected displayLocalErrors(files: File[]): FormError[];
+    protected isMaxSelectionReached(files: File[]): boolean;
+    protected isMaxFilesCountReached(files: File[]): boolean;
+    protected isMaxFilesSizeReached(files: File[]): boolean;
+    abstract getTotalFilesSize(): number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AbstractFoehnUploaderComponent<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AbstractFoehnUploaderComponent<any>, never, never, { "showUploadButton": { "alias": "showUploadButton"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "hideGlobalInfos": { "alias": "hideGlobalInfos"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "key": { "alias": "key"; "required": false; "isSignal": true; }; "overrideAcceptedExtensions": { "alias": "overrideAcceptedExtensions"; "required": false; "isSignal": true; }; "overrideMaxFileNameLength": { "alias": "overrideMaxFileNameLength"; "required": false; "isSignal": true; }; "overrideIllegalCharacters": { "alias": "overrideIllegalCharacters"; "required": false; "isSignal": true; }; "showDeleteConfirmationMessage": { "alias": "showDeleteConfirmationMessage"; "required": false; "isSignal": true; }; "maxSimultaneousSelectedFiles": { "alias": "maxSimultaneousSelectedFiles"; "required": false; "isSignal": true; }; "maxFilesCount": { "alias": "maxFilesCount"; "required": false; "isSignal": true; }; "maxFilesSizeInMo": { "alias": "maxFilesSizeInMo"; "required": false; "isSignal": true; }; "dragAndDrop": { "alias": "dragAndDrop"; "required": false; "isSignal": true; }; "shouldDisplayFileSavedConfirmation": { "alias": "shouldDisplayFileSavedConfirmation"; "required": false; "isSignal": true; }; "chooseButtonLabel": { "alias": "chooseButtonLabel"; "required": false; "isSignal": true; }; "chooseButtonLabelMultiple": { "alias": "chooseButtonLabelMultiple"; "required": false; "isSignal": true; }; "dropZoneLabel": { "alias": "dropZoneLabel"; "required": false; "isSignal": true; }; "dropZoneLabelMultiple": { "alias": "dropZoneLabelMultiple"; "required": false; "isSignal": true; }; "deleteConfirmationMessage": { "alias": "deleteConfirmationMessage"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class PendingFiles {
+    url: string;
+    formKey: string;
+    label: string;
+    files: File[];
+    key: string;
+    isMultiple: boolean;
+    shouldDisplayFileSavedConfirmation: boolean;
+}
+
+declare class PageUploadLimitService {
+    private dictionaryService;
+    private growlService;
+    private pageMaxFilesCount;
+    private pageMaxFilesSizeInMo;
+    private registeredUploaders;
+    setPageMaxFilesCount(countLimit: number): void;
+    setPageMaxFilesSizeInMo(maxSizeInMo: number): void;
+    registerUploader(uploader: UploaderRegistration): void;
+    unregisterUploader(uploader: UploaderRegistration): void;
+    canUploadMoreFiles(filesToUpload: File[]): boolean;
+    private willTotalCountExceedLimit;
+    private willTotalSizeExceedLimit;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PageUploadLimitService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PageUploadLimitService>;
+}
+
+declare class DocumentError {
+    key: string;
+    label: string;
+    formKey: string;
+    errorCode: string;
+}
+declare class DocumentsWithErrors {
+    documents: DocumentReference[];
+    errors: DocumentError[];
+}
+
+declare class MultiUploadService {
+    private httpClient;
+    private growlService;
+    private gesdemHandlerService;
+    private applicationInfoService;
+    private dictionaryService;
+    private readonly uploadProgressService;
+    private readonly globalUploadProgressService;
+    private globalSequence;
+    private uploaderHelper;
+    private readonly NB_CONCURRENT_FILES_TO_UPLOAD;
+    constructor();
+    uploadDocuments(baseUrl: string, formKey: string, label: string, files: File[], key: string, isMultiple: boolean, language: string, shouldDisplayFileSavedConfirmation: boolean, hasGlobalProgress?: boolean): Observable<DocumentsWithErrors>;
+    deleteDocument(baseUrl: string, document: DocumentReference): Observable<DocumentReference>;
+    getDownloadUrl(baseUrl: string, document: DocumentReference): string;
+    private getDocumentsWithErrorsObservable;
+    private mergeDocumentsWithErrors;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MultiUploadService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MultiUploadService>;
+}
+
+declare class PendingUploadService {
+    private gesdemService;
+    private readonly gesdemEventService;
+    private readonly uploadProgressService;
+    private pendingFilesByFormKey;
+    private attachmentsUploadedSubject;
+    private pendingUploadedErrorsSubject;
+    private uploadExecutors;
+    private destroyRef;
+    constructor();
+    get attachmentsUploaded(): Observable<any>;
+    get pendingUploadedErrors(): Observable<DocumentsWithErrors>;
+    getPendingFiles(formKey: string): File[];
+    hasPendingFiles(formKey?: string): boolean;
+    addPendingFiles(baseUrl: string, formKey: string, label: string, files: File[], key: string, isMultiple: boolean, shouldDisplayFileSavedConfirmation: boolean): void;
+    removePendingFile(file: File, formKey: string): void;
+    registerUploadExecutor(formKey: string, executor: () => Observable<DocumentsWithErrors>): void;
+    unregisterUploadExecutor(formKey: string): void;
+    private uploadPendingFilesAndSaveForm;
+    private executeSingleUpload;
+    private mergePendingUploadedServerResult;
+    private setNestedValue;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PendingUploadService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PendingUploadService>;
+}
+
+declare class FoehnMultiUploadComponent extends AbstractFoehnUploaderComponent<DocumentReference[]> implements OnInit, OnDestroy {
+    readonly url: _angular_core.InputSignal<string>;
+    readonly reference: _angular_core.InputSignal<string>;
+    multiUploadService: MultiUploadService;
+    pendingUploadService: PendingUploadService;
+    protected pageUploadLimitService: PageUploadLimitService;
+    get pendingFiles(): File[];
+    get addedFiles(): File[] | DocumentReference[];
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    trackByPending(index: number, pending: File): string;
+    getTotalFilesSize(): number;
+    canAddMoreFiles(): boolean;
+    onFileChange(event: Event): void;
+    onDrop(event: any): void;
+    protected removeFileOnConfirmation(document: any): void;
+    private populateFileItemList;
+    private displayPendingUploadedErrorsFromServerByFormKey;
+    private displayResultFromServer;
+    private removeDocumentFromModel;
+    private displayErrorsFromServer;
+    private manageSingleFile;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnMultiUploadComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnMultiUploadComponent, "foehn-multi-upload", never, { "url": { "alias": "url"; "required": false; "isSignal": true; }; "reference": { "alias": "reference"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class BoDocumentError {
+    key: string;
+    label: string;
+    formKey: string;
+    errorCode: string;
+}
+declare class BoDocumentsWithErrors {
+    documents: DocumentReference[];
+    errors: BoDocumentError[];
+}
+
+declare class BoMultiUploadService {
+    private httpClient;
+    private growlService;
+    private applicationInfoService;
+    private dictionaryService;
+    private uploadProgressService;
+    private globalSequence;
+    private uploaderHelper;
+    private readonly NB_CONCURRENT_FILES_TO_UPLOAD;
+    constructor();
+    uploadDocuments(url: string, formKey: string, label: string, files: File[], key: string, isMultiple: boolean, language: string, shouldDisplayFileSavedConfirmation: boolean): Observable<BoDocumentsWithErrors>;
+    deleteDocument(baseUrl: string, document: DocumentReference): Observable<DocumentReference>;
+    getDownloadUrl(baseUrl: string, document: DocumentReference): string;
+    private getDocumentsWithErrorsObservable;
+    private mergeDocumentsWithErrors;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BoMultiUploadService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<BoMultiUploadService>;
+}
+
+declare class FoehnBoMultiUploadComponent extends AbstractFoehnUploaderComponent<DocumentReference[]> implements OnInit, OnDestroy {
+    readonly uploadUrl: _angular_core.InputSignal<string>;
+    readonly deleteUrl: _angular_core.InputSignal<string>;
+    readonly downloadUrl: _angular_core.InputSignal<string>;
+    readonly optionalLabelKey: _angular_core.InputSignal<string>;
+    readonly documentDeleted: _angular_core.OutputEmitterRef<DocumentReference>;
+    boMultiUploadService: BoMultiUploadService;
+    protected pageUploadLimitService: PageUploadLimitService;
+    get addedFiles(): DocumentReference[];
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    getTotalFilesSize(): number;
+    canAddMoreFiles(): boolean;
+    onFileChange(event: Event): void;
+    onDrop(event: any): void;
+    private populateFileItemList;
+    private displayResultFromServer;
+    private removeDocumentFromModel;
+    private displayErrorsFromServer;
+    private manageSingleFile;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnBoMultiUploadComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnBoMultiUploadComponent, "foehn-bo-multi-upload", never, { "uploadUrl": { "alias": "uploadUrl"; "required": false; "isSignal": true; }; "deleteUrl": { "alias": "deleteUrl"; "required": false; "isSignal": true; }; "downloadUrl": { "alias": "downloadUrl"; "required": false; "isSignal": true; }; "optionalLabelKey": { "alias": "optionalLabelKey"; "required": false; "isSignal": true; }; }, { "documentDeleted": "documentDeleted"; }, never, ["*"], true, never>;
+}
+
+declare class FoehnPictureUploadComponent extends FoehnInputComponent<DocumentReference[]> implements OnInit {
+    readonly key: _angular_core.InputSignal<string>;
+    readonly baseUrl: _angular_core.InputSignal<string>;
+    readonly croppedPictureFilename: _angular_core.InputSignal<string>;
+    readonly resizeToWidth: _angular_core.InputSignal<number>;
+    readonly resizeToHeight: _angular_core.InputSignal<number>;
+    readonly shouldDisplayFileSavedConfirmation: _angular_core.InputSignal<boolean>;
+    readonly acceptFormats = ".jpeg,.jpg,.png";
+    pictureToCrop: Event;
+    croppedPictureAsBlob: Blob;
+    loading: boolean;
+    protected currentLanguage: string;
+    private uploadService;
+    private dictionaryService;
+    get hasPicture(): boolean;
+    ngOnInit(): void;
+    onPictureSelection(imgEvent: Event): void;
+    onPictureSelectionFailed(): void;
+    onImageCropped(croppedEvent: ImageCroppedEvent): void;
+    resetPictureSelection(): void;
+    savePicture(): void;
+    deleteFile(): void;
+    getDownloadUrl(): string;
+    refreshErrors(results: any[]): void;
+    private isValidFileType;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnPictureUploadComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnPictureUploadComponent, "foehn-picture-upload", never, { "key": { "alias": "key"; "required": false; "isSignal": true; }; "baseUrl": { "alias": "baseUrl"; "required": false; "isSignal": true; }; "croppedPictureFilename": { "alias": "croppedPictureFilename"; "required": false; "isSignal": true; }; "resizeToWidth": { "alias": "resizeToWidth"; "required": false; "isSignal": true; }; "resizeToHeight": { "alias": "resizeToHeight"; "required": false; "isSignal": true; }; "shouldDisplayFileSavedConfirmation": { "alias": "shouldDisplayFileSavedConfirmation"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare abstract class AbstractUploadProgressService {
+    private readonly _showProgress;
+    get showProgress(): BehaviorSubject<boolean>;
+    get showProgressSubject(): Observable<boolean>;
+    abstract manageUploadEventFilter(event: HttpEvent<DocumentsWithErrors>, packageIndex?: number, nbPackages?: number): boolean;
+}
+
+declare class AbstractFoehnGlobalUploadProgressBarComponent {
+    readonly progressBarPanel: _angular_core.Signal<ElementRef<any>>;
+    showProgress: Observable<boolean>;
+    protected uploadProgressService: AbstractUploadProgressService;
+    constructor();
+    private focusOnContainer;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AbstractFoehnGlobalUploadProgressBarComponent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AbstractFoehnGlobalUploadProgressBarComponent, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class GlobalUploadProgressService extends AbstractUploadProgressService {
+    private readonly _globalProgress;
+    private totalBytes;
+    private uploadedBytes;
+    private lastLoaded;
+    get globalProgress(): BehaviorSubject<number>;
+    get globalProgressSubject(): Observable<number>;
+    manageUploadEventFilter(event: HttpEvent<DocumentsWithErrors>): boolean;
+    initGlobalProgress(totalBytes: number): void;
+    completeRequest(): void;
+    forceComplete(): void;
+    private updateGlobalProgress;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GlobalUploadProgressService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<GlobalUploadProgressService>;
+}
+
+declare class FoehnGlobalUploadProgressBarComponent extends AbstractFoehnGlobalUploadProgressBarComponent {
+    globalProgress: Observable<number>;
+    protected uploadProgressService: GlobalUploadProgressService;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnGlobalUploadProgressBarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnGlobalUploadProgressBarComponent, "foehn-global-upload-progress-bar", never, {}, {}, never, never, true, never>;
+}
+
+declare class UploadProgress {
+    loaded: number;
+    total: number;
+    packageIndex?: number;
+    nbPackages?: number;
+}
+
+declare class UploadProgressService extends AbstractUploadProgressService {
+    private _analysisProgressSubject;
+    private readonly _uploadProgressSubject;
+    get analysisProgress(): BehaviorSubject<boolean>;
+    get analysisProgressSubject(): Observable<boolean>;
+    get uploadProgress(): BehaviorSubject<UploadProgress>;
+    get uploadProgressSubject(): Observable<UploadProgress>;
+    manageUploadEventFilter(event: HttpEvent<DocumentsWithErrors>, packageIndex?: number, nbPackages?: number): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UploadProgressService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<UploadProgressService>;
+}
+
+declare class FoehnUploadProgressBarComponent extends AbstractFoehnGlobalUploadProgressBarComponent {
+    readonly progressBarTriggerHtmlElement: _angular_core.InputSignal<HTMLElement>;
+    analysisProgress: Observable<boolean>;
+    currentUploadPercentage: Observable<number>;
+    hasUploadPackages: Observable<boolean>;
+    uploadPackage: Observable<UploadProgress>;
+    protected uploadProgressService: UploadProgressService;
+    private destroyRef;
+    constructor();
+    private calculateProgressPercentage;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnUploadProgressBarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnUploadProgressBarComponent, "foehn-upload-progress-bar", never, { "progressBarTriggerHtmlElement": { "alias": "progressBarTriggerHtmlElement"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class PendingPaymentComponent {
+    readonly onPay: _angular_core.OutputEmitterRef<void>;
+    isModalVisible: boolean;
+    goToPayer(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PendingPaymentComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PendingPaymentComponent, "sdk-pending-payment", never, {}, { "onPay": "onPay"; }, never, never, true, never>;
+}
+
+/**
+ * Composant invisible à insérer dans une page SDK permettant d'effectuer des paiement sur la plateforme de paiement de
+ * Postfinance. La méthode payNow() déclenche le paiement.
+ */
+declare class SdkEpaymentComponent implements OnInit {
+    readonly baseUrl: _angular_core.InputSignal<string>;
+    platformFailureMessageDicoKey: string;
+    failureModalDisplayed: boolean;
+    redirectModalDisplayed: boolean;
+    private ePaymentService;
+    private readonly route;
+    private readonly gesDemService;
+    private readonly gesdemEventService;
+    private readonly registerNgModelService;
+    private window;
+    private failureMessageDicoKeyByCode;
+    ngOnInit(): void;
+    /**
+     * Déclenche le processus de paiement électronique. Le paiement est d'abord préparé avec GesDem, puis on navigue
+     * vers la plateforme de paiement.
+     * @param reference La référence de la demande en cours
+     */
+    payNow(reference: string): void;
+    private handleFailure;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SdkEpaymentComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SdkEpaymentComponent, "epayment-form", never, { "baseUrl": { "alias": "baseUrl"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class EPaymentService {
+    private http;
+    private growlService;
+    /**
+     * Effectuer une requête de préparation du paiement auprès du backend, et obtenir les paramètres de formulaire
+     * en vue du passage sur la plateforme de paiement électronique.
+     * @param ref La référence de la demande en cours
+     * @param baseUrl L'url de base (optionnelle)
+     * @returns la page de paiement sur laquelle rediriger l'utilisateur
+     */
+    createPendingPayment(ref: string, baseUrl: string): Observable<string>;
+    cancelPendingPayment(ref: string, baseUrl: string): void;
+    private handleError;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EPaymentService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<EPaymentService>;
+}
+
+declare class FoehnConfirmModalComponent implements OnInit {
+    isVisible: boolean;
+    private confirmModalService;
+    private destroyRef;
+    constructor();
+    get content(): Observable<FoehnConfirmModalContent>;
+    ngOnInit(): void;
+    cancel(): void;
+    ok(): void;
+    updateVisibilityStatus(status: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnConfirmModalComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnConfirmModalComponent, "foehn-confirm-modal", never, {}, {}, never, never, true, never>;
+}
+
+declare class FoehnHelpModalComponent {
+    readonly modalContent: _angular_core.InputSignal<HelpModal>;
+    readonly draggable: _angular_core.InputSignal<boolean>;
+    readonly hideable: _angular_core.InputSignal<boolean>;
+    readonly modalTrigger: _angular_core.Signal<ElementRef<any>>;
+    readonly content: _angular_core.Signal<ElementRef<any>>;
+    private isVisible;
+    get isModalVisible(): boolean;
+    get currentModalTitle(): string;
+    open(): void;
+    close(): void;
+    closeOnModalClick(): void;
+    updateVisibilityStatus(status: boolean): void;
+    hasContent(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnHelpModalComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnHelpModalComponent, "foehn-help-modal", never, { "modalContent": { "alias": "modalContent"; "required": false; "isSignal": true; }; "draggable": { "alias": "draggable"; "required": false; "isSignal": true; }; "hideable": { "alias": "hideable"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class FoehnModalComponent {
+    readonly isModalVisible: _angular_core.ModelSignal<boolean>;
+    readonly id: _angular_core.InputSignal<string>;
+    readonly modalBodyText: _angular_core.InputSignal<string>;
+    readonly modalHeaderText: _angular_core.InputSignal<string>;
+    readonly closeable: _angular_core.InputSignal<boolean>;
+    readonly draggable: _angular_core.InputSignal<boolean>;
+    readonly hideable: _angular_core.InputSignal<boolean>;
+    readonly modalTriggerHtmlElement: _angular_core.InputSignal<HTMLElement>;
+    readonly name: _angular_core.InputSignal<string>;
+    readonly modalSize: _angular_core.InputSignal<string>;
+    readonly modalBody: _angular_core.Signal<ElementRef<any>>;
+    readonly modalTitle: _angular_core.Signal<ElementRef<any>>;
+    readonly specificfooter: _angular_core.Signal<ElementRef<any>>;
+    readonly modalDefaultCloseBtn: _angular_core.Signal<ElementRef<any>>;
+    private previousIsVisible;
+    private readonly visibilityEffect;
+    handleKeyboardEvent(event: KeyboardEvent): void;
+    private focusOnContainer;
+    private focusOnModalTrigger;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnModalComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnModalComponent, "foehn-modal", never, { "isModalVisible": { "alias": "isModalVisible"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "modalBodyText": { "alias": "modalBodyText"; "required": false; "isSignal": true; }; "modalHeaderText": { "alias": "modalHeaderText"; "required": false; "isSignal": true; }; "closeable": { "alias": "closeable"; "required": false; "isSignal": true; }; "draggable": { "alias": "draggable"; "required": false; "isSignal": true; }; "hideable": { "alias": "hideable"; "required": false; "isSignal": true; }; "modalTriggerHtmlElement": { "alias": "modalTriggerHtmlElement"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "modalSize": { "alias": "modalSize"; "required": false; "isSignal": true; }; }, { "isModalVisible": "isModalVisibleChange"; }, never, ["*", "[modal-footer]"], true, never>;
+}
+
+declare class FoehnPageModalComponent implements OnInit {
+    wrongPublicModalVisible: boolean;
+    formattedPublicsCibles: string[];
+    private sessionInfo;
+    private applicationInfoService;
+    private foehnPageModalService;
+    private userCategories;
+    private publicsCibles;
+    ngOnInit(): void;
+    getFullLoginUrl(): Observable<string>;
+    getAbortUrl(): Observable<string>;
+    getUserCategory(): string;
+    updateVisibilityStatus(status: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnPageModalComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnPageModalComponent, "foehn-page-modal", never, {}, {}, never, never, true, never>;
+}
+
+declare class FoehnTransmitWaitingModalComponent {
+    isTransmit: Observable<boolean>;
+    private transmitModalService;
+    constructor();
+    updateVisibilityStatus(status: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnTransmitWaitingModalComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnTransmitWaitingModalComponent, "foehn-transmit-waiting-modal", never, {}, {}, never, never, true, never>;
+}
+
+declare const TRANSMIT_WAITING_MODAL_DELAY_IN_MILLISECONDS = 2000;
+declare class FoehnTransmitWaitingModalService {
+    private showModalDelayTimer;
+    private toggleModalBehaviorSubject;
+    modalVisibilityObservable(): Observable<boolean>;
+    toggleModalVisibility(isVisible: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnTransmitWaitingModalService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<FoehnTransmitWaitingModalService>;
+}
+
+declare class DateHelper {
+    private locale;
+    private dateFormat;
+    private dateTimeFormat;
+    private datePipe;
+    constructor();
+    private static isValidArray;
+    mapToDateFromNumberArray(object: any, ...fieldsNames: string[]): any;
+    mapAllToDateFromNumberArray(objects: any[], ...fieldsNames: string[]): any[];
+    toDateFromNumberArray(dateInArray: number[]): Date;
+    arrayToDisplayDateDMY(d: number[], showTime: boolean): string | null;
+    toDayjsFromNumberArray(value: number[]): dayjs.Dayjs;
+    isValid(value: number[]): boolean;
+    isToday(value: number[]): boolean;
+    leftPad(num: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DateHelper, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DateHelper>;
+}
+
+declare const CURRENCY_REGEXP: RegExp;
+declare const THOUSANDS_SEPARATOR = "'";
+declare const DECIMALS_SEPARATOR = ".";
+declare function formatNumberAsGiven(value: string): string;
+declare function formatDecimalCurrency(value: string, maxDecimalCount: number, maxLength: number, allowFreeInput: boolean): string;
+declare function formatNonDecimalCurrency(value: string): string;
+declare class CurrencyHelper {
+    formatCurrency(value: number | string, currency?: string, fixedDecimalCount?: number, showZero?: boolean): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CurrencyHelper, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CurrencyHelper>;
+}
+
+declare class NumberCurrencyFormatterDirective implements OnInit {
+    private readonly host;
+    private readonly ngZone;
+    private hasFocus;
+    private readonly formattingEffect;
+    onBlur(event: FocusEvent): void;
+    onFocus(event: FocusEvent): void;
+    onModelChange(value: string): void;
+    ngOnInit(): void;
+    private setFormatting;
+    private hasValueChanged;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NumberCurrencyFormatterDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NumberCurrencyFormatterDirective, "[numberCurrencyFormatter]", never, {}, {}, never, never, true, never>;
+}
+
+declare class IbanFormatterDirective {
+    private readonly host;
+    onBlur(event: FocusEvent): void;
+    private formatIban;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IbanFormatterDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<IbanFormatterDirective, "[ibanFormatter]", never, {}, {}, never, never, true, never>;
+}
+
+declare class IdeFormatterDirective {
+    private readonly host;
+    onBlur(event: FocusEvent): void;
+    /**
+     * Formats ide
+     *
+     * CHE123456789 >> CHE-123.456.789
+     * @param value as ide
+     * @returns string
+     */
+    private formatIde;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdeFormatterDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<IdeFormatterDirective, "[ideFormatter]", never, {}, {}, never, never, true, never>;
+}
+
+declare class NDCFormatterDirective {
+    private readonly host;
+    onBlur(event: FocusEvent): void;
+    /**
+     * Format the tax payer number following this pattern:
+     *
+     * 1 – 9 => X
+     * 10 - 99 => XX
+     * 100 - 999 => X.XX
+     * 1’000 - 9’999 => XX.XX
+     * 10’000 - 99’999 => XXX.XX
+     * 100'000 - 999'999 => X.XXX.XX
+     * 1'000'000 - 9’999'999 => XX.XXX.XX
+     * 10'000'000 - 99'999'999 => XXX.XXX.XX
+     * @param value as numero de contribuable
+     * @returns string
+     */
+    private formatNDC;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NDCFormatterDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NDCFormatterDirective, "[ndcFormatter]", never, {}, {}, never, never, true, never>;
+}
+
+interface FoehnRecapSectionElement {
+    key: string;
+    value: Address | string | number | boolean;
+    acceptEmptyValue?: boolean;
+    /**
+     * An optional Id, will be added on the `dd` DOM element.
+     */
+    id?: string;
+    isComment?: boolean;
+}
+interface FoehnRecapSection {
+    id?: string;
+    titleKey: string;
+    titleLevel?: 'h2' | 'h3' | 'h4' | 'h5' | 'h6';
+    elements: FoehnRecapSectionElement[];
+}
+
+declare class FoehnRecapSectionComponent {
+    readonly acceptEmptyValues: _angular_core.InputSignal<boolean>;
+    readonly data: _angular_core.InputSignal<FoehnRecapSection>;
+    readonly comment: _angular_core.Signal<FoehnRecapSectionElement>;
+    readonly section: _angular_core.Signal<FoehnRecapSection>;
+    cleanValue(element: FoehnRecapSectionElement): any;
+    atLeastOneElementHasContent(data: FoehnRecapSection): boolean;
+    hasContent(element: FoehnRecapSectionElement): boolean;
+    buildId(element: FoehnRecapSectionElement): string;
+    isAddress(element: FoehnRecapSectionElement): boolean;
+    getAddressToDisplay(element: FoehnRecapSectionElement): Address;
+    private formatEmptyValue;
+    private fixLineBreaks;
+    private isSet;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnRecapSectionComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnRecapSectionComponent, "foehn-recap-section", never, { "acceptEmptyValues": { "alias": "acceptEmptyValues"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class GesdemActionRecoveryLoginComponent implements OnInit {
+    readonly reference: _angular_core.InputSignal<string>;
+    readonly redirectTarget: _angular_core.InputSignal<string>;
+    readonly loginForm: _angular_core.Signal<FoehnFormComponent>;
+    readonly recaptchaComponent: _angular_core.Signal<SdkRecaptchaComponent>;
+    demandeNotFound: boolean;
+    rateLimited: boolean;
+    rateLimitCounter: number;
+    otpRecipient: string;
+    otp: string;
+    private recoveryService;
+    private growlService;
+    private confirmModalService;
+    private validationHandler;
+    private applicationInfoService;
+    private gesDemHandlerService;
+    private dictionaryService;
+    private router;
+    private route;
+    private eventsLoggerService;
+    private destroyRef;
+    ngOnInit(): void;
+    validateOtp(): void;
+    getPluralMarker(count: number): string;
+    private startRecovery;
+    private startRateLimitCounter;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GesdemActionRecoveryLoginComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GesdemActionRecoveryLoginComponent, "gesdem-action-recovery-login", never, { "reference": { "alias": "reference"; "required": false; "isSignal": true; }; "redirectTarget": { "alias": "redirectTarget"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class GesdemActionRecoveryRegistrationComponent implements OnInit {
+    readonly dispatchFormErrors: _angular_core.InputSignal<boolean>;
+    readonly continueLaterLabel: _angular_core.InputSignal<string>;
+    readonly continueLaterAlreadyRegisteredLabel: _angular_core.InputSignal<string>;
+    readonly continueLaterConnectedLabel: _angular_core.InputSignal<string>;
+    readonly triggerOnPageChange: _angular_core.InputSignal<boolean>;
+    readonly modalTrigger: _angular_core.Signal<ElementRef<any>>;
+    readonly form: _angular_core.Signal<FoehnFormComponent>;
+    model: RepriseInfo;
+    mailSent: boolean;
+    canContinueLater: Observable<boolean>;
+    isConnectedCyber: Observable<boolean>;
+    currentInfoReprise: Observable<RepriseInfo>;
+    currentEtapeInfo: Observable<EtapeInfo>;
+    draftDemRetentionDays: Observable<number>;
+    draftDemandeDeletionDate: Observable<number[]>;
+    modalTriggerLabel: Observable<string>;
+    private actionRecoveryService;
+    private validationHandler;
+    private foehnPageService;
+    private gesdemEventService;
+    private gesdemService;
+    private appInfoService;
+    private sessionInfoService;
+    private router;
+    private eventsLoggerService;
+    private dictionaryService;
+    private destroyRef;
+    private isVisible;
+    constructor();
+    get isModalVisible(): boolean;
+    get reference(): string;
+    ngOnInit(): void;
+    saveAndOpenModal(): void;
+    openModal(isConnectedCyber: boolean): void;
+    close(): void;
+    sendAndClose(): void;
+    updateVisibilityStatus(status: boolean): void;
+    getPluralMarker(count: number): string;
+    private canContinueLaterForEtape;
+    private clearErrors;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GesdemActionRecoveryRegistrationComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GesdemActionRecoveryRegistrationComponent, "gesdem-action-recovery-registration", never, { "dispatchFormErrors": { "alias": "dispatchFormErrors"; "required": false; "isSignal": true; }; "continueLaterLabel": { "alias": "continueLaterLabel"; "required": false; "isSignal": true; }; "continueLaterAlreadyRegisteredLabel": { "alias": "continueLaterAlreadyRegisteredLabel"; "required": false; "isSignal": true; }; "continueLaterConnectedLabel": { "alias": "continueLaterConnectedLabel"; "required": false; "isSignal": true; }; "triggerOnPageChange": { "alias": "triggerOnPageChange"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class FoehnAbbrComponent {
+    readonly title: _angular_core.InputSignal<string>;
+    readonly text: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnAbbrComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnAbbrComponent, "foehn-abbr", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare abstract class AbstractPageFromMenuComponent<T extends I18nForm> extends AbstractPageComponent<T> implements OnInit {
+    protected confirmModalService: FoehnConfirmModalService;
+    ngOnInit(): void;
+    protected onFormSent(goToNextPage: boolean): void;
+    protected returnToParent(): void;
+    protected appendPageToBreadCrumb(): void;
+    private displayModalErrorConfirmation;
+    protected abstract getMenuPath(): string;
+    protected abstract getMenuLabel(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AbstractPageFromMenuComponent<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AbstractPageFromMenuComponent<any>, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class FoehnListItem {
+    trackingIndex: number;
+    disableEdition?: boolean;
+    disableDeletion?: boolean;
+}
+
+declare abstract class AbstractListDetailPageComponent<FORM_TYPE extends I18nForm, ITEM_TYPE extends FoehnListItem> extends AbstractPageFromMenuComponent<FORM_TYPE> implements OnInit, OnDestroy {
+    list: ITEM_TYPE[];
+    itemIndex: number;
+    protected router: Router;
+    protected location: Location;
+    get itemToEdit(): ITEM_TYPE;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    protected getNextTrackingIndex(): number;
+    protected returnToParent(): void;
+    protected resetBreadCrumb(): void;
+    protected appendPageToBreadCrumb(): void;
+    private loadNewItem;
+    private assignItemIndex;
+    private scrollToSpecifiedElement;
+    private showErrors;
+    abstract getList(): ITEM_TYPE[];
+    abstract getNewListItem(): ITEM_TYPE;
+    abstract getListPagePath(): string;
+    abstract getListPageLabel(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AbstractListDetailPageComponent<any, any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AbstractListDetailPageComponent<any, any>, never, never, {}, {}, never, never, true, never>;
+}
+
+declare abstract class AbstractMenuPageComponent<T extends I18nForm> extends AbstractPageComponent<T> implements AfterViewInit {
+    protected ngZone: NgZone;
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AbstractMenuPageComponent<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AbstractMenuPageComponent<any>, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class FoehnErrorPillComponent {
+    readonly errorPrefix: _angular_core.InputSignal<string | RegExp>;
+    readonly incompleteIndicatorOnly: _angular_core.InputSignal<boolean>;
+    hasErrors: Observable<boolean>;
+    private validationHandlerService;
+    constructor();
+    private matchesErrorPrefix;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnErrorPillComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnErrorPillComponent, "foehn-error-pill", never, { "errorPrefix": { "alias": "errorPrefix"; "required": false; "isSignal": true; }; "incompleteIndicatorOnly": { "alias": "incompleteIndicatorOnly"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface FoehnListItemDescription {
+    label: string;
+    hideIfEmpty?(item: FoehnListItem): boolean;
+    getFormattedValue(item: FoehnListItem): string;
+}
+
+declare class FoehnListSummaryComponent extends FoehnInputComponent<FoehnListItem[]> implements AfterViewInit, OnChanges {
+    readonly getListItemTitle: _angular_core.InputSignal<(item: FoehnListItem) => string>;
+    readonly list: _angular_core.InputSignal<FoehnListItem[]>;
+    readonly listItemDescriptions: _angular_core.InputSignal<FoehnListItemDescription[]>;
+    readonly showAsTable: _angular_core.InputSignal<boolean>;
+    readonly tableActionButtons: _angular_core.Signal<TemplateRef<unknown>>;
+    readonly canAddItems: _angular_core.InputSignal<boolean>;
+    readonly internalList: _angular_core.WritableSignal<FoehnListItem[]>;
+    readonly internalListItemDescriptions: _angular_core.WritableSignal<FoehnListItemDescription[]>;
+    readonly itemRemoved: _angular_core.OutputEmitterRef<void>;
+    readonly itemEdit: _angular_core.OutputEmitterRef<number>;
+    listCopyForTable: FoehnListItem[];
+    tableConfiguration: FoehnTableColumnConfiguration<FoehnListItem>[];
+    tableSort: TableSort;
+    private confirmModalService;
+    private ngZone;
+    trackFoehnListItem: TrackByFunction<FoehnListItem>;
+    trackFoehnListItemDescription: TrackByFunction<FoehnListItemDescription>;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    showLine(item: FoehnListItem, itemParam: FoehnListItemDescription): boolean;
+    editItem(index?: number): void;
+    removeItem(index: number): void;
+    changeSort(sortEvent: TableSort): void;
+    private sortNow;
+    private updateListCopyForTable;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnListSummaryComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnListSummaryComponent, "foehn-list-summary", never, { "getListItemTitle": { "alias": "getListItemTitle"; "required": false; "isSignal": true; }; "list": { "alias": "list"; "required": false; "isSignal": true; }; "listItemDescriptions": { "alias": "listItemDescriptions"; "required": false; "isSignal": true; }; "showAsTable": { "alias": "showAsTable"; "required": false; "isSignal": true; }; "canAddItems": { "alias": "canAddItems"; "required": false; "isSignal": true; }; }, { "itemRemoved": "itemRemoved"; "itemEdit": "itemEdit"; }, never, never, true, never>;
+}
+
+declare class FoehnMenuItemComponent {
+    readonly labelDicoKey: _angular_core.InputSignal<string>;
+    readonly dicoLabelPlaceHolders: _angular_core.InputSignal<PlaceholderType>;
+    readonly linkId: _angular_core.InputSignal<string>;
+    readonly rLink: _angular_core.InputSignal<string>;
+    readonly queryParamsHandling: _angular_core.InputSignal<QueryParamsHandling>;
+    readonly errorPrefix: _angular_core.InputSignal<string | RegExp>;
+    readonly listLength: _angular_core.InputSignal<number>;
+    readonly applicable: _angular_core.InputSignal<boolean>;
+    readonly showErrorPill: _angular_core.InputSignal<boolean>;
+    get nonApplicableId(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnMenuItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnMenuItemComponent, "foehn-menu-item", never, { "labelDicoKey": { "alias": "labelDicoKey"; "required": false; "isSignal": true; }; "dicoLabelPlaceHolders": { "alias": "dicoLabelPlaceHolders"; "required": false; "isSignal": true; }; "linkId": { "alias": "linkId"; "required": false; "isSignal": true; }; "rLink": { "alias": "rLink"; "required": false; "isSignal": true; }; "queryParamsHandling": { "alias": "queryParamsHandling"; "required": false; "isSignal": true; }; "errorPrefix": { "alias": "errorPrefix"; "required": false; "isSignal": true; }; "listLength": { "alias": "listLength"; "required": false; "isSignal": true; }; "applicable": { "alias": "applicable"; "required": false; "isSignal": true; }; "showErrorPill": { "alias": "showErrorPill"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class FoehnMenuItemTransmitComponent {
+    readonly linkId: _angular_core.InputSignal<string>;
+    readonly rLink: _angular_core.InputSignal<string>;
+    readonly labelDicoKey: _angular_core.InputSignal<string>;
+    readonly dicoLabelPlaceHolders: _angular_core.InputSignal<PlaceholderType>;
+    readonly remainingErrorNamesToIgnore: _angular_core.InputSignal<string[]>;
+    readonly remainingErrorsAlertTitle: _angular_core.InputSignal<string>;
+    readonly remainingErrorsAlertBody: _angular_core.InputSignal<string>;
+    readonly clickedWithRemainingErrors: _angular_core.OutputEmitterRef<number>;
+    showRemainingErrorsAlert: boolean;
+    private router;
+    private activatedRoute;
+    private gesdemService;
+    transmit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnMenuItemTransmitComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnMenuItemTransmitComponent, "foehn-menu-item-transmit", never, { "linkId": { "alias": "linkId"; "required": false; "isSignal": true; }; "rLink": { "alias": "rLink"; "required": false; "isSignal": true; }; "labelDicoKey": { "alias": "labelDicoKey"; "required": false; "isSignal": true; }; "dicoLabelPlaceHolders": { "alias": "dicoLabelPlaceHolders"; "required": false; "isSignal": true; }; "remainingErrorNamesToIgnore": { "alias": "remainingErrorNamesToIgnore"; "required": false; "isSignal": true; }; "remainingErrorsAlertTitle": { "alias": "remainingErrorsAlertTitle"; "required": false; "isSignal": true; }; "remainingErrorsAlertBody": { "alias": "remainingErrorsAlertBody"; "required": false; "isSignal": true; }; }, { "clickedWithRemainingErrors": "clickedWithRemainingErrors"; }, never, never, true, never>;
+}
+
+declare class DayMonth {
+    date: dayjs.Dayjs;
+    dateAsString: string;
+    dateAsReadable: string;
+    dayOfMonth: number;
+    isCurrentMonth: boolean;
+}
+
+declare class MonthYear {
+    year: string;
+    month: string;
+}
+
+declare class DatePickerHelper {
+    initialMonth: string;
+    initialYear: string;
+    initialDay: string;
+    readonly YEAR_STRING_FORMAT = "YYYY";
+    readonly MONTH_STRING_NUMBER_FORMAT = "M";
+    readonly DAY_STRING_NUMBER_FORMAT = "D";
+    private readonly NB_DAYS_IN_WEEK;
+    private readonly DATE_STRING_FORMAT;
+    private readonly DATE_READABLE_FORMAT;
+    private _displayedMonthYear;
+    get displayedMonthYear(): Observable<MonthYear>;
+    static getDateAsString(date: number[]): string;
+    private static getWeekday;
+    private static getNumberOfDaysInMonth;
+    private static getPreviousMonth;
+    private static getNextMonth;
+    loadLocale: (language: string) => Promise<void>;
+    getWeekDays(): string[];
+    getWeeksOfMonth(initialYear: string, initialMonth: string, initialDay?: string): DayMonth[][];
+    getNextWeeksOfMonth(): DayMonth[][];
+    getPreviousWeeksOfMonth(): DayMonth[][];
+    private createDaysForCurrentMonth;
+    private createDaysForPreviousMonth;
+    private createDaysForNextMonth;
+    private buildWeeksOfMonth;
+}
+
+declare class DatePickerNavigationHelper {
+    private _currentFocusedElement;
+    private _daysButtonsElemRef;
+    private _hostId;
+    private pendingDaysButtonsUpdateAction;
+    private _displayNextMonth;
+    private _displayPreviousMonth;
+    get displayNextMonth(): Observable<void>;
+    get displayPreviousMonth(): Observable<void>;
+    set currentFocusedElement(elem: Element);
+    set daysButtonsElemRef(elems: readonly ElementRef[]);
+    set hostId(id: string);
+    private static convertElementToFocusedDay;
+    private static focusPreviousMonthButton;
+    private static focusNextMonthButton;
+    focusDefaultDay(hasSelectedDay: boolean): void;
+    focusNextDay(): void;
+    focusPreviousDay(): void;
+    focusNextWeekDay(): void;
+    focusPreviousWeekDay(): void;
+    private flushPendingDaysButtonsUpdateAction;
+    private getEnabledDaysOfWeek;
+    private getAllDaysInColumn;
+    private getEnabledDaysInColumn;
+    private getCurrentFocusedIndex;
+}
+
+declare class FocusedDay {
+    disabled: boolean;
+    indexDay: number;
+    indexRow: number;
+    indexColumn: number;
+}
+
+declare class FoehnDatePickerComponent implements OnInit {
+    hostId: string;
+    readonly daysButtonsElemRef: _angular_core.Signal<readonly ElementRef<any>[]>;
+    readonly model: _angular_core.ModelSignal<number[]>;
+    readonly isDatepickerVisible: _angular_core.ModelSignal<boolean>;
+    readonly id: _angular_core.InputSignal<string>;
+    readonly minDate: _angular_core.InputSignal<number[]>;
+    readonly maxDate: _angular_core.InputSignal<number[]>;
+    readonly datepickerTriggerHtmlElement: _angular_core.InputSignal<HTMLElement>;
+    readonly closeable: _angular_core.InputSignal<boolean>;
+    readonly name: _angular_core.InputSignal<string>;
+    readonly minYear: _angular_core.InputSignal<number>;
+    readonly maxYear: _angular_core.InputSignal<number>;
+    readonly userInput: _angular_core.OutputEmitterRef<number[]>;
+    readonly minYearComputed: _angular_core.Signal<number>;
+    readonly maxYearComputed: _angular_core.Signal<number>;
+    readonly yearListItem: _angular_core.Signal<FormSelectOption[]>;
+    weekDays: string[];
+    weeks: DayMonth[][];
+    selectedDate: dayjs.Dayjs;
+    currentMonthYear: Observable<MonthYear>;
+    model_: number[];
+    monthListItem: FormSelectOption[];
+    private dictionary;
+    private ngZone;
+    private changeDetector;
+    private destroyRef;
+    private previousIsVisible;
+    private keyboardNavigationAllowed;
+    private datePickerHelper;
+    private datePickerNavigationHelper;
+    /**
+     * effect() — side effect
+     * Quand un changement de signal doit déclencher quelque chose en dehors du graphe de signals : DOM, localStorage, log, appel externe...
+     */
+    private readonly isDatepickerVisibleEffect;
+    private readonly daysButtonsElemRefEffect;
+    private readonly modelEffect;
+    constructor();
+    handleKeyboardUpEvent(event: KeyboardEvent): void;
+    handleKeyboardDownEvent(event: KeyboardEvent): void;
+    ngOnInit(): void;
+    onModelChange(value: number[]): void;
+    updateNgModel(value: number[]): void;
+    buildId(suffix?: string): string;
+    isToday(date: dayjs.Dayjs): boolean;
+    isSelected(date: dayjs.Dayjs): boolean;
+    handleUserInput(date: dayjs.Dayjs): void;
+    previousMonth(): void;
+    nextMonth(): void;
+    userInputMonth(month: string): void;
+    userInputYear(year: string): void;
+    getMonthAsReadable(monthIndex: string): string;
+    onDaysFocusin(): void;
+    onDaysFocusout(): void;
+    getDayTabIndex(day: DayMonth): number;
+    focusDefaultDay(): void;
+    getDayDisabledAttribute(dayOfWeek: DayMonth): string;
+    isPreviousMonthDisabled(monthYear: MonthYear): string;
+    isNextMonthDisabled(monthYear: MonthYear): string;
+    private isDateInRange;
+    private initializeDatepicker;
+    private setDate;
+    private getDateAsArray;
+    private focusOnDatepickerTrigger;
+    private populateMonthList;
+    private onKeyDownInner;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnDatePickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnDatePickerComponent, "foehn-date-picker", never, { "model": { "alias": "model"; "required": false; "isSignal": true; }; "isDatepickerVisible": { "alias": "isDatepickerVisible"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; "datepickerTriggerHtmlElement": { "alias": "datepickerTriggerHtmlElement"; "required": false; "isSignal": true; }; "closeable": { "alias": "closeable"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "minYear": { "alias": "minYear"; "required": false; "isSignal": true; }; "maxYear": { "alias": "maxYear"; "required": false; "isSignal": true; }; }, { "model": "modelChange"; "isDatepickerVisible": "isDatepickerVisibleChange"; "userInput": "userInput"; }, never, never, true, never>;
+}
+
+declare class FoehnDatePickerButtonComponent implements OnInit {
+    hostId: string;
+    readonly model: _angular_core.ModelSignal<number[]>;
+    readonly id: _angular_core.InputSignal<string>;
+    readonly displaySelectedDate: _angular_core.InputSignal<boolean>;
+    readonly name: _angular_core.InputSignal<string>;
+    readonly minYear: _angular_core.InputSignal<number>;
+    readonly maxYear: _angular_core.InputSignal<number>;
+    readonly minDate: _angular_core.InputSignal<number[]>;
+    readonly maxDate: _angular_core.InputSignal<number[]>;
+    readonly selectedDateSrOnlyLabelKey: _angular_core.InputSignal<string>;
+    readonly datepickerTrigger: _angular_core.Signal<ElementRef<any>>;
+    readonly userInput: _angular_core.OutputEmitterRef<number[]>;
+    model_: number[];
+    private isVisible;
+    private readonly modelEffect;
+    get isDatepickerVisible(): boolean;
+    ngOnInit(): void;
+    buildId(suffix?: string): string;
+    open(): void;
+    close(): void;
+    updateVisibilityStatus(status: boolean): void;
+    onModelChange(value: number[]): void;
+    updateNgModel(value: number[]): void;
+    handleUserInput(date: number[]): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnDatePickerButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnDatePickerButtonComponent, "foehn-date-picker-button", never, { "model": { "alias": "model"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "displaySelectedDate": { "alias": "displaySelectedDate"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "minYear": { "alias": "minYear"; "required": false; "isSignal": true; }; "maxYear": { "alias": "maxYear"; "required": false; "isSignal": true; }; "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; "selectedDateSrOnlyLabelKey": { "alias": "selectedDateSrOnlyLabelKey"; "required": false; "isSignal": true; }; }, { "model": "modelChange"; "userInput": "userInput"; }, never, never, true, never>;
+}
+
+declare class FoehnDecisionElectroniqueComponent extends FoehnInputComponent<boolean> {
+    readonly id: _angular_core.InputSignal<string>;
+    readonly name: _angular_core.InputSignal<string>;
+    isConnectedCyber: Observable<boolean>;
+    private sessionInfo;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnDecisionElectroniqueComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnDecisionElectroniqueComponent, "foehn-decision-electronique", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class DemandeHelper {
+    static getSafeReference(reference: string): string;
+}
+
+declare class ObjectHelper {
+    /**
+     * Angular uses object identity to select option. It's possible for the identities of items to change while the data does not.
+     * This can happen, for example, if the items are produced from an RPC to the server, and that RPC is re-run.
+     * Even if the data hasn't changed, the second response will produce objects with different identities.
+     * (see: https://angular.io/api/forms/SelectControlValueAccessor#customizing-option-selection)
+     * @param value1 as first value to compare to
+     * @param value2 as value to be compared to
+     * @param skipFunctionTypeCompare boolean (default true) (when set to false compares functions)
+     * @returns boolean
+     */
+    static isEqual(value1: unknown, value2: unknown, skipFunctionTypeCompare?: boolean): boolean;
+    static isDifferent(value1: unknown, value2: unknown, skipFunctionType?: boolean): boolean;
+    static hasAnyValue(value: any): boolean;
+    static isEmpty(value: any): boolean;
+    /**
+     * Deep copy is a true copy for nested objects
+     * Often, shallow copy is good enough and you will not need a deep copy.
+     * A shallow copy means the first level is copied, deeper levels are referenced.
+     *
+     * Examples of shallow copy :
+     * const shallowClone = { ...nestedObject };
+     * const shallowClone = Object.assign({}, nestedObject);
+     * @param obj is the object to copied
+     * @returns obj
+     */
+    static deepCopy(obj: any): any;
+    static stripHtml(html: string): string;
+    static getNestedProperty(obj: any, key: string): any;
+}
+
+declare class ScrollHelper {
+    static scrollIntoViewWithExpirationTimerOffset(elementContainer: Element): void;
+}
+
+declare class StringHelper {
+    private static readonly REGEX_TO_ESCAPE_REGEX;
+    static stripHtmlTags(value: string): string;
+    static normalizeUtf8(value: string): string;
+    static normalizeSearch(value: string, caseSensitiveSearch: boolean): string;
+    static escapeRegExp(value: string): string;
+    static toSafeIdFragment(value: string): string;
+    static replaceLineBreaksWithBr(value: string): string;
+}
+
+declare class AddressTypeLight {
+    id: string;
+    egid: string;
+    number: string;
+}
+
+declare class Canton {
+    code: string;
+    label: string;
+}
+
+declare class District {
+    districtHistId: string;
+    cantonId: string;
+    districtId: string;
+    districtLongName: string;
+    districtShortName: string;
+}
+
+declare class Municipality {
+    id: number;
+    name: string;
+    canton: string;
+    districtHistId: string;
+    districtId: string;
+    historyMunicipalityId: string;
+    municipalityEntryMode: string;
+}
+
+declare class PlaceOfOrigin {
+    canton: string;
+    historyMunicipalityId: number;
+    placeOfOriginId: string;
+    name: string;
+    successorId: string;
+    validFrom: number[];
+    validTo: number[];
+}
+
+declare class PostalLocality {
+    id: string;
+    zipCode: string;
+    zipCodeAddOn: string;
+    zipCodeId: number;
+    name: string;
+    municipalityId: number;
+    canton: Canton;
+    zipCodeType: string;
+}
+
+declare class DaySlots {
+    day: string;
+    date: number[];
+    timeSlots: string[];
+}
+
+declare class PaginationWeek {
+    label: string;
+    weekNumber: number;
+    year: number;
+}
+
+declare class CurrentWeek extends PaginationWeek {
+    week: DaySlots[];
+}
+
+declare class Calendar {
+    previousWeek: PaginationWeek;
+    currentWeek: CurrentWeek;
+    nextWeek: PaginationWeek;
+    minAvailableDate: number[];
+    maxAvailableDate: number[];
+}
+
+declare class SelectedSlot {
+    day: string;
+    time: string;
+    year: number;
+    weekNumber: number;
+    date: number[];
+}
+
+declare class FoehnAgendaTimeslotPanelComponent extends FoehnInputComponent<SelectedSlot> implements OnChanges {
+    readonly DEFAULT_NB_VISIBLE_ELEMENTS = 22;
+    readonly calendar: _angular_core.InputSignal<Observable<Calendar>>;
+    readonly currentWeek: _angular_core.InputSignal<DaySlots>;
+    readonly nbVisibleElements: _angular_core.InputSignal<number>;
+    readonly visibleElementsCount: _angular_core.Signal<number>;
+    readonly timeSlotButtonsElemRef: _angular_core.Signal<readonly ElementRef<any>[]>;
+    selectedTimeSlot: string;
+    timeSlots: string[];
+    isClosed: boolean;
+    timeslotRemaining: number;
+    timeInputValue: string;
+    canClose: boolean;
+    private dictionaryService;
+    private dayInputValue;
+    private keyboardNavigationAllowed;
+    private currentActiveElement;
+    private hasSelectedSlotInPanel;
+    constructor();
+    ngOnChanges(changes: SimpleChanges): void;
+    handleKeyboardDownEvent(event: KeyboardEvent): void;
+    focus(): void;
+    capitalCaseFirstLetter(s: string): string;
+    handleUserInput(day: string, date: number[], time: string, calendar: Calendar): void;
+    togglePanel(): void;
+    onModelChange(value: SelectedSlot): void;
+    getTimeInputValue(s: string): string;
+    searchTimeValueInTimeSlot(): void;
+    onTimeFocusin(): void;
+    onTimeFocusout(): void;
+    isSelected(timeSlot: string): boolean;
+    getButtonTimeSlotAriaLabel(day: string, timeSlot: string): string;
+    getTimeSlotTabIndex(timeSlot: string, index: number): number;
+    cleanIdForQuerySelector(s: string): string;
+    private sliceNbVisibleElements;
+    private getValidValue;
+    private onKeyDownInner;
+    private focusTimeSlot;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnAgendaTimeslotPanelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnAgendaTimeslotPanelComponent, "foehn-agenda-timeslot-panel", never, { "calendar": { "alias": "calendar"; "required": false; "isSignal": true; }; "currentWeek": { "alias": "currentWeek"; "required": false; "isSignal": true; }; "nbVisibleElements": { "alias": "nbVisibleElements"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class FoehnAgendaComponent extends FoehnInputComponent<SelectedSlot> {
+    readonly calendar: _angular_core.InputSignal<Observable<Calendar>>;
+    readonly nbVisibleElements: _angular_core.InputSignal<number>;
+    readonly paginationChange: _angular_core.OutputEmitterRef<PaginationWeek>;
+    readonly readableSelectedTimeSlot: _angular_core.Signal<string>;
+    readonly timeSlotPanelsElemRef: _angular_core.Signal<readonly FoehnAgendaTimeslotPanelComponent[]>;
+    srAnnouncements: string;
+    private dictionaryService;
+    private srAnnouncementClearTimer;
+    private readonly SR_ANNOUNCEMENT_CLEAR_TIMEOUT_INTERVAL_MS;
+    private static cleanIdForQuerySelector;
+    focus(): void;
+    paginate(paginationWeek: PaginationWeek): void;
+    handleUserInput(selectedTimeSlot: SelectedSlot): void;
+    scrollToNavigation(isTop: boolean): void;
+    private manageScreenReaderAnnouncement;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnAgendaComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnAgendaComponent, "foehn-agenda", never, { "calendar": { "alias": "calendar"; "required": false; "isSignal": true; }; "nbVisibleElements": { "alias": "nbVisibleElements"; "required": false; "isSignal": true; }; }, { "paginationChange": "paginationChange"; }, never, ["*"], true, never>;
+}
+
+declare class FoehnAgendaNavigationComponent implements OnChanges {
+    readonly id: _angular_core.InputSignal<string>;
+    readonly calendar: _angular_core.InputSignal<Calendar>;
+    readonly isSrOnly: _angular_core.InputSignal<boolean>;
+    readonly minDate: _angular_core.InputSignal<number[]>;
+    readonly maxDate: _angular_core.InputSignal<number[]>;
+    readonly paginationChange: _angular_core.OutputEmitterRef<PaginationWeek>;
+    currentDay: number[];
+    private overrideWithCalendarDate;
+    private static getCurrentDateAsArray;
+    ngOnChanges(changes: SimpleChanges): void;
+    paginate(paginationWeek: PaginationWeek): void;
+    datePickerUserInput(selectedDate: number[]): void;
+    private onCalendarChange;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnAgendaNavigationComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnAgendaNavigationComponent, "foehn-agenda-navigation", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "calendar": { "alias": "calendar"; "required": false; "isSignal": true; }; "isSrOnly": { "alias": "isSrOnly"; "required": false; "isSignal": true; }; "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; }, { "paginationChange": "paginationChange"; }, never, never, true, never>;
+}
+
+interface Position {
+    left: number;
+    top: number;
+}
+declare class FoehnDropdownMenuComponent implements OnInit {
+    hostId: string;
+    readonly id: _angular_core.InputSignal<string>;
+    readonly label: _angular_core.InputSignal<string>;
+    readonly model: _angular_core.InputSignal<DropdownMenuGroup[]>;
+    readonly btnCssClass: _angular_core.InputSignal<string>;
+    readonly selectedFocusList: _angular_core.Signal<readonly ElementRef<any>[]>;
+    readonly buttonTrigger: _angular_core.Signal<ElementRef<any>>;
+    readonly entryPoint: _angular_core.Signal<ElementRef<any>>;
+    isDropdownVisible: boolean;
+    closeDropdownTimer: any;
+    popupPosition: Position;
+    private router;
+    private currentItemGlobalIndex;
+    private shouldFocusEntryPointAfterOpen;
+    private readonly selectedFocusListEffect;
+    constructor();
+    handleKeyboardUpEvent(event: KeyboardEvent): void;
+    handleKeyboardDownEvent(event: KeyboardEvent): void;
+    ngOnInit(): void;
+    handleFocusIn(): void;
+    handleFocusOut(): void;
+    buildId(suffix?: string): string;
+    toggleDropdownVisibility(): void;
+    resetDropdown(): void;
+    private onKeyDownInner;
+    private focusNextElement;
+    private focusFirstElement;
+    private focusLastElement;
+    private selectCurrentFocusItem;
+    private elementsDisplayed;
+    private calculatePopupPosition;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnDropdownMenuComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnDropdownMenuComponent, "foehn-dropdown-menu", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "model": { "alias": "model"; "required": false; "isSignal": true; }; "btnCssClass": { "alias": "btnCssClass"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class FoehnFeedbackNotificationType {
+    answer: string;
+    idMetierEtape: string;
+    isConnected: boolean;
+    beneficiaryCategory: string;
+    currentAction: number;
+    isBehindIAM: boolean;
+}
+
+declare const FEEDBACK_USAGERS_LOCAL_STORAGE_PREFIX = "FEEDBACK-USAGERS-";
+declare class FoehnFeedbackNotificationComponent {
+    goodIconName: _fortawesome_fontawesome_common_types.IconDefinition;
+    mediumIconName: _fortawesome_fontawesome_common_types.IconDefinition;
+    badIconName: _fortawesome_fontawesome_common_types.IconDefinition;
+    expanded: boolean;
+    isScrollEnded: boolean;
+    visible: Observable<boolean>;
+    goodUrl: Observable<string>;
+    mediumUrl: Observable<string>;
+    badUrl: Observable<string>;
+    private applicationInfoService;
+    private sessionInfo;
+    private gesdemHandlerService;
+    private http;
+    constructor();
+    onWindowScroll(): void;
+    hideNotification(): void;
+    getUrl(answer: string, feedbackUsager: FoehnFeedbackNotificationType, feedBackFormBaseUrl: string, reference: string): Observable<string>;
+    private getCategory;
+    private getPortailBaseUrl;
+    private getFullReference;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnFeedbackNotificationComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnFeedbackNotificationComponent, "foehn-feedback-notification", never, {}, {}, never, never, true, never>;
+}
+
+declare enum SdkLogLevel {
+    INFO = "INFO",
+    WARN = "WARN",
+    ERROR = "ERROR"
+}
+
+declare class SdkLog {
+    logLevel: SdkLogLevel;
+    message: string;
+}
+
+interface BrowserInfo {
+    name: string;
+    version: string;
+    platform: string;
+}
+declare class SdkLogsService {
+    private readonly http;
+    private cachedBrowserInfo;
+    addLog(message: string, logLevel: SdkLogLevel): void;
+    addLogWithError(message: string, logLevel: SdkLogLevel, error: unknown): void;
+    private prepareLogMessage;
+    private getBrowserInfo;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SdkLogsService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SdkLogsService>;
+}
+
+export { APP_INFO_API_URL, AbstractFoehnUploaderComponent, AbstractListDetailPageComponent, AbstractMenuPageComponent, AbstractPageComponent, AbstractPageFromMenuComponent, ActionStatut, Address, AddressTypeLight, ApplicationInfo, ApplicationInfoService, BAD_PARAMS_HELP_TEXT, BoDocumentError, BoDocumentsWithErrors, BoMultiUploadService, Breadcrumb, BreadcrumbEventService, BreadcrumbItem, CAPTCHA_ERROR_NAME, CURRENCY_REGEXP, Calendar, Canton, Captcha, ChunkLoadErrorHandler, ComponentError, Configuration, Country, CurrencyHelper, CurrentWeek, DECIMALS_SEPARATOR, DEFAULT_INTERNATIONAL_AND_NO_SWISS, DEFAULT_INTERNATIONAL_AND_NO_SWISS_MOBILE, DEFAULT_INTERNATIONAL_AND_NO_SWISS_PHONE, DEFAULT_INTERNATIONAL_HELP_TEXT, DEFAULT_PREFIX, DEFAULT_SWISS_HELP_TEXT, DEFAULT_SWISS_MOBILE_PHONE_HELP_TEXT, DEFAULT_SWISS_PHONE_HELP_TEXT, DICTIONARY_BASE_URL, DateHelper, DatePickerHelper, DatePickerNavigationHelper, DayMonth, DaySlots, DemandeExpirationService, DemandeHelper, DisplayCurrencyPipe, DisplayDatePipe, District, Document, DocumentError, DocumentReference, DocumentReferenceWithFile, DocumentsWithErrors, DropdownMenuGroup, DropdownMenuItem, EPaymentService, EtapeInfo, FEEDBACK_USAGERS_LOCAL_STORAGE_PREFIX, FORM_SUPPORT_CYBER_TITLE_FALLBACK, FocusedDay, FoehnAbbrComponent, FoehnAgendaComponent, FoehnAgendaNavigationComponent, FoehnAgendaTimeslotPanelComponent, FoehnAutocompleteComponent, FoehnBoMultiUploadComponent, FoehnBooleanCheckboxComponent, FoehnBooleanRadioComponent, FoehnBreadcrumbComponent, FoehnCheckableGroupComponent, FoehnCheckboxComponent, FoehnConfirmModalComponent, FoehnConfirmModalContent, FoehnConfirmModalService, FoehnDateComponent, FoehnDatePickerButtonComponent, FoehnDatePickerComponent, FoehnDateTimeComponent, FoehnDecisionElectroniqueComponent, FoehnDisplayAddressComponent, FoehnDropdownMenuComponent, FoehnErrorPillComponent, FoehnFeedbackNotificationComponent, FoehnFormComponent, FoehnGlobalUploadProgressBarComponent, FoehnHeaderComponent, FoehnHelpModalComponent, FoehnIconCalendarComponent, FoehnIconCheckComponent, FoehnIconCheckSquareOComponent, FoehnIconChevronDownComponent, FoehnIconChevronLeftComponent, FoehnIconChevronRightComponent, FoehnIconChevronUpComponent, FoehnIconClockComponent, FoehnIconCommentDotsComponent, FoehnIconEditComponent, FoehnIconExternalLinkAltComponent, FoehnIconFilePdfComponent, FoehnIconInfoCircleComponent, FoehnIconLockComponent, FoehnIconMapMarkerComponent, FoehnIconMinusCircleComponent, FoehnIconPencilComponent, FoehnIconPlusCircleComponent, FoehnIconPlusSquareComponent, FoehnIconSearchComponent, FoehnIconTimesComponent, FoehnIconTrashAltComponent, FoehnIconUnlockAltComponent, FoehnIconUserComponent, FoehnInputAddressComponent, FoehnInputComponent, FoehnInputEmailComponent, FoehnInputForeignLocalityComponent, FoehnInputForeignStreetComponent, FoehnInputHiddenComponent, FoehnInputNav13Component, FoehnInputNumberComponent, FoehnInputPasswordComponent, FoehnInputPhoneComponent, FoehnInputPrefixedTextComponent, FoehnInputStringComponent, FoehnInputTextComponent, FoehnInputTextareaComponent, FoehnListComponent, FoehnListItem, FoehnListSummaryComponent, FoehnMenuItemComponent, FoehnMenuItemTransmitComponent, FoehnModalComponent, FoehnMultiUploadComponent, FoehnMultiselectAutocompleteComponent, FoehnNavigationComponent, FoehnNavigationService, FoehnNotfoundComponent, FoehnPageComponent, FoehnPageCounterComponent, FoehnPageExpirationTimerComponent, FoehnPageModalComponent, FoehnPageService, FoehnPictureUploadComponent, FoehnRadioComponent, FoehnRecapSectionComponent, FoehnRemainingAlertsSummaryComponent, FoehnSelectComponent, FoehnSimpleNavigationComponent, FoehnSkipLinkComponent, FoehnStatusProgressBarComponent, FoehnTableColumnConfiguration, FoehnTableComponent, FoehnTablePageChangeEvent, FoehnTimeComponent, FoehnTransmitWaitingModalComponent, FoehnTransmitWaitingModalService, FoehnUploadProgressBarComponent, FoehnUserConnectedAsComponent, FoehnValidationAlertSummaryComponent, FoehnValidationAlertsComponent, FooterLink, FormMetadata, FormPostResponse, FormSelectOption, FormatIdePipe, GESDEM_MAX_DATA_LENGTH, GesdemActionRecoveryLoginComponent, GesdemActionRecoveryRegistrationComponent, GesdemConfirmationComponent, GesdemErrorComponent, GesdemEventService, GesdemHandlerService, GesdemStatutUtils, GlobalUploadProgressService, GrowlBrokerService, GrowlMessage, GrowlType, HTTP_LOADER_FILTERED_URL, I18nForm, IAM_ACV_OIDC_REDIRECT_LOCATION_REGEX, IAM_ACV_REDIRECT_LOCATION_REGEX, IbanFormatterDirective, IdeFormatterDirective, IntervalHelper, Locality, MonthYear, MultiUploadService, Municipality, NDCFormatterDirective, NavigationDirection, NumberCurrencyFormatterDirective, OIDC_ENABLED, ObjectHelper, PORTAIL_BASE_URL_INT, PORTAIL_BASE_URL_PROD, PORTAIL_BASE_URL_VAL, PageChangeEvent, PageUploadLimitService, PaginationWeek, PendingFiles, PendingPaymentComponent, PendingUploadService, PlaceOfOrigin, Portail, PostalLocality, Preferences, RECAPTCHA_API_URL, RecaptchaService, RedirectComponent, RegisterNgModelService, RowElement, SESSION_INFO_API_URL, SWISS_ISO_ID, ScrollHelper, SdkDictionaryPipe, SdkDictionaryService, SdkEpaymentComponent, SdkEvent, SdkEventType, SdkEventsLoggerService, SdkLog, SdkLogLevel, SdkLogsService, SdkRecaptchaComponent, SdkStatisticsService, SelectedSlot, Session, SessionInfo, SessionInfoData, SessionInfoWithApplicationService, Street, StreetNumber, StringHelper, THOUSANDS_SEPARATOR, TRANSMIT_WAITING_MODAL_DELAY_IN_MILLISECONDS, TableSort, UploadProgress, UploadProgressService, UploaderHelper, ValidationHandlerService, formatDecimalCurrency, formatNonDecimalCurrency, formatNumberAsGiven, gesdemLoaderGuard, providePrestationsNgCore, replaceAll };
+export type { BreadcrumbConfiguration, BrowserInfo, DictionaryType, FoehnListItemDescription, FoehnRecapSection, FoehnRecapSectionElement, FormError, HasCustomErrors, HelpModal, Image, Language, PlaceholderType };