import { Observable } from 'rxjs';
import { ByteSource, BinaryReader, BinaryWriter } from 'google-protobuf';

/**
 * Describes a gRPC message class
 */
interface GrpcMessageClass<M extends GrpcMessage> {
    new (m?: any): M;
    id: string;
    deserializeBinary: (bytes: ByteSource) => M;
    deserializeBinaryFromReader: (message: M, reader: BinaryReader) => void;
    serializeBinaryToWriter: (message: M, writer: BinaryWriter) => void;
}

/**
 * A message pool for using with `google.protobuf.Any`.
 * Pass the array of messages to be registered within the pool and give this pool to `toProtobufJSON` or to `unpack`.
 */
declare class GrpcMessagePool {
    private index;
    constructor(messages: GrpcMessageClass<GrpcMessage>[]);
    add(messages: GrpcMessageClass<GrpcMessage>[]): void;
    get(id: string): GrpcMessageClass<GrpcMessage>;
}

/**
 * gRPC message interface
 */
interface GrpcMessage {
    serializeBinary(): Uint8Array;
    toObject(): any;
    toJSON(): any;
    toProtobufJSON(options?: ToProtobufJSONOptions): any;
}
/**
 * Options to pass to `toProtobufJSON(options)`
 */
interface ToProtobufJSONOptions {
    /**
     * Message pool to unpack google.protobuf.Any. If you do not expect the message or any of its descendants to be google.protobuf.Any this option should be omitted.
     */
    messagePool?: GrpcMessagePool;
}

declare class GrpcMetadata {
    private map;
    constructor(initial?: {
        [prop: string]: string;
    });
    set(name: string, value: string): void;
    get(name: string): string;
    has(name: string): boolean;
    clone(): GrpcMetadata;
    toObject(): {};
}

/**
 * Data event. This event is emitted when the new message arrives from the server
 */
declare class GrpcDataEvent<T extends GrpcMessage> {
    data: T;
    constructor(data: T);
}
/**
 * Status event. This event is emitted when the new status and metadata arrives from the server
 */
declare class GrpcStatusEvent {
    statusCode: number;
    statusMessage: string;
    metadata: GrpcMetadata;
    constructor(statusCode: number, statusMessage: string, metadata: GrpcMetadata);
}
/**
 * GrpcEvent can be either data or status event
 */
type GrpcEvent<T extends GrpcMessage> = GrpcDataEvent<T> | GrpcStatusEvent;

/**
 * This interface describes transport layer client factory, which is important in instantiating GrpcClient
 * because the GrpcClientFactory is bound to the dependency injection (use constructor to inject normal Angular services & config),
 * while GrpcClient has none
 */
interface GrpcClientFactory<ST> {
    /**
     * Create a GrpcClient
     *
     * @param serviceId a service type in proto (passed in by generated service client), e.g.
     * @param settings settings for underlying grpc client implementation
     * @returns new GrpcClient
     */
    createClient(serviceId: string, settings: ST): GrpcClient<ST>;
}
/**
 * A transport layer client implementation interface
 * Instance of GrpcClient is created for every gRPC service client by corresponding GrpcClientFactory
 */
interface GrpcClient<ST> {
    /**
     * Returns a copy of current client settings
     */
    getSettings(): ST;
    /**
     * Handle unary RPC
     *
     * @param path gRPC method path (rpc path)
     * @param req request data
     * @param metadata request metadata
     * @param reqclss request message class
     * @param resclss response message class
     */
    unary<Q extends GrpcMessage, S extends GrpcMessage>(path: string, req: Q, metadata: GrpcMetadata, reqclss: GrpcMessageClass<Q>, resclss: GrpcMessageClass<S>): Observable<GrpcEvent<S>>;
    /**
     * Handle server stream RPC
     *
     * @param path gRPC method path (rpc path)
     * @param req request data
     * @param metadata request metadata
     * @param reqclss request message class
     * @param resclss response message class
     */
    serverStream<Q extends GrpcMessage, S extends GrpcMessage>(path: string, req: Q, metadata: GrpcMetadata, reqclss: GrpcMessageClass<Q>, resclss: GrpcMessageClass<S>): Observable<GrpcEvent<S>>;
    /**
     * Handle client stream RPC
     *
     * @param path gRPC method path (rpc path)
     * @param inputStream streamed request data
     * @param metadata request metadata
     * @param reqclss request message class
     * @param resclss response message class
     */
    clientStream<Q extends GrpcMessage, S extends GrpcMessage>(path: string, inputStream: Observable<Q>, metadata: GrpcMetadata, reqclss: GrpcMessageClass<Q>, resclss: GrpcMessageClass<S>): Observable<GrpcEvent<S>>;
    /**
     * Handle bidirectional stream RPC
     *
     * @param path gRPC method path (rpc path)
     * @param inputStream streamed request data
     * @param metadata request metadata
     * @param reqclss request message class
     * @param resclss response message class
     */
    bidiStream<Q extends GrpcMessage, S extends GrpcMessage>(path: string, inputStream: Observable<Q>, metadata: GrpcMetadata, reqclss: GrpcMessageClass<Q>, resclss: GrpcMessageClass<S>): Observable<GrpcEvent<S>>;
}
/**
 * Type of the RPC
 */
declare enum GrpcCallType {
    unary = 0,
    serverStream = 1,
    clientStream = 2,
    bidiStream = 3
}
/**
 * This interface describes the internal gRPC request data structure
 */
interface GrpcRequest<Q extends GrpcMessage, S extends GrpcMessage> {
    path: string;
    client: GrpcClient<any>;
    type: GrpcCallType;
    requestData: Q | Observable<Q>;
    requestMetadata: GrpcMetadata;
    requestClass: GrpcMessageClass<Q>;
    responseClass: GrpcMessageClass<S>;
}

/**
 * Helper type to turn every property and all sub-properties (from sub-objects) the incoming type to be optional
 */
type RecursivePartial<T> = {
    [P in keyof T]?: T[P] extends Uint8Array ? T[P] : T[P] extends (infer U)[] ? RecursivePartial<U>[] : T[P];
};

/**
 * Converts Uint8Array to string as prescribed by protobuf bytes toJSON definition
 * Inspired by https://stackoverflow.com/a/9458996/1990451
 */
declare function uint8ArrayToBase64(array: Uint8Array): string;

export { GrpcCallType, GrpcDataEvent, GrpcMessagePool, GrpcMetadata, GrpcStatusEvent, uint8ArrayToBase64 };
export type { GrpcClient, GrpcClientFactory, GrpcEvent, GrpcMessage, GrpcMessageClass, GrpcRequest, RecursivePartial, ToProtobufJSONOptions };