import { type CallOptions, type ChannelCredentials, Client, type ClientOptions, type ClientReadableStream, type ClientUnaryCall, type handleServerStreamingCall, type handleUnaryCall, type Metadata, type ServiceError, type UntypedServiceImplementation } from "@grpc/grpc-js";
import { AnalysisFrames, CloseAnalysisSessionRequest, GetAnalysisFramesAfterTimestampRequest, GetAnalysisFramesBeforeTimestampRequest, GetAnalysisFramesBetweenTimestampsRequest, GetAnalysisSignalEnvelopesRequest, GetAnalysisSignalEnvelopesResponse, ListAnalysisSessionsResponse, OpenAnalysisSessionRequest, OpenAnalysisSessionResponse, SetAnalysisProcessingRequest, SetAnalysisProcessingResponse } from "./data_analysis_params";
import { Empty } from "./google/protobuf/empty";
/**
 * The data analysis service. Provides file-backed, session-keyed analysis of previously recorded
 * message log and signal log files, independent of any live measurement. Multiple sessions may be
 * open concurrently, each identified by a session id, to support analysing multiple log files at once.
 */
export type DataAnalysisServiceService = typeof DataAnalysisServiceService;
export declare const DataAnalysisServiceService: {
    /**
     * Opens a log file for analysis and returns a new session identifier along with basic file info.
     * @param request A request message with the log file to open.
     * @returns A response message with the new session's identifier and detected file info.
     */
    readonly openAnalysisSession: {
        readonly path: "/dataanalysisservice.DataAnalysisService/OpenAnalysisSession";
        readonly requestStream: false;
        readonly responseStream: false;
        readonly requestSerialize: (value: OpenAnalysisSessionRequest) => Buffer;
        readonly requestDeserialize: (value: Buffer) => OpenAnalysisSessionRequest;
        readonly responseSerialize: (value: OpenAnalysisSessionResponse) => Buffer;
        readonly responseDeserialize: (value: Buffer) => OpenAnalysisSessionResponse;
    };
    /**
     * Lists all currently open analysis sessions.
     * @returns A response message with all open sessions.
     */
    readonly listAnalysisSessions: {
        readonly path: "/dataanalysisservice.DataAnalysisService/ListAnalysisSessions";
        readonly requestStream: false;
        readonly responseStream: false;
        readonly requestSerialize: (value: Empty) => Buffer;
        readonly requestDeserialize: (value: Buffer) => Empty;
        readonly responseSerialize: (value: ListAnalysisSessionsResponse) => Buffer;
        readonly responseDeserialize: (value: Buffer) => ListAnalysisSessionsResponse;
    };
    /**
     * Replaces the entire data-processing pipeline (databases, filter, interpreter, extension steps, in order) for an analysis session.
     * @param request A request message with the session identifier and the ordered processing steps to apply.
     * @returns A response message with any per-step errors and any resulting frame definitions.
     */
    readonly setAnalysisProcessing: {
        readonly path: "/dataanalysisservice.DataAnalysisService/SetAnalysisProcessing";
        readonly requestStream: false;
        readonly responseStream: false;
        readonly requestSerialize: (value: SetAnalysisProcessingRequest) => Buffer;
        readonly requestDeserialize: (value: Buffer) => SetAnalysisProcessingRequest;
        readonly responseSerialize: (value: SetAnalysisProcessingResponse) => Buffer;
        readonly responseDeserialize: (value: Buffer) => SetAnalysisProcessingResponse;
    };
    /**
     * Gets frames from an analysis session before a specific timestamp, processed through the session's pipeline.
     * @param request A request message with the session identifier, timestamp and a max count.
     * @returns A stream of frames before the specified timestamp, the last message also carrying any frame
     * definition updates learned while reading.
     */
    readonly getAnalysisFramesBeforeTimestamp: {
        readonly path: "/dataanalysisservice.DataAnalysisService/GetAnalysisFramesBeforeTimestamp";
        readonly requestStream: false;
        readonly responseStream: true;
        readonly requestSerialize: (value: GetAnalysisFramesBeforeTimestampRequest) => Buffer;
        readonly requestDeserialize: (value: Buffer) => GetAnalysisFramesBeforeTimestampRequest;
        readonly responseSerialize: (value: AnalysisFrames) => Buffer;
        readonly responseDeserialize: (value: Buffer) => AnalysisFrames;
    };
    /**
     * Gets frames from an analysis session after a specific timestamp, processed through the session's pipeline.
     * @param request A request message with the session identifier, timestamp and a max count.
     * @returns A stream of frames after the specified timestamp, the last message also carrying any frame
     * definition updates learned while reading.
     */
    readonly getAnalysisFramesAfterTimestamp: {
        readonly path: "/dataanalysisservice.DataAnalysisService/GetAnalysisFramesAfterTimestamp";
        readonly requestStream: false;
        readonly responseStream: true;
        readonly requestSerialize: (value: GetAnalysisFramesAfterTimestampRequest) => Buffer;
        readonly requestDeserialize: (value: Buffer) => GetAnalysisFramesAfterTimestampRequest;
        readonly responseSerialize: (value: AnalysisFrames) => Buffer;
        readonly responseDeserialize: (value: Buffer) => AnalysisFrames;
    };
    /**
     * Gets frames from an analysis session between two timestamps, processed through the session's pipeline.
     * @param request A request message with the session identifier, timestamp range and a max count.
     * @returns A stream of frames between the specified timestamps, the last message also carrying any frame
     * definition updates learned while reading.
     */
    readonly getAnalysisFramesBetweenTimestamps: {
        readonly path: "/dataanalysisservice.DataAnalysisService/GetAnalysisFramesBetweenTimestamps";
        readonly requestStream: false;
        readonly responseStream: true;
        readonly requestSerialize: (value: GetAnalysisFramesBetweenTimestampsRequest) => Buffer;
        readonly requestDeserialize: (value: Buffer) => GetAnalysisFramesBetweenTimestampsRequest;
        readonly responseSerialize: (value: AnalysisFrames) => Buffer;
        readonly responseDeserialize: (value: Buffer) => AnalysisFrames;
    };
    /**
     * Gets downsampled signal time-series data (min/max envelopes) for a signal plot from an analysis session.
     * Works for signal log sessions directly, and for message log sessions with databases attached.
     * @param request A request message with the session identifier, timestamp range, view width and signal names.
     * @returns A response message with the signal envelopes.
     */
    readonly getAnalysisSignalEnvelopes: {
        readonly path: "/dataanalysisservice.DataAnalysisService/GetAnalysisSignalEnvelopes";
        readonly requestStream: false;
        readonly responseStream: false;
        readonly requestSerialize: (value: GetAnalysisSignalEnvelopesRequest) => Buffer;
        readonly requestDeserialize: (value: Buffer) => GetAnalysisSignalEnvelopesRequest;
        readonly responseSerialize: (value: GetAnalysisSignalEnvelopesResponse) => Buffer;
        readonly responseDeserialize: (value: Buffer) => GetAnalysisSignalEnvelopesResponse;
    };
    /**
     * Closes an analysis session, releasing its file handle and any server-side memory.
     * @param request A request message with the session identifier to close.
     * @returns An empty response message.
     */
    readonly closeAnalysisSession: {
        readonly path: "/dataanalysisservice.DataAnalysisService/CloseAnalysisSession";
        readonly requestStream: false;
        readonly responseStream: false;
        readonly requestSerialize: (value: CloseAnalysisSessionRequest) => Buffer;
        readonly requestDeserialize: (value: Buffer) => CloseAnalysisSessionRequest;
        readonly responseSerialize: (value: Empty) => Buffer;
        readonly responseDeserialize: (value: Buffer) => Empty;
    };
};
export interface DataAnalysisServiceServer extends UntypedServiceImplementation {
    /**
     * Opens a log file for analysis and returns a new session identifier along with basic file info.
     * @param request A request message with the log file to open.
     * @returns A response message with the new session's identifier and detected file info.
     */
    openAnalysisSession: handleUnaryCall<OpenAnalysisSessionRequest, OpenAnalysisSessionResponse>;
    /**
     * Lists all currently open analysis sessions.
     * @returns A response message with all open sessions.
     */
    listAnalysisSessions: handleUnaryCall<Empty, ListAnalysisSessionsResponse>;
    /**
     * Replaces the entire data-processing pipeline (databases, filter, interpreter, extension steps, in order) for an analysis session.
     * @param request A request message with the session identifier and the ordered processing steps to apply.
     * @returns A response message with any per-step errors and any resulting frame definitions.
     */
    setAnalysisProcessing: handleUnaryCall<SetAnalysisProcessingRequest, SetAnalysisProcessingResponse>;
    /**
     * Gets frames from an analysis session before a specific timestamp, processed through the session's pipeline.
     * @param request A request message with the session identifier, timestamp and a max count.
     * @returns A stream of frames before the specified timestamp, the last message also carrying any frame
     * definition updates learned while reading.
     */
    getAnalysisFramesBeforeTimestamp: handleServerStreamingCall<GetAnalysisFramesBeforeTimestampRequest, AnalysisFrames>;
    /**
     * Gets frames from an analysis session after a specific timestamp, processed through the session's pipeline.
     * @param request A request message with the session identifier, timestamp and a max count.
     * @returns A stream of frames after the specified timestamp, the last message also carrying any frame
     * definition updates learned while reading.
     */
    getAnalysisFramesAfterTimestamp: handleServerStreamingCall<GetAnalysisFramesAfterTimestampRequest, AnalysisFrames>;
    /**
     * Gets frames from an analysis session between two timestamps, processed through the session's pipeline.
     * @param request A request message with the session identifier, timestamp range and a max count.
     * @returns A stream of frames between the specified timestamps, the last message also carrying any frame
     * definition updates learned while reading.
     */
    getAnalysisFramesBetweenTimestamps: handleServerStreamingCall<GetAnalysisFramesBetweenTimestampsRequest, AnalysisFrames>;
    /**
     * Gets downsampled signal time-series data (min/max envelopes) for a signal plot from an analysis session.
     * Works for signal log sessions directly, and for message log sessions with databases attached.
     * @param request A request message with the session identifier, timestamp range, view width and signal names.
     * @returns A response message with the signal envelopes.
     */
    getAnalysisSignalEnvelopes: handleUnaryCall<GetAnalysisSignalEnvelopesRequest, GetAnalysisSignalEnvelopesResponse>;
    /**
     * Closes an analysis session, releasing its file handle and any server-side memory.
     * @param request A request message with the session identifier to close.
     * @returns An empty response message.
     */
    closeAnalysisSession: handleUnaryCall<CloseAnalysisSessionRequest, Empty>;
}
export interface DataAnalysisServiceClient extends Client {
    /**
     * Opens a log file for analysis and returns a new session identifier along with basic file info.
     * @param request A request message with the log file to open.
     * @returns A response message with the new session's identifier and detected file info.
     */
    openAnalysisSession(request: OpenAnalysisSessionRequest, callback: (error: ServiceError | null, response: OpenAnalysisSessionResponse) => void): ClientUnaryCall;
    openAnalysisSession(request: OpenAnalysisSessionRequest, metadata: Metadata, callback: (error: ServiceError | null, response: OpenAnalysisSessionResponse) => void): ClientUnaryCall;
    openAnalysisSession(request: OpenAnalysisSessionRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: OpenAnalysisSessionResponse) => void): ClientUnaryCall;
    /**
     * Lists all currently open analysis sessions.
     * @returns A response message with all open sessions.
     */
    listAnalysisSessions(request: Empty, callback: (error: ServiceError | null, response: ListAnalysisSessionsResponse) => void): ClientUnaryCall;
    listAnalysisSessions(request: Empty, metadata: Metadata, callback: (error: ServiceError | null, response: ListAnalysisSessionsResponse) => void): ClientUnaryCall;
    listAnalysisSessions(request: Empty, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: ListAnalysisSessionsResponse) => void): ClientUnaryCall;
    /**
     * Replaces the entire data-processing pipeline (databases, filter, interpreter, extension steps, in order) for an analysis session.
     * @param request A request message with the session identifier and the ordered processing steps to apply.
     * @returns A response message with any per-step errors and any resulting frame definitions.
     */
    setAnalysisProcessing(request: SetAnalysisProcessingRequest, callback: (error: ServiceError | null, response: SetAnalysisProcessingResponse) => void): ClientUnaryCall;
    setAnalysisProcessing(request: SetAnalysisProcessingRequest, metadata: Metadata, callback: (error: ServiceError | null, response: SetAnalysisProcessingResponse) => void): ClientUnaryCall;
    setAnalysisProcessing(request: SetAnalysisProcessingRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: SetAnalysisProcessingResponse) => void): ClientUnaryCall;
    /**
     * Gets frames from an analysis session before a specific timestamp, processed through the session's pipeline.
     * @param request A request message with the session identifier, timestamp and a max count.
     * @returns A stream of frames before the specified timestamp, the last message also carrying any frame
     * definition updates learned while reading.
     */
    getAnalysisFramesBeforeTimestamp(request: GetAnalysisFramesBeforeTimestampRequest, options?: Partial<CallOptions>): ClientReadableStream<AnalysisFrames>;
    getAnalysisFramesBeforeTimestamp(request: GetAnalysisFramesBeforeTimestampRequest, metadata?: Metadata, options?: Partial<CallOptions>): ClientReadableStream<AnalysisFrames>;
    /**
     * Gets frames from an analysis session after a specific timestamp, processed through the session's pipeline.
     * @param request A request message with the session identifier, timestamp and a max count.
     * @returns A stream of frames after the specified timestamp, the last message also carrying any frame
     * definition updates learned while reading.
     */
    getAnalysisFramesAfterTimestamp(request: GetAnalysisFramesAfterTimestampRequest, options?: Partial<CallOptions>): ClientReadableStream<AnalysisFrames>;
    getAnalysisFramesAfterTimestamp(request: GetAnalysisFramesAfterTimestampRequest, metadata?: Metadata, options?: Partial<CallOptions>): ClientReadableStream<AnalysisFrames>;
    /**
     * Gets frames from an analysis session between two timestamps, processed through the session's pipeline.
     * @param request A request message with the session identifier, timestamp range and a max count.
     * @returns A stream of frames between the specified timestamps, the last message also carrying any frame
     * definition updates learned while reading.
     */
    getAnalysisFramesBetweenTimestamps(request: GetAnalysisFramesBetweenTimestampsRequest, options?: Partial<CallOptions>): ClientReadableStream<AnalysisFrames>;
    getAnalysisFramesBetweenTimestamps(request: GetAnalysisFramesBetweenTimestampsRequest, metadata?: Metadata, options?: Partial<CallOptions>): ClientReadableStream<AnalysisFrames>;
    /**
     * Gets downsampled signal time-series data (min/max envelopes) for a signal plot from an analysis session.
     * Works for signal log sessions directly, and for message log sessions with databases attached.
     * @param request A request message with the session identifier, timestamp range, view width and signal names.
     * @returns A response message with the signal envelopes.
     */
    getAnalysisSignalEnvelopes(request: GetAnalysisSignalEnvelopesRequest, callback: (error: ServiceError | null, response: GetAnalysisSignalEnvelopesResponse) => void): ClientUnaryCall;
    getAnalysisSignalEnvelopes(request: GetAnalysisSignalEnvelopesRequest, metadata: Metadata, callback: (error: ServiceError | null, response: GetAnalysisSignalEnvelopesResponse) => void): ClientUnaryCall;
    getAnalysisSignalEnvelopes(request: GetAnalysisSignalEnvelopesRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: GetAnalysisSignalEnvelopesResponse) => void): ClientUnaryCall;
    /**
     * Closes an analysis session, releasing its file handle and any server-side memory.
     * @param request A request message with the session identifier to close.
     * @returns An empty response message.
     */
    closeAnalysisSession(request: CloseAnalysisSessionRequest, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
    closeAnalysisSession(request: CloseAnalysisSessionRequest, metadata: Metadata, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
    closeAnalysisSession(request: CloseAnalysisSessionRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
}
export declare const DataAnalysisServiceClient: {
    new (address: string, credentials: ChannelCredentials, options?: Partial<ClientOptions>): DataAnalysisServiceClient;
    service: typeof DataAnalysisServiceService;
    serviceName: string;
};