itc-components-library20 0.0.1

package/index.d.ts

@@ -0,0 +1,1868 @@
+import * as i0 from '@angular/core';
+import { EventEmitter, ChangeDetectorRef, SimpleChanges, InjectionToken } from '@angular/core';
+import { Router } from '@angular/router';
+import { IconDefinition } from '@fortawesome/angular-fontawesome';
+import * as fas from '@fortawesome/free-solid-svg-icons';
+import { Table } from 'primeng/table';
+import { SortEvent, MenuItem } from 'primeng/api';
+import * as _fortawesome_fontawesome_common_types from '@fortawesome/fontawesome-common-types';
+import { PrimeNG } from 'primeng/config';
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import * as AWS from 'aws-sdk';
+
+declare class ItcLibrary20 {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ItcLibrary20, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ItcLibrary20, "lib-itc-library20", never, {}, {}, never, never, true, never>;
+}
+
+declare class PrimaryButton {
+    text: string;
+    bgColor: string;
+    isNegative: boolean;
+    icon?: any;
+    position: string;
+    fontWeight: string;
+    textColor: string;
+    border: string;
+    borderRadius: string;
+    onClick: EventEmitter<void>;
+    click(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PrimaryButton, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PrimaryButton, "lib-primary-button", never, { "text": { "alias": "text"; "required": false; }; "bgColor": { "alias": "bgColor"; "required": false; }; "isNegative": { "alias": "isNegative"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "position": { "alias": "position"; "required": false; }; "fontWeight": { "alias": "fontWeight"; "required": false; }; "textColor": { "alias": "textColor"; "required": false; }; "border": { "alias": "border"; "required": false; }; "borderRadius": { "alias": "borderRadius"; "required": false; }; }, { "onClick": "onClick"; }, never, never, true, never>;
+}
+
+declare class SecondaryButton {
+    text: string;
+    bgColor: string;
+    textColor: string;
+    icon?: any;
+    position: string;
+    fontWeight: string;
+    borderRadius: string;
+    border: string;
+    onClick: EventEmitter<void>;
+    click(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SecondaryButton, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SecondaryButton, "lib-secondary-button", never, { "text": { "alias": "text"; "required": false; }; "bgColor": { "alias": "bgColor"; "required": false; }; "textColor": { "alias": "textColor"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "position": { "alias": "position"; "required": false; }; "fontWeight": { "alias": "fontWeight"; "required": false; }; "borderRadius": { "alias": "borderRadius"; "required": false; }; "border": { "alias": "border"; "required": false; }; }, { "onClick": "onClick"; }, never, never, true, never>;
+}
+
+declare class ThirdButton {
+    text: string;
+    bgColor: string;
+    textColor: string;
+    icon?: any;
+    position: string;
+    fontWeight: string;
+    width: string;
+    height: string;
+    borderRadius: string;
+    border: string;
+    disabled: boolean;
+    iconSpin: boolean;
+    fontSize: string;
+    onClick: EventEmitter<void>;
+    click(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThirdButton, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ThirdButton, "lib-third-button", never, { "text": { "alias": "text"; "required": false; }; "bgColor": { "alias": "bgColor"; "required": false; }; "textColor": { "alias": "textColor"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "position": { "alias": "position"; "required": false; }; "fontWeight": { "alias": "fontWeight"; "required": false; }; "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "borderRadius": { "alias": "borderRadius"; "required": false; }; "border": { "alias": "border"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "iconSpin": { "alias": "iconSpin"; "required": false; }; "fontSize": { "alias": "fontSize"; "required": false; }; }, { "onClick": "onClick"; }, never, never, true, never>;
+}
+
+interface IColumn {
+    field: string;
+    header: string;
+}
+declare class BasicTable {
+    router: Router;
+    columns: IColumn[];
+    data: any[];
+    rows: number;
+    detailRoute: string;
+    actions: Record<string, (rowData: any) => void>;
+    first: number;
+    faCircle: IconDefinition;
+    faStroopwafel: IconDefinition;
+    isDateColumn(value: any): boolean;
+    isIconColumn(columnField: string): boolean;
+    navigateRoute(id: number): void;
+    pageChange(event: any): void;
+    get tableData(): any[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<BasicTable, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BasicTable, "lib-basic-table", never, { "columns": { "alias": "columns"; "required": false; }; "data": { "alias": "data"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "detailRoute": { "alias": "detailRoute"; "required": false; }; "actions": { "alias": "actions"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class SortableTable {
+    router: Router;
+    columns: IColumn[];
+    data: any[];
+    rows: number;
+    detailRoute: string;
+    actions: Record<string, (rowData: any) => void>;
+    colorPicker: (rowData: any, field: string) => string;
+    selected: any[];
+    tableCheckbox: string;
+    selectionChange: EventEmitter<any[]>;
+    resetData: EventEmitter<void>;
+    first: number;
+    faCircle: fas.IconDefinition;
+    faStroopwafel: fas.IconDefinition;
+    faMagnifyingGlass: fas.IconDefinition;
+    selectedData: any[];
+    isDateColumn(value: any): boolean;
+    isIconColumn(columnField: string): boolean;
+    navigateRoute(id: number): void;
+    pageChange(event: any): void;
+    dt: Table;
+    initialValue: any[];
+    isSorted: boolean | null;
+    currentSortedField: string | null;
+    ngOnInit(): void;
+    customSort(event: SortEvent): void;
+    sortTableData(event: SortEvent): void;
+    private isPriorityField;
+    isPriorityColumn(columnField: string): boolean;
+    private comparePriorities;
+    onRowSelect(): void;
+    clearSelection(): void;
+    hasMagnifyingGlassIcon(field: string): boolean;
+    resetSorting(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SortableTable, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SortableTable, "lib-sortable-table", never, { "columns": { "alias": "columns"; "required": false; }; "data": { "alias": "data"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "detailRoute": { "alias": "detailRoute"; "required": false; }; "actions": { "alias": "actions"; "required": false; }; "colorPicker": { "alias": "colorPicker"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "tableCheckbox": { "alias": "tableCheckbox"; "required": false; }; }, { "selectionChange": "selectionChange"; "resetData": "resetData"; }, never, never, true, never>;
+}
+
+interface IAppointment {
+    id: string;
+    patientId: string;
+    startDate: Date;
+    endDate: Date;
+    name: string;
+    createDate: Date;
+    accountProfileId: string;
+}
+declare enum CalendarView {
+    Month = "month",
+    Week = "week"
+}
+declare class Calendar {
+    private cdr;
+    private primengConfig;
+    appointments: IAppointment[];
+    items: MenuItem[];
+    startHour: number;
+    endHour: number;
+    timeInterval: number;
+    dateSelected: EventEmitter<{
+        date: Date;
+        startTime: string;
+    }>;
+    closeModal: EventEmitter<void>;
+    tabChanged: EventEmitter<string>;
+    faChevronLeft: _fortawesome_fontawesome_common_types.IconDefinition;
+    faChevronRight: _fortawesome_fontawesome_common_types.IconDefinition;
+    faCirclePlus: _fortawesome_fontawesome_common_types.IconDefinition;
+    faCircleCheck: _fortawesome_fontawesome_common_types.IconDefinition;
+    viewDate: Date;
+    selectedDate: Date | null;
+    blinkDate: Date | null;
+    selectedDateString: string;
+    selectedStartTime: string | undefined;
+    weekDays: string[];
+    monthDays: Date[];
+    currentView: CalendarView;
+    timeSlots: string[];
+    weeks: Date[][];
+    visibleList: boolean;
+    newAppointment: boolean;
+    activeItem: MenuItem | undefined;
+    activeValue: string;
+    selectedAppointments: IAppointment[];
+    hoveredAppointment: any;
+    tooltipStyle: any;
+    private appointmentCache;
+    private monthViewData;
+    private weekViewData;
+    private formattedDateCache;
+    private cacheKeys;
+    isLoading: boolean;
+    CalendarView: typeof CalendarView;
+    constructor(cdr: ChangeDetectorRef, primengConfig: PrimeNG);
+    configuraLingua(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private invalidateAppointmentCache;
+    private formatDateKey;
+    private cacheAppointmentData;
+    private precomputeAppointments;
+    private precomputeInBatches;
+    private getVisibleDays;
+    private precomputeForDays;
+    generateView(view: CalendarView, date: Date): void;
+    private isSameWeek;
+    generateMonthView(date: Date): void;
+    generateWeekView(date: Date): void;
+    generateTimeSlots(): void;
+    switchToView(view: CalendarView): void;
+    startOfWeek(date: Date): Date;
+    previous(): void;
+    next(): void;
+    isToday(date: Date): boolean;
+    isPastDate(date: Date): boolean;
+    isPastTime(date: Date, timeSlot: string): boolean;
+    hasAppointments(date: Date): boolean;
+    isTimeSlotOccupied(date: Date, timeSlot: string): boolean;
+    isCurrentMonth(date: Date): boolean;
+    isSameDate(date1: Date, date2: Date): boolean;
+    formatDate(date: Date): string;
+    extractTime(dateInput: Date): string;
+    selectDate(date?: Date, startTime?: string): void;
+    getAppointmentsForDate(day: Date, timeSlots: string[]): IAppointment[];
+    getAppointmentDuration(appointment: any): number;
+    getAppointmentHeightStyle(appointment: any): object;
+    getFirstAppointmentForDate(day: Date, timeSlots: string[]): IAppointment | null;
+    getAppointmentsForDataTime(date: Date, timeSlot: string): IAppointment[];
+    private formatHourToTimeString;
+    toggleNewAppointment(): void;
+    closeAppointmentModal(): void;
+    onDialogHide(): void;
+    viewToday(): void;
+    showTooltip(appointment: any, event: MouseEvent): void;
+    hideTooltip(): void;
+    onValueChange(value: string | number): void;
+    ngOnInit(): void;
+    dialogWidth: string;
+    onResize(): void;
+    setDialogWidth(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Calendar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Calendar, "lib-calendar", never, { "appointments": { "alias": "appointments"; "required": false; }; "items": { "alias": "items"; "required": false; }; "startHour": { "alias": "startHour"; "required": false; }; "endHour": { "alias": "endHour"; "required": false; }; "timeInterval": { "alias": "timeInterval"; "required": false; }; }, { "dateSelected": "dateSelected"; "closeModal": "closeModal"; "tabChanged": "tabChanged"; }, never, [".custom-input", ".custom-prescription", ".save-button"], true, never>;
+}
+
+declare class Message {
+    text: string;
+    date: string;
+    from: string;
+    bgColor: string;
+    textColor: string;
+    fontWeight: string;
+    width: string;
+    minHeight: string;
+    borderRadius: string;
+    border: string;
+    padding: string;
+    viewed?: any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Message, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Message, "lib-message", never, { "text": { "alias": "text"; "required": false; }; "date": { "alias": "date"; "required": false; }; "from": { "alias": "from"; "required": false; }; "bgColor": { "alias": "bgColor"; "required": false; }; "textColor": { "alias": "textColor"; "required": false; }; "fontWeight": { "alias": "fontWeight"; "required": false; }; "width": { "alias": "width"; "required": false; }; "minHeight": { "alias": "minHeight"; "required": false; }; "borderRadius": { "alias": "borderRadius"; "required": false; }; "border": { "alias": "border"; "required": false; }; "padding": { "alias": "padding"; "required": false; }; "viewed": { "alias": "viewed"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface IDictionaryIconDTO {
+    id: string | null;
+    name: string | null;
+    code: string | null;
+    type: string | null;
+}
+
+interface IDictionaryTypeQuestionDTO {
+    id: number | null;
+    name: string | null;
+}
+
+interface IDictionaryTypeSurveyDTO {
+    id?: number | null;
+    name: string | null;
+}
+
+interface IDictionaryAnswerResponse {
+    id: string;
+    text: string | null;
+    value: number;
+    icon: IDictionaryIconDTO;
+}
+
+interface IDictionaryStepResponse {
+    id: number;
+    name: string | null;
+    number: number;
+    typeSurvey: IDictionaryTypeSurveyDTO;
+}
+
+interface IDictionaryQuestionResponse {
+    id: string;
+    text: string | null;
+    position: string | null;
+    step: IDictionaryStepResponse;
+    typeSurvey: IDictionaryTypeSurveyDTO;
+    typeQuestion: IDictionaryTypeQuestionDTO;
+    icon: IDictionaryIconDTO;
+    answers: IDictionaryAnswerResponse[];
+}
+
+interface IQuestionAnswer {
+    idQuestion: string | undefined;
+    idAnswer: string | undefined;
+    idTypeSurvey: number;
+}
+declare class Survey {
+    questionList: IDictionaryQuestionResponse[];
+    typeSurvey: number;
+    patientSurvey: string;
+    sumOutput: EventEmitter<any>;
+    questionAnswer: EventEmitter<IQuestionAnswer>;
+    ngOnInit(): void;
+    onSumOutputReceived(sum: any): void;
+    onQuestionAnswerReceived(object: IQuestionAnswer): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Survey, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Survey, "lib-survey", never, { "questionList": { "alias": "questionList"; "required": false; }; "typeSurvey": { "alias": "typeSurvey"; "required": false; }; "patientSurvey": { "alias": "patientSurvey"; "required": false; }; }, { "sumOutput": "sumOutput"; "questionAnswer": "questionAnswer"; }, never, never, true, never>;
+}
+
+interface ISurveyResultResponse {
+    question: IDictionaryQuestionResponse;
+    answer: IDictionaryAnswerResponse;
+    value: number | null;
+}
+
+interface IPatientSurveyResponse {
+    id: string;
+    patientId: string;
+    date: Date;
+    typeSurvey: IDictionaryTypeSurveyDTO;
+    results: ISurveyResultResponse[];
+}
+
+interface IPatientSurveyRequest {
+    patientId: string;
+    typeSurveyId: number;
+    answers: string[];
+}
+
+declare class ApiSurveyService {
+    private gateway;
+    endpoint: string;
+    constructor(gateway: string);
+    http: HttpClient;
+    getQuestionByParameters(typeSurvey: number | "", stepNumber: number | ""): Observable<IDictionaryQuestionResponse[]>;
+    getQuestionByTypeSurvey(typeSurvey: number): Observable<IDictionaryQuestionResponse[]>;
+    getQuestionByQuestionId(questionId: number): Observable<IDictionaryQuestionResponse[]>;
+    getStepByTypeSurvey(typeSurvey: number): Observable<IDictionaryStepResponse[]>;
+    getStepByStepNumber(stepNumber: number): Observable<IDictionaryStepResponse[]>;
+    getSurveys(): Observable<IPatientSurveyResponse[]>;
+    getSurvey(patientId: string | "", surveyType: number | "", surveyId: string | "", lastSurvey: false): Observable<IPatientSurveyResponse[]>;
+    getSurveyById(surveyId: string): Observable<IPatientSurveyResponse>;
+    getLastSurvey(patientId: string, surveyType: number, lastSurvey: true): Observable<IPatientSurveyResponse[]>;
+    postSurvey(patientSurveyRequest: IPatientSurveyRequest): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ApiSurveyService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ApiSurveyService>;
+}
+
+declare class SurveyRadio {
+    apiSurvey: ApiSurveyService;
+    question: IDictionaryQuestionResponse | undefined;
+    typeSurvey: number;
+    patientSurvey: string;
+    patientId: string | undefined;
+    questionAnswer: EventEmitter<IQuestionAnswer>;
+    filteredSurvey: IPatientSurveyResponse;
+    questionAnswerObject: IQuestionAnswer;
+    ngOnInit(): void;
+    selectedValue(idQuestion: string | undefined, idAnswer: string | undefined): void;
+    searchSurvey(surveyId: string): void;
+    getMatchingAnswer(surveyId: string, answerId: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SurveyRadio, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SurveyRadio, "lib-survey-radio", never, { "question": { "alias": "question"; "required": false; }; "typeSurvey": { "alias": "typeSurvey"; "required": false; }; "patientSurvey": { "alias": "patientSurvey"; "required": false; }; "patientId": { "alias": "patientId"; "required": false; }; }, { "questionAnswer": "questionAnswer"; }, never, never, true, never>;
+}
+
+declare class SurveyValuebox {
+    apiSurvey: ApiSurveyService;
+    question: IDictionaryQuestionResponse | undefined;
+    typeSurvey: number;
+    indexQuestion: number;
+    patientSurvey: string;
+    patientId: string | undefined;
+    sumOutput: EventEmitter<any>;
+    questionAnswer: EventEmitter<IQuestionAnswer>;
+    filteredSurvey: IPatientSurveyResponse;
+    sum: number;
+    selectedValues: {
+        [key: number]: number | string;
+    };
+    questionAnswerObject: IQuestionAnswer;
+    sumValue(valueSelected: number, groupIndex: number, idQuestion: string | undefined, idAnswer: string | undefined): void;
+    ngOnInit(): void;
+    searchSurvey(surveyId: string): void;
+    getMatchingAnswer(answerId: string | undefined): boolean;
+    initializeSelectedValues(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SurveyValuebox, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SurveyValuebox, "lib-survey-valuebox", never, { "question": { "alias": "question"; "required": false; }; "typeSurvey": { "alias": "typeSurvey"; "required": false; }; "indexQuestion": { "alias": "indexQuestion"; "required": false; }; "patientSurvey": { "alias": "patientSurvey"; "required": false; }; "patientId": { "alias": "patientId"; "required": false; }; }, { "sumOutput": "sumOutput"; "questionAnswer": "questionAnswer"; }, never, never, true, never>;
+}
+
+declare class SurveyText {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SurveyText, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SurveyText, "lib-survey-text", never, {}, {}, never, never, true, never>;
+}
+
+interface IMinio {
+    bucketName: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    endpoint: string;
+}
+
+declare class Minio {
+    private config;
+    private s3;
+    bucketName: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    endpoint: string;
+    constructor(config: IMinio);
+    uploadFile(fileName: string, fileContent: any): Promise<AWS.S3.ManagedUpload.SendData>;
+    getObject(fileName: string): Promise<AWS.S3.GetObjectOutput>;
+    getAllObjectsInFolder(folderPath: string): Promise<Map<string, AWS.S3.GetObjectOutput>>;
+    deleteObject(bucketName: string, fileName: string): Promise<AWS.S3.DeleteObjectOutput>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Minio, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<Minio>;
+}
+
+declare class PrimengItalianLocale {
+}
+declare const PRIMENG_ITALIAN_LOCALE: {
+    firstDayOfWeek: number;
+    dayNames: string[];
+    dayNamesShort: string[];
+    dayNamesMin: string[];
+    monthNames: string[];
+    monthNamesShort: string[];
+    today: string;
+    clear: string;
+    dateFormat: string;
+    weekHeader: string;
+};
+
+declare class FormatDate {
+    convertToISOFormat(date: Date): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormatDate, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FormatDate>;
+}
+
+interface IDictionaryTypeContact$1 {
+    id: number;
+    name: string;
+    isEnabled: boolean;
+    isVisible: boolean;
+}
+
+interface IAccountContactResponse {
+    typeContact: IDictionaryTypeContact$1;
+    value: string;
+    isActive: boolean;
+}
+
+interface IDictionarySystemDTO {
+    id?: string;
+    name?: string;
+    initials?: string;
+    isEnabled: boolean;
+    isVisible: boolean;
+}
+
+interface IAccountDistrictResponse {
+    districtId: string;
+    isActive: boolean;
+}
+
+interface IAccountAslResponse {
+    id: number;
+    aslId: string;
+    isActive: boolean;
+    accountDistricts: IAccountDistrictResponse[];
+}
+
+interface IAccountStructureResponse {
+    id: number;
+    structureId: string;
+    isActive: boolean;
+    asls: IAccountAslResponse[];
+}
+
+interface IDictionaryPermission {
+    id?: number;
+    function: string;
+    code: string;
+    isEnabled: boolean;
+    isVisible: boolean;
+}
+
+interface IProfilePermissionResponse {
+    permission: IDictionaryPermission;
+    write: boolean;
+}
+
+interface IDictionaryProfileResponse {
+    id: number;
+    name: string;
+    isEnabled: boolean;
+    isVisible: boolean;
+    systems?: IDictionarySystemDTO[];
+    permissions: IProfilePermissionResponse[];
+}
+
+interface IAccountProfileSystemResponse {
+    id: string;
+    profile: IDictionaryProfileResponse;
+    system: IDictionarySystemDTO;
+    createDate: Date;
+    expireDate: Date;
+    structures?: IAccountStructureResponse[];
+    isActive: boolean;
+}
+
+interface IAccountResponse {
+    id: string;
+    name?: string;
+    lastname?: string;
+    fiscalcode?: string;
+    username?: string;
+    dateOfBirth?: Date;
+    lastLoginDate?: Date;
+    isActive: boolean;
+    isLocked: boolean;
+    dateLocked?: Date;
+    firstAccess: boolean;
+    numberLoginFailed: number;
+    otp?: string;
+    dateExpireOTP?: Date;
+    profileSystems?: IAccountProfileSystemResponse[];
+    contacts?: IAccountContactResponse[];
+}
+
+interface IAccountContactRequest {
+    typeContactId: number;
+    value: string;
+    isActive: boolean;
+}
+
+interface IAccountStructureRequest {
+    id?: number;
+    structureId: string;
+    isActive: boolean;
+}
+
+interface IAccountProfileSystemRequest {
+    id?: string;
+    profileId: number;
+    systemId?: string;
+    isActive: boolean;
+    expireDate?: Date;
+    structures?: IAccountStructureRequest[];
+}
+
+interface IAccountRequest {
+    id?: string;
+    name?: string;
+    lastname?: string;
+    fiscalcode?: string;
+    username?: string;
+    dateOfBirth?: Date;
+    isActive: boolean;
+    isLocked: boolean;
+    dateLocked?: Date;
+    lastLoginDate?: Date;
+    numberLoginFailed?: number;
+    profileSystems?: IAccountProfileSystemRequest[];
+    contacts: IAccountContactRequest[];
+}
+
+interface ILoginRequest {
+    username: string;
+    password: string;
+    idLdap?: number;
+}
+
+interface IAuthenticationResponse {
+    id: string;
+    jwtToken?: string;
+    refreshToken?: string;
+    jwtExpiration: Date;
+    refreshTokenExpiration: Date;
+}
+
+interface ILoginResponse {
+    accountId: string;
+    isLocked: boolean;
+    dateLocked?: Date;
+    isEnabled: boolean;
+    firstAccess: boolean;
+    numberFail: number;
+    passwordExpired: boolean;
+    tokenData?: IAuthenticationResponse;
+}
+
+interface INewTokenRequest {
+    token?: string;
+    refreshToken?: string;
+}
+
+interface IAccountCredentialDTO {
+    id?: number;
+    accountId: string;
+    password?: string;
+    date: Date;
+}
+
+declare class ApiAccountService {
+    private gateway;
+    endpoint: string;
+    constructor(gateway: string);
+    http: HttpClient;
+    getAccounts(): Observable<IAccountResponse[]>;
+    getAccountById(id: string): Observable<IAccountResponse>;
+    getAccountByFiscalCode(fiscalCode: string): Observable<IAccountResponse>;
+    getAccountByUsername(username: string): Observable<IAccountResponse>;
+    getAccountByAccountProfileId(accountProfileId: string): Observable<IAccountResponse>;
+    getCredentialByAccountId(accountId: string): Observable<IAccountCredentialDTO>;
+    postAccount(accountRequest: IAccountRequest): Observable<string>;
+    postLogin(loginRequest: ILoginRequest): Observable<string | ILoginResponse>;
+    postLoginLdap(loginRequest: ILoginRequest): Observable<string | ILoginResponse>;
+    postRefreshToken(refreshToken: INewTokenRequest): Observable<IAuthenticationResponse>;
+    postCredential(accountCredentialDTO: IAccountCredentialDTO): Observable<number>;
+    setLoginAccount(id: string): Observable<boolean>;
+    deleteAccount(id: string): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ApiAccountService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ApiAccountService>;
+}
+
+interface IProfilePermissionRequest {
+    profileId?: number;
+    permissionId: number;
+    write: boolean;
+}
+
+interface IDictionaryProfileRequest {
+    id?: number;
+    name?: string;
+    isEnabled: boolean;
+    isVisible: boolean;
+    systems?: string[];
+    permissions?: IProfilePermissionRequest[];
+}
+
+declare class ApiAccountDictionaryService {
+    private gateway;
+    endpoint: string;
+    constructor(gateway: string);
+    http: HttpClient;
+    getPermissions(): Observable<IDictionaryPermission[]>;
+    getPermissionById(id: string): Observable<IDictionaryPermission>;
+    getPermissionByCode(code: string): Observable<IDictionaryPermission>;
+    getPermissionByParameters(id: string, code: string): Observable<IDictionaryPermission>;
+    getProfiles(): Observable<IDictionaryProfileResponse[]>;
+    getProfileById(id: string): Observable<IDictionaryProfileResponse>;
+    getTypesContact(): Observable<IDictionaryTypeContact$1[]>;
+    getTypeContactById(id: string): Observable<IDictionaryTypeContact$1>;
+    getSystems(): Observable<IDictionarySystemDTO[]>;
+    getSystemById(id: string): Observable<IDictionarySystemDTO>;
+    postPermission(permissionRequest: IDictionaryPermission): Observable<number>;
+    postProfile(profileRequest: IDictionaryProfileRequest): Observable<number>;
+    postTypeContact(typeContactRequest: IDictionaryTypeContact$1): Observable<number>;
+    postSystem(system: IDictionarySystemDTO): Observable<string>;
+    deletePermission(id: number): Observable<boolean>;
+    deleteProfile(id: number): Observable<boolean>;
+    deleteTypeContact(id: number): Observable<boolean>;
+    deleteSystem(id: string): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ApiAccountDictionaryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ApiAccountDictionaryService>;
+}
+
+interface IDictionaryVitalSign {
+    id?: string;
+    name?: string;
+    unitOfMeasure?: string;
+    isEnabled: boolean;
+    isVisible: boolean;
+    sort?: number;
+    referenceVitalSign?: IDictionaryVitalSign;
+}
+
+interface IDictionaryTypeRecurrency {
+    id: number | null;
+    name: string | null;
+    isEnabled: boolean;
+    isVisible: boolean;
+    dayToAdd: number;
+}
+
+interface IDictionaryRecurrencyResponse {
+    id: number;
+    startDate: Date;
+    endDate: Date;
+    number: number;
+    typeRecurrency: IDictionaryTypeRecurrency;
+}
+
+interface IExamValueResponse {
+    id: string;
+    patientId: string;
+    vitalSign: IDictionaryVitalSign;
+    examDate: Date;
+    receivedDate: Date;
+    value: string | null;
+    viewed: boolean;
+    examId: string;
+}
+
+interface IPatientExamResponse {
+    id: string;
+    patientId: string;
+    vitalSign: IDictionaryVitalSign;
+    startDate: Date;
+    endDate: Date;
+    annotation: string | null;
+    accountProfileId: string;
+    telephone: string | null;
+    email: string | null;
+    toDo: boolean;
+    values: IExamValueResponse[] | null;
+    recurrency: IDictionaryRecurrencyResponse;
+}
+
+interface IDictionaryRecurrencyRequest {
+    id: number | null;
+    startDate: string;
+    endDate: string;
+    typeId: number;
+    number: number;
+}
+
+interface IPatientExamRequest {
+    id?: string;
+    patientId: string;
+    vitalSignId: string;
+    startDate: string;
+    endDate: string;
+    annotation?: string;
+    accountProfileId: string;
+    telephone?: string;
+    email?: string;
+    recurrency?: IDictionaryRecurrencyRequest;
+}
+
+interface IExamValueRequest {
+    id: string | null;
+    examId: string | null;
+    patientId: string;
+    vitalSignId: string;
+    examDate: Date;
+    receivedDate: Date;
+    value: string | null;
+}
+
+declare class ApiExamService {
+    private gateway;
+    endpoint: string;
+    constructor(gateway: string);
+    http: HttpClient;
+    getPatientExams(): Observable<IPatientExamResponse[]>;
+    getPatientExamsByParameters(patientId: string | "", vitalSignId: string | ""): Observable<IPatientExamRequest[]>;
+    getPatientExamByPatientId(patientid: string): Observable<IPatientExamResponse[]>;
+    getPatientExamVitalSignId(id: string): Observable<IPatientExamResponse>;
+    getExamValues(): Observable<IExamValueResponse[]>;
+    getExamValueByParameters(vitalSignId: string | "", patientId: string | ""): Observable<IExamValueResponse[]>;
+    getExamValueByVitalSignId(vitalSignId: string): Observable<IExamValueResponse>;
+    getExamValueByPatientId(patientId: string): Observable<IExamValueResponse[]>;
+    postPatientExams(patientExamRequest: IPatientExamRequest): Observable<string>;
+    postExamValue(examValueRequest: IExamValueRequest): Observable<string>;
+    setPatientExam(id: string): Observable<boolean>;
+    setExamValue(patientId: string): Observable<boolean>;
+    deletePatientExam(id: string): Observable<boolean>;
+    deleteExamValue(id: string): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ApiExamService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ApiExamService>;
+}
+
+interface IDictionaryTypeAppointment {
+    id: number | null;
+    name: string | null;
+    isEnabled: boolean;
+    isVisible: boolean;
+    dayToAdd: number;
+}
+
+interface IPatientAppointmentResponse {
+    id: string;
+    patientId: string;
+    startDate: Date;
+    endDate: Date;
+    typeAppointment: IDictionaryTypeAppointment;
+    annotation: string | null;
+    accountProfileId: string;
+    structureDepartmentId: string | null;
+    telephone: string | null;
+    email: string | null;
+    toDo: boolean;
+    createDate: Date;
+    recurrency: IDictionaryRecurrencyResponse;
+}
+
+interface IPatientAppointmentRequest {
+    id?: string;
+    patientId: string;
+    startDate: string;
+    endDate: string;
+    typeId: number;
+    annotation?: string;
+    accountProfileId: string;
+    structureDepartmentId?: string;
+    telephone?: string;
+    email?: string;
+    recurrency?: IDictionaryRecurrencyRequest;
+}
+
+declare class ApiExamAppointmentService {
+    private gateway;
+    endpoint: string;
+    constructor(gateway: string);
+    http: HttpClient;
+    getPatientAppointments(): Observable<IPatientAppointmentResponse[]>;
+    getPatientAppointmentByParameters(patientId: string | "", accountProfileId: string | "", structureDepartmentId: string | "", typeId: number | ""): Observable<IPatientAppointmentResponse[]>;
+    getPatientAppointmentById(id: string): Observable<IPatientAppointmentResponse>;
+    getPatientAppointmentByPatientId(patientId: string): Observable<IPatientAppointmentResponse>;
+    getPatientAppointmentByAccountProfileId(accountProfileId: string): Observable<IPatientAppointmentResponse[]>;
+    getPatientAppointmentByStructureDepartmentId(structureDepartmentId: string): Observable<IPatientAppointmentResponse>;
+    getPatientAppointmentByTypeId(typeId: string): Observable<IPatientAppointmentResponse>;
+    postPatientAppointment(patientAppointmentRequest: IPatientAppointmentRequest): Observable<string>;
+    deletePatientAppointment(id: string): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ApiExamAppointmentService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ApiExamAppointmentService>;
+}
+
+interface IDictionaryTarget {
+    id: string;
+    vitalSign: IDictionaryVitalSign;
+    defaultMinValue: string | null;
+    defaultMaxValue: string | null;
+    step: number;
+    percentage: boolean;
+}
+
+interface IDictionaryTypeComponentDTO {
+    id?: number;
+    name?: string;
+    isEnabled: boolean;
+    isVisible: boolean;
+    createDate: Date;
+}
+
+interface IDictionaryComponentResponse {
+    id: string;
+    name?: string;
+    identifier?: string;
+    typeComponent: IDictionaryTypeComponentDTO;
+    brand?: string;
+    model?: string;
+    macAddress?: string;
+    bluetoothName?: string;
+}
+
+interface IDictionaryKitResponse {
+    id: string;
+    kitIdentifier?: string;
+    createDate: Date;
+    isEnabled: boolean;
+    isVisible: boolean;
+    components?: IDictionaryComponentResponse[];
+    video?: boolean;
+    departmentId?: string;
+}
+
+interface IDictionaryKitRequest {
+    id?: string;
+    kitIdentifier?: string;
+    isEnabled: boolean;
+    isVisible: boolean;
+    components?: string[];
+    video?: boolean;
+    departmentId?: string;
+}
+
+interface IDictionaryComponentRequest {
+    id?: string;
+    name?: string;
+    identifier?: string;
+    typeId: number;
+    brand?: string;
+    model?: string;
+    macAddress?: string;
+    bluetoothName?: string;
+    ipAddress?: string;
+}
+
+interface IDictionaryTargetRequest {
+    id?: string;
+    vitalSignId: string;
+    defaultMinValue?: string;
+    defaultMaxValue?: string;
+    step: number;
+    percentage: boolean;
+}
+
+interface IRiskDefaultTargetResponse {
+    id: number;
+    target: IDictionaryTarget[];
+    minValue?: string;
+    maxValue?: string;
+}
+
+interface IDictionaryRiskResponse {
+    id: string;
+    name?: string;
+    createDate: Date;
+    isEnabled: boolean;
+    isVisible: boolean;
+    values?: IRiskDefaultTargetResponse[];
+}
+
+interface IRiskDefaultTargetRequest {
+    id?: number;
+    riskId: string;
+    targetId: string;
+    minValue?: string;
+    maxValue?: string;
+}
+
+interface IDictionaryRiskRequest {
+    id?: string;
+    name?: string;
+    isEnabled: boolean;
+    isVisible: boolean;
+    values?: IRiskDefaultTargetRequest[];
+}
+
+declare class ApiExamDictionaryService {
+    private gateway;
+    endpoint: string;
+    constructor(gateway: string);
+    http: HttpClient;
+    getRecurrencies(): Observable<IDictionaryRecurrencyResponse[]>;
+    getRecurrencyById(id: number): Observable<IDictionaryRecurrencyResponse>;
+    getTypesRecurrency(): Observable<IDictionaryTypeRecurrency[]>;
+    getTypeRecurrencyById(id: number): Observable<IDictionaryTypeRecurrency>;
+    getVitalSigns(): Observable<IDictionaryVitalSign[]>;
+    getVitalSignById(id: string): Observable<IDictionaryVitalSign>;
+    getTypesAppointment(): Observable<IDictionaryTypeAppointment[]>;
+    getTypeAppointmentById(id: number): Observable<IDictionaryTypeAppointment>;
+    getTargets(): Observable<IDictionaryTarget[]>;
+    getTargetById(targetId: string): Observable<IDictionaryTarget>;
+    getTargetByVitalSignId(vitalSignId: string): Observable<IDictionaryTarget[]>;
+    getTargetByParameters(vitalSignId: string | '', targetId: string | ''): Observable<IDictionaryTarget>;
+    getKits(): Observable<IDictionaryKitResponse[]>;
+    getKitById(id: string): Observable<IDictionaryKitResponse>;
+    getComponents(): Observable<IDictionaryComponentResponse[]>;
+    getComponentById(id: string): Observable<IDictionaryComponentResponse>;
+    getComponentsByType(type: number): Observable<IDictionaryComponentResponse[]>;
+    getComponentByParameters(id: string, type: number): Observable<IDictionaryComponentResponse>;
+    getTypeComponent(): Observable<IDictionaryTypeComponentDTO[]>;
+    getTypeComponentById(id: number): Observable<IDictionaryTypeComponentDTO>;
+    getRisks(): Observable<IDictionaryRiskResponse[]>;
+    getRiskById(id: string): Observable<IDictionaryRiskResponse>;
+    postRecurrency(recurrencyRequest: IDictionaryRecurrencyRequest): Observable<number>;
+    postTypeRecurrency(typeRecurrencyRequest: IDictionaryTypeRecurrency): Observable<number>;
+    postVitalSign(vitalSignRequest: IDictionaryVitalSign): Observable<number>;
+    postTypeAppointment(typeAppointmentRequest: IDictionaryTypeAppointment): Observable<number>;
+    postTarget(targetRequest: IDictionaryTargetRequest): Observable<string>;
+    postComponent(componentRequest: IDictionaryComponentRequest): Observable<string>;
+    postKit(kitRequest: IDictionaryKitRequest): Observable<string>;
+    postRisk(riskRequest: IDictionaryRiskRequest): Observable<string>;
+    deleteRecurrency(id: number): Observable<boolean>;
+    deleteTypeRecurrency(id: number): Observable<boolean>;
+    deleteVitalSign(id: string): Observable<boolean>;
+    deleteTypeAppointment(id: number): Observable<boolean>;
+    deleteTarget(targetId: string): Observable<boolean>;
+    deleteKit(id: string): Observable<boolean>;
+    deleteRisk(id: string): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ApiExamDictionaryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ApiExamDictionaryService>;
+}
+
+interface IPatientKitResponse {
+    id: string;
+    kit: IDictionaryKitResponse;
+    patientId: string;
+    createDate: Date;
+    status: boolean;
+    assignDate: Date;
+    expireDate: Date;
+    isCalibrated?: boolean;
+    floor?: string;
+    room?: string;
+    bed?: string;
+}
+
+interface IPatientKitRequest {
+    id?: string;
+    patientId: string;
+    kitId: string;
+    assignDate?: string;
+    expireDate?: string;
+    floor?: string;
+    room?: string;
+    bed?: string;
+}
+
+declare class ApiKitService {
+    private gateway;
+    endpoint: string;
+    constructor(gateway: string);
+    http: HttpClient;
+    getPatientKit(): Observable<IPatientKitResponse[]>;
+    getPatientKitByParameters(id: string, patientId: string): Observable<IPatientKitResponse>;
+    getPatientKitById(id: string): Observable<IPatientKitResponse>;
+    getPatientKitByPatientId(patientId: string): Observable<IPatientKitResponse[]>;
+    postPatientKit(patientKitRequest: IPatientKitRequest): Observable<string>;
+    setPatientKit(id: string): Observable<boolean>;
+    deletePatientKit(id: string): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ApiKitService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ApiKitService>;
+}
+
+interface ICountryResponse {
+    id: string;
+    name: string;
+    code: string;
+    iso: string;
+}
+
+interface IRegionResponse {
+    id: string;
+    name: string;
+    code: string;
+    istatCode: string;
+    iso: string;
+    country: ICountryResponse;
+}
+
+interface IProvinceResponse {
+    id: string;
+    name: string;
+    code: string;
+    istatCode: string;
+    iso: string;
+    symbol: string;
+    region: IRegionResponse;
+}
+
+interface ICommonResponse {
+    id: string;
+    name: string;
+    code: string;
+    latitude: string;
+    longitute: string;
+    istatCode: string;
+    registryCode: string;
+    province: IProvinceResponse;
+    abroadCountry: ICountryResponse;
+}
+
+interface IAslResponse {
+    id: string;
+    name: string;
+    code: string;
+    email: string;
+    telephone: string;
+    latitude: string;
+    longitute: string;
+    common: ICommonResponse;
+}
+
+interface IDistrictResponse {
+    id: string;
+    name: string;
+    code: string;
+    email: string;
+    telephone: string;
+    asl: IAslResponse;
+}
+
+interface IAslRequest {
+    id: string;
+    name: string;
+    code: string;
+    email: string;
+    telephone: string;
+    latitude: string;
+    longitute: string;
+    commonId: string;
+}
+
+interface IDistrictRequest {
+    id: string;
+    name: string;
+    code: string;
+    email: string;
+    telephone: string;
+    aslId: string;
+}
+
+interface ICommonRequest {
+    id: string;
+    name: string;
+    code: string;
+    latitude: string;
+    longitute: string;
+    istatCode: string;
+    registryCode: string;
+    provinceId: string;
+    abroadCountryId: string;
+}
+
+interface ICountryRequest {
+    id: string;
+    name: string;
+    code: string;
+    iso: string;
+}
+
+interface IProvinceRequest {
+    id: string;
+    name: string;
+    code: string;
+    istatCode: string;
+    iso: string;
+    symbol: string;
+    regionId: string;
+}
+
+interface IRegionRequest {
+    id: string;
+    name: string;
+    code: string;
+    istatCode: string;
+    iso: string;
+    countryId: string;
+}
+
+declare class ApiGeographyService {
+    private gateway;
+    endpoint: string;
+    constructor(gateway: string);
+    http: HttpClient;
+    getAsls(): Observable<IAslResponse[]>;
+    getAslById(id: string): Observable<IAslResponse>;
+    getAslByName(name: string): Observable<IAslResponse>;
+    getAslByCommonId(commonId: string): Observable<IAslResponse[]>;
+    getDistricts(): Observable<IDistrictResponse[]>;
+    getDistrictById(id: string): Observable<IDistrictResponse>;
+    getDistrictByName(name: string): Observable<IDistrictResponse>;
+    getDistrictByAslId(aslId: string): Observable<IDistrictResponse[]>;
+    getCommons(): Observable<ICommonResponse[]>;
+    getCommonByParameters(provinceId: string | "", regionId: string | ""): Observable<ICommonResponse[]>;
+    getCommonById(id: string): Observable<ICommonResponse>;
+    getCommonByName(name: string): Observable<ICommonResponse>;
+    getCommonByProvinceId(provinceId: string): Observable<ICommonResponse[]>;
+    getCommonByRegionId(regionId: string): Observable<ICommonResponse[]>;
+    getCountries(): Observable<ICountryResponse[]>;
+    getCountryById(id: string): Observable<ICountryResponse>;
+    getCountryByName(name: string): Observable<ICountryResponse>;
+    getProvinces(): Observable<IProvinceResponse[]>;
+    getProvinceById(id: string): Observable<IProvinceResponse>;
+    getProvinceByName(name: string): Observable<IProvinceResponse>;
+    getProvinceByRegionId(regionId: string): Observable<IProvinceResponse[]>;
+    getRegions(): Observable<IRegionResponse[]>;
+    getRegionById(id: string): Observable<IRegionResponse>;
+    getRegionByName(name: string): Observable<IRegionResponse>;
+    getRegionByCountryId(countryId: string): Observable<IRegionResponse[]>;
+    postAsl(aslRequest: IAslRequest): Observable<string>;
+    postDistrict(districtRequest: IDistrictRequest): Observable<string>;
+    postCommon(commonRequest: ICommonRequest): Observable<string>;
+    postCountry(countryRequest: ICountryRequest): Observable<string>;
+    postProvince(provinceRequest: IProvinceRequest): Observable<string>;
+    postRegion(regionRequest: IRegionRequest): Observable<string>;
+    deleteAsl(id: string): Observable<boolean>;
+    deleteDistrict(id: string): Observable<boolean>;
+    deleteCommon(id: string): Observable<boolean>;
+    deleteCountry(id: string): Observable<boolean>;
+    deleteProvince(id: string): Observable<boolean>;
+    deleteRegion(id: string): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ApiGeographyService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ApiGeographyService>;
+}
+
+interface IPatientDataRequest {
+    id: string;
+    name?: string;
+    lastName?: string;
+    gender?: string;
+    birthDate: Date;
+}
+
+interface IPatientIdentifierRequest {
+    patientId: string;
+    identifierId: number;
+    value?: string;
+}
+
+interface IPatientContactRequest {
+    id?: number;
+    patientId: string;
+    contactId: number;
+    value?: string;
+}
+
+interface IPatientIdentifierResponse {
+    patientId: string;
+    identifierId: number;
+    value?: string;
+    createDate: Date;
+}
+
+interface IPatientContactResponse {
+    id: number;
+    patientId: string;
+    contactId: number;
+    value?: string;
+}
+
+interface IPatientAddressResponse {
+    patientId: string;
+    typeAddressId: number;
+    fullAddress?: string;
+    address?: string;
+    cap?: string;
+    commonId?: string;
+    room?: string;
+    bed?: string;
+    floor?: string;
+    departmentId?: string;
+}
+
+interface IPatientAddressRequest {
+    patientId: string;
+    addressId: number;
+    fullAddress?: string;
+    address?: string;
+    cap?: string;
+    commonId?: string;
+    room?: string;
+    bed?: string;
+    floor?: string;
+    departmentId?: string;
+}
+
+declare class ApiAdministrationService {
+    private gateway;
+    endpoint: string;
+    constructor(gateway: string);
+    http: HttpClient;
+    getPatientIdentifiers(): Observable<IPatientIdentifierResponse[]>;
+    getPatientIdentifierByParameters(patientId: string | '', identifierId: number | 0): Observable<IPatientIdentifierResponse[]>;
+    getPatientContacts(): Observable<IPatientContactResponse[]>;
+    getPatientContactByParameters(patientId: string | '', contactId: number | 0): Observable<IPatientContactResponse[]>;
+    getPatientAddresses(): Observable<IPatientAddressResponse[]>;
+    getPatientAddressByParameters(patientId: string | '', addressId: number | 0): Observable<IPatientAddressResponse[]>;
+    postPatientData(patientDataRequest: IPatientDataRequest): Observable<boolean>;
+    postPatientIdentifier(patientIdentifierRequest: IPatientIdentifierRequest): Observable<boolean>;
+    postPatientContact(patientContactRequest: IPatientContactRequest): Observable<boolean>;
+    postPatientAddress(patientAddressRequest: IPatientAddressRequest): Observable<boolean>;
+    putPatientIdentifier(patientIdentifierRequest: IPatientIdentifierRequest): Observable<boolean>;
+    putPatientContact(patientContactRequest: IPatientContactRequest): Observable<boolean>;
+    putPatientAddress(patientAddressRequest: IPatientAddressRequest): Observable<boolean>;
+    deletePatientIdentifier(patientId: string, identifierId: number): Observable<boolean>;
+    deletePatientContact(contactId: number): Observable<boolean>;
+    deletePatientAddress(patientId: string, typeAddressId: number): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ApiAdministrationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ApiAdministrationService>;
+}
+
+interface ITargetDTO {
+    patientId?: string;
+    targetId: string;
+    minValue?: string;
+    maxValue?: string;
+}
+
+interface ICaregiverDTO {
+    patientId?: string;
+    name?: string;
+    lastname?: string;
+    fiscalcode?: string;
+    telephone?: string;
+    email?: string;
+    annotation?: string;
+}
+
+interface IDictionaryTypeAddress {
+    id: number;
+    name: string;
+    isEnabled: boolean;
+    isVisible: boolean;
+}
+
+interface IAddressResponse {
+    fullAddress: string;
+    address: string;
+    cap: string;
+    commonId: number;
+    type: IDictionaryTypeAddress;
+    room?: string;
+    bed?: string;
+    floor?: string;
+    departmentId?: string;
+}
+
+interface IDictionaryTypeContact {
+    id: number;
+    name: string;
+    isEnabled: boolean;
+    isVisible: boolean;
+}
+
+interface IContactResponse {
+    id: number;
+    contactId: number;
+    value: string;
+    type: IDictionaryTypeContact;
+}
+
+interface IDoctorResponse {
+    doctorName: string;
+    doctorLastname: string;
+    doctorFiscalcode: string;
+}
+
+interface IDictionaryIdentifier {
+    id: number;
+    name: string;
+    isEnabled: boolean;
+    isVisible: boolean;
+}
+
+interface IIdentifierResponse {
+    value: string;
+    type: IDictionaryIdentifier;
+}
+
+interface IDictionarySetting {
+    id?: string;
+    name?: string;
+    sender: boolean;
+    receiver: boolean;
+}
+
+interface IDictionarySettingStatus {
+    id?: number;
+    name?: string;
+    isEnabled: boolean;
+    isVisible: boolean;
+}
+
+interface ISettingResponse {
+    id: number;
+    patientId: string;
+    sender: IDictionarySetting;
+    receiver: IDictionarySetting;
+    status: IDictionarySettingStatus;
+    date: Date;
+    isActive: boolean;
+}
+
+interface IRiskDTO {
+    patientId?: string;
+    riskId: string;
+    createDate?: Date;
+}
+
+interface IPatientResponse {
+    id: string;
+    name: string;
+    lastname: string;
+    gender: string;
+    birthDate: Date;
+    inBed?: boolean;
+    doctors: IDoctorResponse[];
+    contacts: IContactResponse[];
+    identifiers: IIdentifierResponse[];
+    addresses?: IAddressResponse[];
+    settings: ISettingResponse[];
+    caregiver: ICaregiverDTO;
+    targets: ITargetDTO[];
+    risk: IRiskDTO;
+    createDate: Date;
+}
+
+interface IAddressRequest {
+    patientId?: string;
+    typeId: number;
+    fullAddress?: string;
+    address?: string;
+    cap?: string;
+    commonId?: string;
+    room?: string;
+    bed?: string;
+    floor?: string;
+    departmentId?: string;
+}
+
+interface IContactsRequest {
+    id?: number;
+    patientId?: string;
+    contactId: number;
+    value?: string;
+}
+
+interface IDoctorRequest {
+    patientId?: string;
+    doctorName?: string;
+    doctorLastname?: string;
+    doctorFiscalcode?: string;
+    telephone?: string;
+    accountId?: string;
+}
+
+interface IIdentifierRequest {
+    patientId?: string;
+    identifierId: number;
+    value?: string;
+}
+
+interface ISettingRequest {
+    id?: number;
+    patientId: string;
+    senderId?: string;
+    receiverId?: string;
+    statusId?: number;
+}
+
+interface IPatientRequest {
+    id?: string;
+    name?: string;
+    lastname?: string;
+    gender?: string;
+    birthDate?: Date;
+    doctors?: IDoctorRequest[];
+    contacts?: IContactsRequest[];
+    identifiers?: IIdentifierRequest[];
+    addresses?: IAddressRequest[];
+    settings?: ISettingRequest[];
+    caregiver?: ICaregiverDTO;
+    targets?: ITargetDTO[];
+    risk?: IRiskDTO;
+}
+
+interface ITargetResponse {
+    patientId: string;
+    targetId: string;
+    minValue: string | null;
+    maxValue: string | null;
+}
+
+interface IDictionaryTypeAnnotation {
+    id?: number;
+    name?: string;
+}
+
+interface IAnnotationResponse {
+    id: string;
+    accountProfileId: string;
+    typeAnnotation: IDictionaryTypeAnnotation;
+    date: string;
+    text?: string;
+}
+
+interface IAnnotationRequest {
+    patientId: string;
+    accountProfileId: string;
+    typeId: number;
+    text?: string;
+}
+
+interface IDictionaryTypeEventDTO {
+    id?: string;
+    name?: string;
+    code?: string;
+    icon?: string;
+    haveImage: boolean;
+}
+
+interface IAlertResponse {
+    id: string;
+    patient: IPatientResponse;
+    date: string;
+    eventType: IDictionaryTypeEventDTO;
+    annotation?: string;
+    value?: string;
+    priority?: string;
+}
+
+declare class ApiPatientService {
+    private gateway;
+    endpoint: string;
+    constructor(gateway: string);
+    http: HttpClient;
+    getPatients(): Observable<IPatientResponse[]>;
+    getPatientById(id: string): Observable<IPatientResponse>;
+    getPatientByFiscalCode(fiscalcode: string): Observable<IPatientResponse>;
+    getTargets(): Observable<ITargetResponse[]>;
+    getTargetByPatientId(patientId: string): Observable<ITargetResponse[]>;
+    getTargetByParameters(patientId: string | '', targetId: string | ''): Observable<ITargetResponse[]>;
+    getSettings(): Observable<ISettingResponse[]>;
+    getSettingByPatientId(patientId: string): Observable<ISettingResponse[]>;
+    getSettingById(id: number): Observable<ISettingResponse>;
+    getCaregivers(): Observable<ICaregiverDTO[]>;
+    getCaregiverById(id: string): Observable<ICaregiverDTO>;
+    getNotes(): Observable<IAnnotationResponse[]>;
+    getNotesByPatientId(patientId: string): Observable<IAnnotationResponse[]>;
+    getLogs(): Observable<IAnnotationResponse[]>;
+    getLogsByPatientId(patientId: string): Observable<IAnnotationResponse[]>;
+    getAlerts(): Observable<IAlertResponse[]>;
+    getAlertsByPatientId(patientId: string): Observable<IAlertResponse[]>;
+    postPatient(patientRequest: IPatientRequest): Observable<number>;
+    postTarget(targetRequest: ITargetResponse): Observable<boolean>;
+    postSetting(settingRequest: ISettingRequest): Observable<number>;
+    postCaregiver(dictionaryCaregiver: ICaregiverDTO): Observable<boolean>;
+    postNote(annotationRequest: IAnnotationRequest): Observable<string>;
+    postLog(annotationRequest: IAnnotationRequest): Observable<string>;
+    postRisk(riskRequest: IRiskDTO): Observable<boolean>;
+    putAlert(patientId: string): Observable<boolean>;
+    deletePatient(id: string): Observable<boolean>;
+    deleteSetting(id: number): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ApiPatientService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ApiPatientService>;
+}
+
+declare class ApiPatientDictionaryService {
+    private gateway;
+    endpoint: string;
+    constructor(gateway: string);
+    http: HttpClient;
+    getIdentifiers(): Observable<IDictionaryIdentifier[]>;
+    getDictionaryIdentifierById(identifierId: number): Observable<IDictionaryIdentifier>;
+    getDictionaryTypesAddress(): Observable<IDictionaryTypeAddress[]>;
+    getDictionaryTypeAddressById(addressId: number): Observable<IDictionaryTypeAddress>;
+    getDictionaryTypesContact(): Observable<IDictionaryTypeContact[]>;
+    getDictionaryTypeContactById(contactId: number): Observable<IDictionaryTypeContact>;
+    getSettingBySenderReceiver(sender: boolean, receiver: boolean): Observable<IDictionarySetting[]>;
+    getSettingById(id: string): Observable<IDictionarySetting>;
+    getSettingStatus(): Observable<IDictionarySettingStatus[]>;
+    getSettingStatusById(id: number): Observable<IDictionarySettingStatus>;
+    getTypeEvent(): Observable<IDictionaryTypeEventDTO[]>;
+    getTypeEventByCode(code: string): Observable<IDictionaryTypeEventDTO>;
+    getTypeEventById(id: string): Observable<IDictionaryTypeEventDTO>;
+    postDictionaryIdentifier(dictionaryIdentifierRequest: IDictionaryIdentifier): Observable<number>;
+    postDictionaryTypeAddress(dictionaryTypeAddressRequest: IDictionaryTypeAddress): Observable<number>;
+    postDictionaryTypeContact(dictionaryTypeContactRequest: IDictionaryTypeContact): Observable<number>;
+    postDictionarySetting(dictionarySetting: IDictionarySetting): Observable<string>;
+    postDictionarySettingStatus(dictionarySettingStatus: IDictionarySettingStatus): Observable<number>;
+    deleteIdentifier(identifierId: number): Observable<boolean>;
+    deleteTypeAddress(addressId: number): Observable<boolean>;
+    deleteTypeContact(contactId: number): Observable<boolean>;
+    deleteSetting(id: string): Observable<boolean>;
+    deleteStatus(id: number): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ApiPatientDictionaryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ApiPatientDictionaryService>;
+}
+
+interface IDictionaryPriority {
+    id: number;
+    name: string;
+    isEnabled: boolean;
+    isVisible: boolean;
+}
+
+interface IDictionaryTypeRequest {
+    id: number;
+    name: string;
+    isEnabled: boolean;
+    isVisible: boolean;
+    subTypeName: string;
+}
+
+interface IDTOEpicrisis {
+    anamnesis: string;
+    objectiveExam: string;
+    diagnosticQuestion: string;
+}
+
+interface IDTOKey {
+    id: string;
+    patientId: string;
+    accessId: string;
+    requestId: string;
+    patientPsId: string;
+    origin: string;
+}
+
+interface IDictionaryOutcome {
+    id: number;
+    name: string;
+    isEnabled: boolean;
+    isVisible: boolean;
+}
+
+interface IOutcomeResponse {
+    accountProfileId: string;
+    outcome: IDictionaryOutcome;
+    outcomeText: string;
+    date: Date;
+}
+
+interface IDictionaryStatus {
+    id: number;
+    name: string;
+    isEnabled: boolean;
+    isVisible: boolean;
+}
+
+interface IStatusResponse {
+    id: number;
+    status: IDictionaryStatus;
+    accountProfileId: string;
+    date: Date;
+}
+
+interface ISurveyResponse {
+    surveyId: string;
+    createDate: Date;
+}
+
+interface IRequestResponse {
+    key: IDTOKey;
+    type: IDictionaryTypeRequest;
+    status: IStatusResponse[];
+    outcome: IOutcomeResponse;
+    priority: IDictionaryPriority;
+    epicrisi: IDTOEpicrisis;
+    surveys: ISurveyResponse[];
+    hubId: string;
+    spokeId: string;
+    departmentId: string;
+    accountSpoke: string;
+    date: Date;
+}
+
+interface IRequestRequest {
+    key: string;
+    keyData: IDTOKey;
+    accountId: string;
+    profileId: string;
+    typeId: number;
+    hubId: string;
+    spokeId: string;
+    departmentId: string;
+    priorityId: number;
+    accountSpoke: string;
+    epicrisi: IDTOEpicrisis;
+}
+
+declare class ApiRequestService {
+    private gateway;
+    endpoint: string;
+    constructor(gateway: string);
+    http: HttpClient;
+    getRequests(): Observable<IRequestResponse[]>;
+    getRequestByParameters(statusId: string | "", typeId: string | ""): Observable<IRequestResponse[]>;
+    getRequestByKey(key: string): Observable<IRequestResponse>;
+    getRequestsByStatus(statusId: string): Observable<IRequestResponse>;
+    getRequestByType(typeId: number): Observable<IRequestResponse>;
+    postRequest(requestRequest: IRequestRequest, accountProfileId: string | ""): Observable<string>;
+    setRequestStatus(requestId: string, statusId: number, accountProfileId: string | ""): Observable<boolean>;
+    deleteRequest(key: string): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ApiRequestService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ApiRequestService>;
+}
+
+interface IOutcomeRequestTypeResponse {
+    id: string;
+    outcome: IDictionaryOutcome;
+    typeRequest: IDictionaryTypeRequest;
+}
+
+interface IOutcomeRequestTypeRequest {
+    id: number;
+    outcomeId: number;
+    typeRequestId: number;
+}
+
+declare class ApiRequestDictionaryService {
+    private gateway;
+    endpoint: string;
+    constructor(gateway: string);
+    http: HttpClient;
+    getKeys(): Observable<IDTOKey[]>;
+    getKeyByParameters(patientId: string | "", accessId: string | "", requestId: string | "", spoke: string | ""): Observable<IDTOKey[]>;
+    getKeyById(id: string): Observable<IDTOKey>;
+    getKeyByPatientId(patientId: string): Observable<IDTOKey>;
+    getKeyByAccessId(accessId: string): Observable<IDTOKey>;
+    getKeyByRequestId(requestId: string): Observable<IDTOKey>;
+    getKeyBySpoke(spoke: string): Observable<IDTOKey>;
+    getOutcomes(): Observable<IDictionaryOutcome[]>;
+    getOutcomeById(id: string): Observable<IDictionaryOutcome>;
+    getStatus(): Observable<IDictionaryStatus[]>;
+    getStatusById(id: string): Observable<IDictionaryStatus>;
+    getTypesRequest(): Observable<IDictionaryTypeRequest[]>;
+    getTypeRequestById(id: string): Observable<IDictionaryTypeRequest>;
+    getTypeRequestOutcome(): Observable<IOutcomeRequestTypeResponse[]>;
+    getTypeRequestOutcomeById(id: string): Observable<IOutcomeRequestTypeResponse>;
+    getPriorities(): Observable<IDictionaryPriority[]>;
+    getPriority(id: string): Observable<IDictionaryPriority>;
+    postKey(dictionaryKey: IDTOKey): Observable<number>;
+    postOutcome(dictionaryOutcome: IDictionaryOutcome): Observable<number>;
+    postStatus(dictionaryStatus: IDictionaryStatus): Observable<number>;
+    postTypeRequest(dictionaryTypeRequest: IDictionaryTypeRequest): Observable<number>;
+    postTypeRequestOutcome(dictionaryTypeRequestOutcome: IOutcomeRequestTypeRequest): Observable<number>;
+    postPriority(dictionaryPriority: IDictionaryPriority): Observable<number>;
+    putKey(dictionaryKey: IDTOKey): Observable<string>;
+    deleteKey(key: string): Observable<boolean>;
+    deleteOutcome(id: string): Observable<boolean>;
+    deleteStatus(id: string): Observable<boolean>;
+    deleteTypeRequest(id: string): Observable<boolean>;
+    deleteTypeRequestOutcome(id: string): Observable<boolean>;
+    deletePriority(id: string): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ApiRequestDictionaryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ApiRequestDictionaryService>;
+}
+
+interface IDTOAddress {
+    fullAddress: string;
+    street: string;
+    cap: string;
+    number: string;
+    aslId: string;
+}
+
+interface IDictionaryDepartment {
+    id?: string;
+    name: string;
+    code: string;
+    isEnabled: boolean;
+    isVisible: boolean;
+}
+
+interface IDepartmentResponse {
+    department: IDictionaryDepartment;
+    isEnabled: boolean;
+    isVisible: boolean;
+}
+
+interface IDictionaryTypeStructure {
+    id: number;
+    name: string;
+    siEnabled: boolean;
+    isVisible: boolean;
+}
+
+interface ITypeResponse {
+    type: IDictionaryTypeStructure;
+    isEnabled: boolean;
+    isVisible: boolean;
+}
+
+interface IStructureResponse {
+    id: string;
+    name: string;
+    code: string;
+    latitude: string;
+    longitude: string;
+    isEnabled: boolean;
+    isVisible: boolean;
+    address: IDTOAddress;
+    types: ITypeResponse[];
+    departments: IDepartmentResponse[];
+}
+
+interface IDepartmentRequest {
+    departmentId: string;
+    isEnabled: boolean;
+    isVisible: boolean;
+}
+
+interface ITypeRequest {
+    typeId: number;
+    isEnabled: boolean;
+    isVisible: boolean;
+}
+
+interface IStructureRequest {
+    id?: string;
+    name: string;
+    code: string;
+    latitude: string;
+    longitude: string;
+    isEnabled: boolean;
+    isVisible: boolean;
+    address: IDTOAddress;
+    types: ITypeRequest[];
+    departments: IDepartmentRequest[];
+}
+
+declare class ApiStructureService {
+    private gateway;
+    endpoint: string;
+    constructor(gateway: string);
+    http: HttpClient;
+    getStructures(): Observable<IStructureResponse[]>;
+    getRequestById(id: string): Observable<IStructureResponse>;
+    getStructureByDepartmentId(departmentId: string): Observable<IStructureResponse[]>;
+    postStructure(structureRequest: IStructureRequest): Observable<string>;
+    deleteStructure(id: string): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ApiStructureService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ApiStructureService>;
+}
+
+declare class ApiStructureDictionaryService {
+    private gateway;
+    endpoint: string;
+    constructor(gateway: string);
+    http: HttpClient;
+    getDepartments(): Observable<IDictionaryDepartment[]>;
+    getDepartmentById(id: string): Observable<IDictionaryDepartment>;
+    getDepartmentByCode(code: string): Observable<IDictionaryDepartment>;
+    getDepartmentByParameters(id: string, code: string): Observable<IDictionaryDepartment>;
+    getTypesStructure(): Observable<IDictionaryTypeStructure[]>;
+    getTypeStructureById(id: string): Observable<IDictionaryTypeStructure>;
+    postDepartment(departmentRequest: IDictionaryDepartment): Observable<string>;
+    postTypeStructure(typeStructureRequest: IDictionaryTypeStructure): Observable<string>;
+    deleteDepartment(id: string): Observable<boolean>;
+    deleteTypeStructure(id: string): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ApiStructureDictionaryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ApiStructureDictionaryService>;
+}
+
+declare class ApiSurveyDictionaryService {
+    private gateway;
+    endpoint: string;
+    constructor(gateway: string);
+    http: HttpClient;
+    getTypeQuestions(): Observable<IDictionaryTypeQuestionDTO[]>;
+    getTypeQuestionById(id: number): Observable<IDictionaryTypeQuestionDTO>;
+    getTypeSurveys(): Observable<IDictionaryTypeQuestionDTO[]>;
+    getTypeSurveyById(id: number): Observable<IDictionaryTypeSurveyDTO>;
+    getIcons(): Observable<IDictionaryIconDTO[]>;
+    getIconById(id: number): Observable<IDictionaryIconDTO>;
+    postTypeQuestion(dictionaryTypeQuestion: IDictionaryTypeQuestionDTO): Observable<number>;
+    postTypeSurvey(dictionarySurveyQuestion: IDictionaryTypeSurveyDTO): Observable<number>;
+    postIcon(dictionaryIcon: IDictionaryIconDTO): Observable<number>;
+    deleteTypeQuestion(id: number): Observable<boolean>;
+    deleteTypeSurvey(id: number): Observable<boolean>;
+    deleteIcon(id: number): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ApiSurveyDictionaryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ApiSurveyDictionaryService>;
+}
+
+interface IEventResponse {
+    date: string;
+    eventType?: string;
+    patientId: string;
+    macAddress?: string;
+    value?: string;
+    json?: string;
+}
+
+declare class ApiEventService {
+    private gateway;
+    endpoint: string;
+    constructor(gateway: string);
+    http: HttpClient;
+    getEventsByPatientIdStartEnd(patientId: string, start: string, end: string): Observable<IEventResponse[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ApiEventService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ApiEventService>;
+}
+
+declare const API_CONFIG: InjectionToken<unknown>;
+
+export { API_CONFIG, ApiAccountDictionaryService, ApiAccountService, ApiAdministrationService, ApiEventService, ApiExamAppointmentService, ApiExamDictionaryService, ApiExamService, ApiGeographyService, ApiKitService, ApiPatientDictionaryService, ApiPatientService, ApiRequestDictionaryService, ApiRequestService, ApiStructureDictionaryService, ApiStructureService, ApiSurveyDictionaryService, ApiSurveyService, BasicTable, Calendar, CalendarView, FormatDate, ItcLibrary20, Message, Minio, PRIMENG_ITALIAN_LOCALE, PrimaryButton, PrimengItalianLocale, SecondaryButton, SortableTable, Survey, SurveyRadio, SurveyText, SurveyValuebox, ThirdButton };
+export type { IAppointment, IColumn, IMinio, IQuestionAnswer };