import type { CallOptions } from './options';
export interface IResponseStream<T> {
    on: ((event: 'data', fn: (item: T) => void) => this) & ((event: 'end', fn: () => void) => this) & ((event: 'status', fn: (status: any) => void) => this) & ((event: 'error', fn: (err: Error) => void) => this);
}
export interface IRequestStream<T> {
    write: (item: T) => void;
    end: () => void;
    cancel: () => void;
}
export interface IDuplexStream<T, R> extends IRequestStream<T>, IResponseStream<R> {
}
export interface IKVClient {
    range: (req: IRangeRequest, options?: CallOptions) => Promise<IRangeResponse>;
    put: (req: IPutRequest, options?: CallOptions) => Promise<IPutResponse>;
    deleteRange: (req: IDeleteRangeRequest, options?: CallOptions) => Promise<IDeleteRangeResponse>;
    txn: (req: ITxnRequest, options?: CallOptions) => Promise<ITxnResponse>;
}
export interface IWatchClient {
    watch: (options?: CallOptions) => Promise<IDuplexStream<IWatchRequest, IWatchResponse>>;
}
export interface ILeaseClient {
    leaseGrant: (req: ILeaseGrantRequest, options?: CallOptions) => Promise<ILeaseGrantResponse>;
    leaseRevoke: (req: ILeaseRevokeRequest, options?: CallOptions) => Promise<ILeaseRevokeResponse>;
    leaseKeepAlive: (options?: CallOptions) => Promise<IDuplexStream<ILeaseKeepAliveRequest, ILeaseKeepAliveResponse>>;
    leaseTimeToLive: (req: ILeaseTimeToLiveRequest, options?: CallOptions) => Promise<ILeaseTimeToLiveResponse>;
    leaseLeases: (options?: CallOptions) => Promise<ILeaseLeasesResponse>;
}
export interface IResponseHeader {
    cluster_id: string;
    member_id: string;
    revision: string;
    raft_term: string;
}
export declare enum SortOrder {
    None = 0,
    Ascend = 1,
    Descend = 2
}
export declare enum SortTarget {
    Key = 0,
    Version = 1,
    Create = 2,
    Mod = 3,
    Value = 4
}
export interface IRangeRequest {
    key: Buffer;
    range_end?: Buffer;
    limit?: string | number;
    revision?: string | number;
    sort_order?: SortOrder | keyof typeof SortOrder;
    sort_target?: SortTarget | keyof typeof SortTarget;
    serializable?: boolean;
    keys_only?: boolean;
    count_only?: boolean;
    min_mod_revision?: string | number;
    max_mod_revision?: string | number;
    min_create_revision?: string | number;
    max_create_revision?: string | number;
}
export interface IRangeResponse {
    header: IResponseHeader;
    kvs: IKeyValue[];
    more: boolean;
    count: string;
}
export interface IPutRequest {
    key: Buffer;
    value?: Buffer;
    lease?: string | number;
    prev_kv?: boolean;
    ignore_value?: boolean;
    ignore_lease?: boolean;
}
export interface IPutResponse {
    header: IResponseHeader;
    prev_kv: IKeyValue;
}
export interface IDeleteRangeRequest {
    key: Buffer;
    range_end?: Buffer;
    prev_kv?: boolean;
}
export interface IDeleteRangeResponse {
    header: IResponseHeader | undefined;
    deleted: string;
    prev_kvs: IKeyValue[];
}
export interface IRequestOp {
    request_range?: IRangeRequest;
    request_put?: IPutRequest;
    request_delete_range?: IDeleteRangeRequest;
    request_txn?: ITxnRequest;
}
export interface IResponseOp {
    response_range: IRangeResponse;
    response_put: IPutResponse;
    response_delete_range: IDeleteRangeResponse;
    response_txn: ITxnResponse;
}
export declare enum CompareResult {
    Equal = 0,
    Greater = 1,
    Less = 2,
    NotEqual = 3
}
export declare enum CompareTarget {
    Version = 0,
    Create = 1,
    Mod = 2,
    Value = 3,
    Lease = 4
}
export interface ICompare {
    result?: CompareResult | keyof typeof CompareResult;
    target?: CompareTarget | keyof typeof CompareTarget;
    key?: Buffer;
    version?: string | number;
    create_revision?: string | number;
    mod_revision?: string | number;
    value?: Buffer;
    lease?: string | number;
    range_end?: Buffer;
}
export interface ITxnRequest {
    compare?: ICompare[];
    success?: IRequestOp[];
    failure?: IRequestOp[];
}
export interface ITxnResponse {
    header: IResponseHeader;
    succeeded: boolean;
    responses: IResponseOp[];
}
export interface ICompactionRequest {
    revision?: string | number;
    physical?: boolean;
}
export interface ICompactionResponse {
    header: IResponseHeader;
}
export interface IHashRequest {
}
export interface IHashKVRequest {
    revision?: string | number;
}
export interface IHashKVResponse {
    header: IResponseHeader;
    hash: string;
    compact_revision: string;
}
export interface IHashResponse {
    header: IResponseHeader;
    hash: string;
}
export interface ISnapshotRequest {
}
export interface ISnapshotResponse {
    header: IResponseHeader;
    remaining_bytes: string;
    blob: Buffer;
}
export interface IWatchRequest {
    create_request?: IWatchCreateRequest;
    cancel_request?: IWatchCancelRequest;
    progress_request?: IWatchProgressRequest;
}
export declare enum FilterType {
    Noput = 0,
    Nodelete = 1
}
export interface IWatchCreateRequest {
    key?: Buffer;
    range_end?: Buffer;
    start_revision?: string | number;
    progress_notify?: boolean;
    filters?: Array<FilterType | keyof typeof FilterType>;
    prev_kv?: boolean;
    watch_id?: string | number;
    fragment?: boolean;
}
export interface IWatchCancelRequest {
    watch_id?: string | number;
}
export interface IWatchProgressRequest {
}
export interface IWatchResponse {
    header: IResponseHeader;
    watch_id: string;
    created: boolean;
    canceled: boolean;
    compact_revision: string;
    cancel_reason: string;
    fragment: boolean;
    events: IEvent[];
}
export interface ILeaseGrantRequest {
    TTL?: string | number;
    ID?: string | number;
}
export interface ILeaseGrantResponse {
    header: IResponseHeader;
    ID: string;
    TTL: string;
    error: string;
}
export interface ILeaseRevokeRequest {
    ID?: string | number;
}
export interface ILeaseRevokeResponse {
    header: IResponseHeader;
}
export interface ILeaseCheckpoint {
    ID?: string | number;
    remaining_TTL?: string | number;
}
export interface ILeaseCheckpointRequest {
    checkpoints?: ILeaseCheckpoint[];
}
export interface ILeaseCheckpointResponse {
    header?: IResponseHeader;
}
export interface ILeaseKeepAliveRequest {
    ID?: string | number;
}
export interface ILeaseKeepAliveResponse {
    header: IResponseHeader;
    ID: string;
    TTL: string;
}
export interface ILeaseTimeToLiveRequest {
    ID?: string | number;
    keys?: boolean;
}
export interface ILeaseTimeToLiveResponse {
    header: IResponseHeader;
    ID: string;
    TTL: string;
    grantedTTL: string;
    keys: Buffer[];
}
export interface ILeaseLeasesRequest {
}
export interface ILeaseStatus {
    ID: string;
}
export interface ILeaseLeasesResponse {
    header: IResponseHeader;
    leases: ILeaseStatus[];
}
export interface IKeyValue {
    key: Buffer;
    create_revision: string;
    mod_revision: string;
    version: string;
    value: Buffer;
    lease: string;
}
export declare enum EventType {
    Put = 0,
    Delete = 1
}
export interface IEvent {
    type: keyof typeof EventType;
    kv: IKeyValue;
    prev_kv?: IKeyValue;
}
export interface IServices {
    KV: IKVClient;
    Watch: IWatchClient;
    Lease: ILeaseClient;
}
export type CallContext = {
    service: 'KV';
    method: 'range';
    isStream: false;
    params: IRangeRequest;
} | {
    service: 'KV';
    method: 'put';
    isStream: false;
    params: IPutRequest;
} | {
    service: 'KV';
    method: 'deleteRange';
    isStream: false;
    params: IDeleteRangeRequest;
} | {
    service: 'KV';
    method: 'txn';
    isStream: false;
    params: ITxnRequest;
} | {
    service: 'Watch';
    method: 'watch';
    isStream: true;
} | {
    service: 'Lease';
    method: 'leaseGrant';
    isStream: false;
    params: ILeaseGrantRequest;
} | {
    service: 'Lease';
    method: 'leaseRevoke';
    isStream: false;
    params: ILeaseRevokeRequest;
} | {
    service: 'Lease';
    method: 'leaseKeepAlive';
    isStream: true;
} | {
    service: 'Lease';
    method: 'leaseTimeToLive';
    isStream: false;
    params: ILeaseTimeToLiveRequest;
} | {
    service: 'Lease';
    method: 'leaseLeases';
    isStream: false;
};
export type CallMethod = CallContext['method'];
export type CallService = CallContext['service'];