import { DataCollection } from '../../models/data-collection';
import { GalenChartDataPoint } from '../../interfaces/galen-chart-data-point';
import { GalenChartDataPointsWithFeatures } from '../../interfaces/galen-chart-data-points-with-features';
import { ActivityLog } from '../../models/activity-log';
import { PatientInfo } from '../../models/patient-info';
import { GalenUser } from '../../models/galen-user';
import { DataModelType } from '../../enums/data-model-type';
import { IcpRecord } from '../../models/icp-record';
import { SurgeryDetails } from '../../models/surgery-details';
import * as i0 from "@angular/core";
export declare class GalenDataService {
    private galenHttpService;
    /** Contains the userId of the patient whose data you want to filter for */
    private ownerId;
    private dataCollectionTable;
    private dataCollectionIdToIcpRecords;
    private deviceId;
    private dataModelData;
    constructor();
    private getDeviceId;
    private getDataModelIdAsync;
    /**
     * Returns a sorted copy of the given [records] based on each entry's given [timestampProperty] key inside of their `RecordData.record` Map
     * @param records The records to sort. Each entry's `RecordData.record` map MUST contain [timestampProperty] as a key
     * @param removeUndefined A flag to indicate whether the function should remove any records that have `undefined` as their [timestampProperty]
     * @param timestampProperty
     * @returns RecordData[] - The sorted record data
     */
    private sortRecordsOnTimestamp;
    /**
     * Fetches all the unique values belonging to a property
     * @param ownerId UUID of the account whose data you want to fetch
     * @param dataModel The data model to fetch from
     * @param propertyCode The property in [dataModel] whose unique values you want
     * @returns any[] - An array of unique values belonging to this propertyCode
     */
    getUniqueValues(ownerId: string, dataModel: DataModelType, propertyCode: string): Promise<any[]>;
    getWandAndImplantIdToSerialNumber(): Promise<{
        wandData: Map<number, string>;
        implantData: Map<number, number>;
    }>;
    getWandIdToSerialNumber(): Promise<Map<number, string>>;
    getImplantIdToSerialNumber(): Promise<Map<number, number>>;
    joinDataModels(ownerId: string, headers: Map<string, {
        table: 'primary' | 'foreign';
        property: string;
    }>, foreignKeyRelationship: {
        primaryKeyProp: string;
        foreignKeyProp: string;
    }, tables: {
        primaryTable: DataModelType;
        foreignTable: DataModelType;
    }, headerToSortBy: string, timestampRange?: {
        primaryTableProperty: string;
        foreignTableProperty: string;
        startDateTime?: Date;
        endDateTime?: Date;
    }, sortBy?: {
        primaryTableAttribute?: string;
        foreignTableAttribute: string;
        sortOrder: 'ASC' | 'DESC';
    }): Promise<{
        tableData: Map<string, string[]>;
        rowCount: number;
    }>;
    getIcpRecords(ownerId: string, pageNumber?: number, pageSize?: number, sortOrder?: 'DESC' | 'ASC'): Promise<{
        icpRecords: IcpRecord[];
        totalElements: number;
        totalPages: number;
    }>;
    /**
     * Fetches all the rows of data in the ActivityLogs data model that match the provided filters
     * for the current patient.
     * @param ownerId The patientId of the Galen account to filter for
     * @param timestampStartDateTime The start-date filter to apply to the dataModel's 'Timestamp' property
     * when fetching the data-rows from Galen
     * @param timestampEndDateTime The end-date filter to apply to the dataModel's 'Timestamp' property
     * when fetching the data-rows from Galen
     * @param pageNumber The page number of the page of data you would like to retrieve from Galen
     * @param pageSize The size of each page of data
     * @returns Promise<{ activityLogs: ActivityLog[]; totalElements: number; }> - A Promise containing the
     * given `pageNumber`'s page-data, along with the total number of rows that satisfy the given filters
     * for this patient
     */
    getActivityRows(ownerId: string, timestampStartDateTime?: Date, timestampEndDateTime?: Date, pageNumber?: number, pageSize?: number, sortOrder?: 'ASC' | 'DESC'): Promise<{
        activityLogs: ActivityLog[];
        totalElements: number;
        totalPages: number;
    }>;
    getSymptomPoints(): Promise<{
        data: Map<string, GalenChartDataPoint[]>;
        minDate?: Date;
        maxDate?: Date;
    }>;
    getBloodPressurePoints(): {
        data: Map<string, GalenChartDataPoint[]>;
        minDate: Date;
        maxDate: Date;
    };
    getMeanIcpPoints(timestampStartDateTime?: Date, timestampEndDateTime?: Date): Promise<GalenChartDataPoint[]>;
    getBodyTemperaturePoints(): GalenChartDataPointsWithFeatures<Date>;
    getFeelingRatingPoints(): GalenChartDataPointsWithFeatures<Date>;
    getPatientPositionPoints(): GalenChartDataPointsWithFeatures<Date>;
    getIcpRecordPoints(dataCollectionId: string): Promise<GalenChartDataPointsWithFeatures<number>>;
    getPatientInformation(): Promise<PatientInfo>;
    /**
     * Fetches the user information belonging to [this.patientId]
     * @returns Promise<GalenUser>
     */
    getGalenUserInformation(): Promise<GalenUser>;
    getPatientData: () => Promise<{
        patientUser?: GalenUser;
        patientName?: string;
        patientInfo?: PatientInfo;
    }>;
    /**
     * Fetches the user information belonging to the currently logged in user
     * @returns Promise<GalenUser>
     */
    getMyGalenUserInformation(): Promise<GalenUser>;
    getDataCollectionItem(key: string): DataCollection;
    getSurgeryDetails(): Promise<SurgeryDetails>;
    private getDataCollectionRecords;
    setOwnerId(ownerId: string): void;
    private extractDataCollectionProperty;
    static ɵfac: i0.ɵɵFactoryDeclaration<GalenDataService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<GalenDataService>;
}