import { AuthClient } from "../auth/auth-client.js";
export type LastValuePayload = {
    topic: string;
    value: unknown;
    values?: Record<string, unknown> | null;
    uom?: string | null;
    timestamp?: string | null;
    dataGroup?: string | null;
    ageMs?: number | null;
    source: string;
};
export type CatchAllTimeField = "auto" | "timestamp" | "interval";
export type CatchAllAggregate = "avg" | "min" | "max" | "last" | "sum" | "count";
export type RangeQueryOptions = {
    table?: string;
    from?: string;
    to?: string;
    timeField?: CatchAllTimeField;
    limit?: number;
    maxPoints?: number;
    bucketMs?: number;
    aggregate?: CatchAllAggregate;
    column?: string;
    summaryOnly?: boolean;
    dedupe?: boolean;
};
export type RangeColumn = {
    name: string;
    type?: string;
};
export type RangeStats = Record<string, unknown> & {
    raw?: {
        columns?: RangeColumn[];
    };
};
export type RangePayload<Row extends unknown[] = unknown[]> = {
    data: Row[];
    stats?: RangeStats | null;
};
export type BatchRangeTopicPayload<Row extends unknown[] = unknown[]> = {
    topic: string;
    error?: string | null;
    data: Row[];
    stats?: RangeStats | null;
};
export type BatchRangeResponsePayload<Row extends unknown[] = unknown[]> = {
    results: BatchRangeTopicPayload<Row>[];
    stats?: Record<string, unknown> | null;
};
export declare class RangeResult<Row extends unknown[] = unknown[]> {
    readonly data: Row[];
    readonly stats?: RangeStats | null;
    constructor(payload: RangePayload<Row>);
    static fromMapping<Row extends unknown[] = unknown[]>(value: Record<string, unknown>): RangeResult<Row>;
    get columns(): RangeColumn[];
    toRecords(): Array<Record<string, unknown>>;
    toObject(): RangePayload<Row>;
}
export declare class BatchRangeTopicResult<Row extends unknown[] = unknown[]> extends RangeResult<Row> {
    readonly topic: string;
    readonly error?: string | null;
    constructor(payload: BatchRangeTopicPayload<Row>);
    static fromMapping<Row extends unknown[] = unknown[]>(value: Record<string, unknown>): BatchRangeTopicResult<Row>;
    toObject(): BatchRangeTopicPayload<Row>;
}
export declare class BatchRangeResponse<Row extends unknown[] = unknown[]> {
    readonly results: BatchRangeTopicResult<Row>[];
    readonly stats?: Record<string, unknown> | null;
    constructor(payload: BatchRangeResponsePayload<Row>);
    static fromMapping<Row extends unknown[] = unknown[]>(value: Record<string, unknown>): BatchRangeResponse<Row>;
    get byTopic(): Record<string, BatchRangeTopicPayload<Row>>;
    toObject(): BatchRangeResponsePayload<Row>;
}
export declare class LastValueResult {
    readonly topic: string;
    readonly value: unknown;
    readonly values?: Record<string, unknown> | null;
    readonly uom?: string | null;
    readonly timestamp?: string | null;
    readonly dataGroup?: string | null;
    readonly ageMs?: number | null;
    readonly source: string;
    constructor(payload: LastValuePayload);
    static fromMapping(value: Record<string, unknown>): LastValueResult;
    get hit(): boolean;
    toObject(): LastValuePayload;
}
export declare class ClientError extends Error {
    readonly statusCode?: number;
    constructor(message: string, statusCode?: number);
}
export type UnsClientOptions = {
    apiBasePath?: string;
    token?: string;
    timeoutMs?: number;
    authClient?: AuthClient;
};
export type RequestOptions = {
    baseUrl?: string;
    authorize?: boolean;
};
export declare class UnsClient {
    private readonly apiBasePath;
    private readonly baseUrl;
    private readonly apiUrl;
    private readonly timeoutMs;
    private readonly authClient?;
    private manualAccessToken?;
    constructor(baseUrl: string, options?: UnsClientOptions);
    setToken(token?: string): void;
    ensureToken(): Promise<string | undefined>;
    get(endpoint: string, params?: Record<string, string | number | boolean>, options?: RequestOptions): Promise<Response>;
    getData(endpoint: string, params?: Record<string, string | number | boolean>, options?: RequestOptions): Promise<Response>;
    post(endpoint: string, body?: Record<string, unknown>, options?: RequestOptions): Promise<Record<string, unknown>>;
    lastValue(topics: string | string[], options?: {
        token?: string;
    }): Promise<Record<string, LastValuePayload> | null>;
    getAttributeData<Row extends unknown[] = unknown[]>(topicPath: string, options?: RangeQueryOptions & {
        token?: string;
    }): Promise<RangeResult<Row> | null>;
    history<Row extends unknown[] = unknown[]>(topics: string | string[], options?: RangeQueryOptions & {
        token?: string;
    }): Promise<BatchRangeResponse<Row> | null>;
    private requestJson;
    private request;
    private buildUrl;
    private stringifyQueryParams;
    private buildQuerySuffix;
    private static normalizeBasePath;
}
//# sourceMappingURL=datahub-client.d.ts.map