///
import { EventEmitter } from 'events';
import * as http2 from 'http2';
import { Duplex, Readable, Writable } from 'stream';
import { StatusObject } from './call-stream';
import { Deserialize, Serialize } from './make-client';
import { Metadata } from './metadata';
import { ObjectReadable, ObjectWritable } from './object-stream';
export declare type ServerStatusResponse = Partial;
export declare type ServerErrorResponse = ServerStatusResponse & Error;
export declare type ServerSurfaceCall = {
cancelled: boolean;
getPeer(): string;
sendMetadata(responseMetadata: Metadata): void;
} & EventEmitter;
export declare type ServerUnaryCall = ServerSurfaceCall & {
request: RequestType | null;
};
export declare type ServerReadableStream = ServerSurfaceCall & ObjectReadable;
export declare type ServerWritableStream = ServerSurfaceCall & ObjectWritable & {
request: RequestType | null;
};
export declare type ServerDuplexStream = ServerSurfaceCall & ObjectReadable & ObjectWritable;
export declare class ServerUnaryCallImpl extends EventEmitter implements ServerUnaryCall {
private call;
metadata: Metadata;
cancelled: boolean;
request: RequestType | null;
constructor(call: Http2ServerCallStream, metadata: Metadata);
getPeer(): string;
sendMetadata(responseMetadata: Metadata): void;
}
export declare class ServerReadableStreamImpl extends Readable implements ServerReadableStream {
private call;
metadata: Metadata;
deserialize: Deserialize;
cancelled: boolean;
constructor(call: Http2ServerCallStream, metadata: Metadata, deserialize: Deserialize);
_read(size: number): void;
getPeer(): string;
sendMetadata(responseMetadata: Metadata): void;
}
export declare class ServerWritableStreamImpl extends Writable implements ServerWritableStream {
private call;
metadata: Metadata;
serialize: Serialize;
cancelled: boolean;
request: RequestType | null;
private trailingMetadata;
constructor(call: Http2ServerCallStream, metadata: Metadata, serialize: Serialize);
getPeer(): string;
sendMetadata(responseMetadata: Metadata): void;
_write(chunk: ResponseType, encoding: string, callback: (...args: any[]) => void): Promise;
_final(callback: Function): void;
end(metadata?: any): void;
}
export declare class ServerDuplexStreamImpl extends Duplex implements ServerDuplexStream {
private call;
metadata: Metadata;
serialize: Serialize;
deserialize: Deserialize;
cancelled: boolean;
private trailingMetadata;
constructor(call: Http2ServerCallStream, metadata: Metadata, serialize: Serialize, deserialize: Deserialize);
getPeer(): string;
sendMetadata(responseMetadata: Metadata): void;
}
export declare type sendUnaryData = (error: ServerErrorResponse | ServerStatusResponse | null, value: ResponseType | null, trailer?: Metadata, flags?: number) => void;
export declare type handleUnaryCall = (call: ServerUnaryCall, callback: sendUnaryData) => void;
export declare type handleClientStreamingCall = (call: ServerReadableStream, callback: sendUnaryData) => void;
export declare type handleServerStreamingCall = (call: ServerWritableStream) => void;
export declare type handleBidiStreamingCall = (call: ServerDuplexStream) => void;
export declare type HandleCall = handleUnaryCall | handleClientStreamingCall | handleServerStreamingCall | handleBidiStreamingCall;
export interface UnaryHandler {
func: handleUnaryCall;
serialize: Serialize;
deserialize: Deserialize;
type: HandlerType;
}
export interface ClientStreamingHandler {
func: handleClientStreamingCall;
serialize: Serialize;
deserialize: Deserialize;
type: HandlerType;
}
export interface ServerStreamingHandler {
func: handleServerStreamingCall;
serialize: Serialize;
deserialize: Deserialize;
type: HandlerType;
}
export interface BidiStreamingHandler {
func: handleBidiStreamingCall;
serialize: Serialize;
deserialize: Deserialize;
type: HandlerType;
}
export declare type Handler = UnaryHandler | ClientStreamingHandler | ServerStreamingHandler | BidiStreamingHandler;
export declare type HandlerType = 'bidi' | 'clientStream' | 'serverStream' | 'unary';
export declare class Http2ServerCallStream extends EventEmitter {
private stream;
private handler;
cancelled: boolean;
deadline: NodeJS.Timer;
private wantTrailers;
private metadataSent;
private canPush;
private isPushPending;
private bufferedMessages;
private messagesToPush;
constructor(stream: http2.ServerHttp2Stream, handler: Handler);
sendMetadata(customMetadata?: Metadata): void;
receiveMetadata(headers: http2.IncomingHttpHeaders): Metadata | undefined;
receiveUnaryMessage(): Promise;
serializeMessage(value: ResponseType): Buffer;
deserializeMessage(bytes: Buffer): Promise;
sendUnaryMessage(err: ServerErrorResponse | ServerStatusResponse | null, value: ResponseType | null, metadata?: Metadata, flags?: number): Promise;
sendStatus(statusObj: StatusObject): void;
sendError(error: ServerErrorResponse | ServerStatusResponse): void;
write(chunk: Buffer): boolean | undefined;
resume(): void;
setupSurfaceCall(call: ServerSurfaceCall): void;
setupReadable(readable: ServerReadableStream | ServerDuplexStream): void;
consumeUnpushedMessages(readable: ServerReadableStream | ServerDuplexStream): boolean;
private pushOrBufferMessage;
private pushMessage;
}