import { ColumnGroup } from '../components/data-table';

export interface PerMeasurementConfig {
    formula?: string;
    aggregation?: 'avg' | 'sum' | 'min' | 'max' | 'last' | 'cumulativeSum';
    cumulativeSumStartDate?: string;
}
export interface NestedPerMeasurementConfigs {
    [columnGroupId: string]: Record<string, PerMeasurementConfig>;
}
interface MeasurementParams {
    measurements: string[];
    startTime: string;
    endTime: string;
    interval?: 'raw' | 'hourly' | 'daily' | 'weekly' | 'monthly';
    aggregation?: 'avg' | 'sum' | 'min' | 'max';
    limit?: number;
    after?: string;
    before?: string;
    measurementConfigs?: NestedPerMeasurementConfigs;
}
interface MeasurementMetadata {
    name: string;
    unit: string;
    deviceName: string;
    sensorName: string;
}
interface MeasurementResponse {
    data: Array<{
        timestamp: string;
        [key: string]: string | number;
    }>;
    metadata: {
        measurements: {
            [key: string]: MeasurementMetadata;
        };
    };
    pagination: {
        next?: {
            after: string;
            limit: number;
        };
        previous?: {
            before: string;
            limit: number;
        };
    };
}
interface ComparisonParams {
    measurements: string[];
    startTime: string;
    endTime: string;
    aggregation: 'avg' | 'sum' | 'min' | 'max';
    columnGroups?: ColumnGroup[];
    measurementConfigs?: NestedPerMeasurementConfigs;
}
interface ComparisonResponse {
    data: Array<{
        device_id: string;
        device_name: string;
        device_serial: string;
        measurements: {
            [columnId: string]: number;
        };
    }>;
    metadata: {
        columns: Array<{
            id: string;
            name: string;
            sensors: Array<{
                id: string;
                name: string;
                port: string;
            }>;
            applied_aggregation: 'avg' | 'sum' | 'min' | 'max';
        }>;
        devices: {
            [deviceId: string]: {
                name: string;
                serial: string;
            };
        };
    };
    time_period?: string;
    column_groups?: ColumnGroup[];
    custom_titles?: Record<string, string>;
    timeseries_removed_measurements?: string[];
    per_measurement_configs?: NestedPerMeasurementConfigs;
}
interface FetchDevicesParams {
    page?: number;
    page_size?: number;
    search?: string;
    include_sensors?: boolean;
    include_extracts?: boolean;
    device_ids?: string;
}
interface FetchMeasurementsParams {
    page?: number;
    page_size?: number;
    search?: string;
    device_ids?: string;
    measurement_ids?: string[];
}
export declare function fetchDevices({ page, page_size, search, include_sensors, include_extracts, device_ids }?: FetchDevicesParams): Promise<any>;
export declare function fetchDevicesLite({ page, page_size, search }?: Pick<FetchDevicesParams, 'page' | 'page_size' | 'search'>): Promise<any>;
export declare function fetchMeasurementsList({ page, page_size, search, device_ids, measurement_ids }?: FetchMeasurementsParams): Promise<any>;
export declare const fetchMeasurementsTimeseries: (params: MeasurementParams) => Promise<MeasurementResponse>;
export declare const fetchMeasurementsComparison: ({ measurements, startTime, endTime, aggregation, columnGroups, measurementConfigs }: ComparisonParams) => Promise<ComparisonResponse>;
export interface DataExplorer {
    id: string;
    name: string;
    created_at: string;
    updated_at: string;
    view_mode: "time_series" | "device_comparison";
    sampling_interval: string;
    selected_measurements: string[];
    column_formulas: Record<string, string>;
    date_range_start: string;
    date_range_end: string;
    aggregation?: string;
    time_period?: string;
    column_groups?: ColumnGroup[];
    custom_titles?: Record<string, string>;
    timeseries_removed_measurements?: string[];
}
export interface CreateDataExplorerRequest {
    name: string;
    view_mode: "time_series" | "device_comparison";
    sampling_interval: string;
    selected_measurements: string[];
    column_formulas?: Record<string, string>;
    date_range_start: string;
    date_range_end: string;
    time_period?: string;
    aggregation?: string;
    column_groups?: ColumnGroup[];
    custom_titles?: Record<string, string>;
    timeseries_removed_measurements?: string[];
    per_measurement_configs?: NestedPerMeasurementConfigs;
}
export declare const dataExplorerApi: {
    list: () => Promise<any>;
    create: (data: CreateDataExplorerRequest) => Promise<any>;
    get: (id: string) => Promise<any>;
    update: (id: string, data: Partial<CreateDataExplorerRequest>) => Promise<any>;
    delete: (id: string) => Promise<any>;
};
export declare const debouncedSaveDataExplorer: import('lodash').DebouncedFunc<(id: string, data: Partial<CreateDataExplorerRequest>, onSuccess?: () => void, onError?: (error: Error) => void) => Promise<void>>;
export {};