import { Observable } from 'rxjs';

type RSocketConnectionStatus = "CONNECTED" | "CONNECTING" | "CLOSED";
type RSocketBuffer = Uint8Array;
interface RSocketJsonCodec {
    encode(data?: unknown): RSocketBuffer;
    decode(raw: unknown): unknown;
}
interface RSocketConnectOptions {
    url: string;
    jwt?: string;
    keepAlive?: number;
    lifetime?: number;
    dataMimeType?: string;
}
interface RSocketReconnectOptions extends RSocketConnectOptions {
    maxRetry?: number;
    baseDelay?: number;
    maxDelay?: number;
    jitter?: number;
}
interface RSocketPayload<Data = RSocketBuffer> {
    data: Data;
    metadata?: RSocketBuffer;
}
interface RSocketSubscription {
    request(n: number): void;
    cancel(): void;
}
interface ReactiveSocketLike<Data = RSocketBuffer> {
    requestStream(payload: RSocketPayload<Data>): {
        subscribe(observer: {
            onComplete?: () => void;
            onError?: (err: unknown) => void;
            onNext?: (payload: RSocketPayload<Data>) => void;
            onSubscribe?: (subscription: RSocketSubscription) => void;
        }): void;
    };
    requestResponse(payload: RSocketPayload<Data>): {
        subscribe(observer: {
            onComplete?: (payload: RSocketPayload<Data>) => void;
            onError?: (err: unknown) => void;
            onSubscribe?: () => void;
        }): void;
    };
    connectionStatus(): {
        subscribe(observer: {
            onNext?: (status: {
                kind?: string;
            }) => void;
            onError?: (err: unknown) => void;
            onSubscribe?: () => void;
            onComplete?: () => void;
        }): void;
    };
    close?: () => void;
}
interface RSocketApiOptions {
    connector: RSocketReconnect;
    jwt?: string;
    codec?: RSocketJsonCodec;
    maxRequest?: number;
}
interface RSocketOperationLike {
    route?: string;
    interaction?: string;
    fireAndForget?: boolean;
    request?: unknown;
    response?: unknown;
}
type RSocketOperationsLike = object;
type RSocketRoute<Operations extends RSocketOperationsLike> = [
    Extract<keyof Operations, string>
] extends [never] ? string : Extract<keyof Operations, string>;
type RSocketOperationProperty<Operations extends RSocketOperationsLike, TRoute extends RSocketRoute<Operations>, TProperty extends string> = TRoute extends keyof Operations ? TProperty extends keyof Operations[TRoute] ? Operations[TRoute][TProperty] : unknown : unknown;
type RSocketOperationRequest<Operations extends RSocketOperationsLike, TRoute extends RSocketRoute<Operations>> = RSocketOperationProperty<Operations, TRoute, "request">;
type RSocketOperationResponse<Operations extends RSocketOperationsLike, TRoute extends RSocketRoute<Operations>> = RSocketOperationProperty<Operations, TRoute, "response">;
type RSocketOperationInteraction<Operations extends RSocketOperationsLike, TRoute extends RSocketRoute<Operations>> = RSocketOperationProperty<Operations, TRoute, "interaction"> extends string ? RSocketOperationProperty<Operations, TRoute, "interaction"> : string;
type RSocketRoutesByInteraction<Operations extends RSocketOperationsLike, TInteraction extends string> = string extends RSocketRoute<Operations> ? string : {
    [TRoute in RSocketRoute<Operations>]: RSocketOperationInteraction<Operations, TRoute> extends TInteraction ? TRoute : never;
}[RSocketRoute<Operations>];
type RSocketStreamRoute<Operations extends RSocketOperationsLike> = RSocketRoutesByInteraction<Operations, "requestStream">;
type RSocketMonoRoute<Operations extends RSocketOperationsLike> = RSocketRoutesByInteraction<Operations, "requestResponse">;
type IsUnknown<T> = unknown extends T ? [T] extends [unknown] ? true : false : false;
type RSocketRequestArgs<Operations extends RSocketOperationsLike, TRoute extends RSocketRoute<Operations>> = IsUnknown<RSocketOperationRequest<Operations, TRoute>> extends true ? [data?: unknown] : [RSocketOperationRequest<Operations, TRoute>] extends [void | undefined] ? [data?: RSocketOperationRequest<Operations, TRoute>] : {} extends RSocketOperationRequest<Operations, TRoute> ? [data?: RSocketOperationRequest<Operations, TRoute>] : [data: RSocketOperationRequest<Operations, TRoute>];
declare const defaultRSocketJsonCodec: RSocketJsonCodec;
declare const connectRSocket: (options: RSocketConnectOptions) => Promise<ReactiveSocketLike<RSocketBuffer>>;
declare class RSocketReconnect {
    private readonly options;
    private rsocket;
    private status;
    private retry;
    private manuallyClosed;
    private reconnectTimer;
    private connectingPromise;
    private readonly maxRetry;
    private readonly baseDelay;
    private readonly maxDelay;
    private readonly jitter;
    constructor(options: RSocketReconnectOptions);
    getStatus(): RSocketConnectionStatus;
    get(): Promise<ReactiveSocketLike<RSocketBuffer>>;
    private nextDelay;
    private connect;
    private handleClose;
    private scheduleReconnect;
    close(): void;
}
declare class RSocketApi<Operations extends RSocketOperationsLike = RSocketOperationsLike> {
    private readonly connector;
    private readonly jwt?;
    private readonly codec;
    private readonly maxRequest;
    constructor(options: RSocketApiOptions);
    private meta;
    private withSocket;
    stream<TRoute extends RSocketStreamRoute<Operations> & RSocketRoute<Operations>>(route: TRoute, data?: RSocketOperationRequest<Operations, TRoute>): Observable<RSocketOperationResponse<Operations, TRoute>>;
    stream<R = unknown>(route: string, data?: unknown): Observable<R>;
    mono<TRoute extends RSocketMonoRoute<Operations> & RSocketRoute<Operations>>(route: TRoute, data?: RSocketOperationRequest<Operations, TRoute>): Observable<RSocketOperationResponse<Operations, TRoute>>;
    mono<R = unknown>(route: string, data?: unknown): Observable<R>;
    close(): void;
}
declare function createRSocketApi<Operations extends RSocketOperationsLike = RSocketOperationsLike>(url: string, jwt?: string, options?: Omit<RSocketReconnectOptions, "url" | "jwt"> & Pick<RSocketApiOptions, "codec" | "maxRequest">): RSocketApi<Operations>;

export { RSocketApi, type RSocketApiOptions, type RSocketBuffer, type RSocketConnectOptions, type RSocketConnectionStatus, type RSocketJsonCodec, type RSocketMonoRoute, type RSocketOperationInteraction, type RSocketOperationLike, type RSocketOperationRequest, type RSocketOperationResponse, type RSocketOperationsLike, type RSocketPayload, RSocketReconnect, type RSocketReconnectOptions, type RSocketRequestArgs, type RSocketRoute, type RSocketRoutesByInteraction, type RSocketStreamRoute, type RSocketSubscription, type ReactiveSocketLike, connectRSocket, createRSocketApi, defaultRSocketJsonCodec };