grpc-js-reflection-client/dist/Proto/v1alpha.d.ts

Package use Grpc reflection api to download grpc proto descriptor. Now you don't have to add proto file to each package. Simple direct download proto package from example microservice without any files.

import * as pb_1 from "google-protobuf";
import * as grpc_1 from "@grpc/grpc-js";
export declare namespace grpc.reflection.v1alpha {
    export class ServerReflectionRequest extends pb_1.Message {
        #private;
        constructor(data?: any[] | ({
            host?: string;
        } & (({
            fileByFilename?: string;
            fileContainingSymbol?: never;
            fileContainingExtension?: never;
            allExtensionNumbersOfType?: never;
            listServices?: never;
        } | {
            fileByFilename?: never;
            fileContainingSymbol?: string;
            fileContainingExtension?: never;
            allExtensionNumbersOfType?: never;
            listServices?: never;
        } | {
            fileByFilename?: never;
            fileContainingSymbol?: never;
            fileContainingExtension?: ExtensionRequest;
            allExtensionNumbersOfType?: never;
            listServices?: never;
        } | {
            fileByFilename?: never;
            fileContainingSymbol?: never;
            fileContainingExtension?: never;
            allExtensionNumbersOfType?: string;
            listServices?: never;
        } | {
            fileByFilename?: never;
            fileContainingSymbol?: never;
            fileContainingExtension?: never;
            allExtensionNumbersOfType?: never;
            listServices?: string;
        }))));
        get host(): string;
        set host(value: string);
        get fileByFilename(): string;
        set fileByFilename(value: string);
        get hasFileByFilename(): boolean;
        get fileContainingSymbol(): string;
        set fileContainingSymbol(value: string);
        get hasFileContainingSymbol(): boolean;
        get fileContainingExtension(): ExtensionRequest;
        set fileContainingExtension(value: ExtensionRequest);
        get hasFileContainingExtension(): boolean;
        get allExtensionNumbersOfType(): string;
        set allExtensionNumbersOfType(value: string);
        get hasAllExtensionNumbersOfType(): boolean;
        get listServices(): string;
        set listServices(value: string);
        get hasListServices(): boolean;
        get message_request(): "fileByFilename" | "fileContainingSymbol" | "fileContainingExtension" | "allExtensionNumbersOfType" | "listServices" | "none";
        static fromObject(data: {
            host?: string;
            fileByFilename?: string;
            fileContainingSymbol?: string;
            fileContainingExtension?: ReturnType<typeof ExtensionRequest.prototype.toObject>;
            allExtensionNumbersOfType?: string;
            listServices?: string;
        }): ServerReflectionRequest;
        toObject(): {
            host?: string;
            fileByFilename?: string;
            fileContainingSymbol?: string;
            fileContainingExtension?: ReturnType<typeof ExtensionRequest.prototype.toObject>;
            allExtensionNumbersOfType?: string;
            listServices?: string;
        };
        serialize(): Uint8Array;
        serialize(w: pb_1.BinaryWriter): void;
        static deserialize(bytes: Uint8Array | pb_1.BinaryReader): ServerReflectionRequest;
        serializeBinary(): Uint8Array;
        static deserializeBinary(bytes: Uint8Array): ServerReflectionRequest;
    }
    export class ExtensionRequest extends pb_1.Message {
        #private;
        constructor(data?: any[] | {
            containingType?: string;
            extensionNumber?: number;
        });
        get containingType(): string;
        set containingType(value: string);
        get extensionNumber(): number;
        set extensionNumber(value: number);
        static fromObject(data: {
            containingType?: string;
            extensionNumber?: number;
        }): ExtensionRequest;
        toObject(): {
            containingType?: string;
            extensionNumber?: number;
        };
        serialize(): Uint8Array;
        serialize(w: pb_1.BinaryWriter): void;
        static deserialize(bytes: Uint8Array | pb_1.BinaryReader): ExtensionRequest;
        serializeBinary(): Uint8Array;
        static deserializeBinary(bytes: Uint8Array): ExtensionRequest;
    }
    export class ServerReflectionResponse extends pb_1.Message {
        #private;
        constructor(data?: any[] | ({
            validHost?: string;
            originalRequest?: ServerReflectionRequest;
        } & (({
            fileDescriptorResponse?: FileDescriptorResponse;
            allExtensionNumbersResponse?: never;
            listServicesResponse?: never;
            errorResponse?: never;
        } | {
            fileDescriptorResponse?: never;
            allExtensionNumbersResponse?: ExtensionNumberResponse;
            listServicesResponse?: never;
            errorResponse?: never;
        } | {
            fileDescriptorResponse?: never;
            allExtensionNumbersResponse?: never;
            listServicesResponse?: ListServiceResponse;
            errorResponse?: never;
        } | {
            fileDescriptorResponse?: never;
            allExtensionNumbersResponse?: never;
            listServicesResponse?: never;
            errorResponse?: ErrorResponse;
        }))));
        get validHost(): string;
        set validHost(value: string);
        get originalRequest(): ServerReflectionRequest;
        set originalRequest(value: ServerReflectionRequest);
        get hasOriginalRequest(): boolean;
        get fileDescriptorResponse(): FileDescriptorResponse;
        set fileDescriptorResponse(value: FileDescriptorResponse);
        get hasFileDescriptorResponse(): boolean;
        get allExtensionNumbersResponse(): ExtensionNumberResponse;
        set allExtensionNumbersResponse(value: ExtensionNumberResponse);
        get hasAllExtensionNumbersResponse(): boolean;
        get listServicesResponse(): ListServiceResponse;
        set listServicesResponse(value: ListServiceResponse);
        get hasListServicesResponse(): boolean;
        get errorResponse(): ErrorResponse;
        set errorResponse(value: ErrorResponse);
        get hasErrorResponse(): boolean;
        get message_response(): "none" | "fileDescriptorResponse" | "allExtensionNumbersResponse" | "listServicesResponse" | "errorResponse";
        static fromObject(data: {
            validHost?: string;
            originalRequest?: ReturnType<typeof ServerReflectionRequest.prototype.toObject>;
            fileDescriptorResponse?: ReturnType<typeof FileDescriptorResponse.prototype.toObject>;
            allExtensionNumbersResponse?: ReturnType<typeof ExtensionNumberResponse.prototype.toObject>;
            listServicesResponse?: ReturnType<typeof ListServiceResponse.prototype.toObject>;
            errorResponse?: ReturnType<typeof ErrorResponse.prototype.toObject>;
        }): ServerReflectionResponse;
        toObject(): {
            validHost?: string;
            originalRequest?: ReturnType<typeof ServerReflectionRequest.prototype.toObject>;
            fileDescriptorResponse?: ReturnType<typeof FileDescriptorResponse.prototype.toObject>;
            allExtensionNumbersResponse?: ReturnType<typeof ExtensionNumberResponse.prototype.toObject>;
            listServicesResponse?: ReturnType<typeof ListServiceResponse.prototype.toObject>;
            errorResponse?: ReturnType<typeof ErrorResponse.prototype.toObject>;
        };
        serialize(): Uint8Array;
        serialize(w: pb_1.BinaryWriter): void;
        static deserialize(bytes: Uint8Array | pb_1.BinaryReader): ServerReflectionResponse;
        serializeBinary(): Uint8Array;
        static deserializeBinary(bytes: Uint8Array): ServerReflectionResponse;
    }
    export class FileDescriptorResponse extends pb_1.Message {
        #private;
        constructor(data?: any[] | {
            fileDescriptorProto?: Uint8Array[];
        });
        get fileDescriptorProto(): Uint8Array[];
        set fileDescriptorProto(value: Uint8Array[]);
        static fromObject(data: {
            fileDescriptorProto?: Uint8Array[];
        }): FileDescriptorResponse;
        toObject(): {
            fileDescriptorProto?: Uint8Array[];
        };
        serialize(): Uint8Array;
        serialize(w: pb_1.BinaryWriter): void;
        static deserialize(bytes: Uint8Array | pb_1.BinaryReader): FileDescriptorResponse;
        serializeBinary(): Uint8Array;
        static deserializeBinary(bytes: Uint8Array): FileDescriptorResponse;
    }
    export class ExtensionNumberResponse extends pb_1.Message {
        #private;
        constructor(data?: any[] | {
            baseTypeName?: string;
            extensionNumber?: number[];
        });
        get baseTypeName(): string;
        set baseTypeName(value: string);
        get extensionNumber(): number[];
        set extensionNumber(value: number[]);
        static fromObject(data: {
            baseTypeName?: string;
            extensionNumber?: number[];
        }): ExtensionNumberResponse;
        toObject(): {
            baseTypeName?: string;
            extensionNumber?: number[];
        };
        serialize(): Uint8Array;
        serialize(w: pb_1.BinaryWriter): void;
        static deserialize(bytes: Uint8Array | pb_1.BinaryReader): ExtensionNumberResponse;
        serializeBinary(): Uint8Array;
        static deserializeBinary(bytes: Uint8Array): ExtensionNumberResponse;
    }
    export class ListServiceResponse extends pb_1.Message {
        #private;
        constructor(data?: any[] | {
            service?: ServiceResponse[];
        });
        get service(): ServiceResponse[];
        set service(value: ServiceResponse[]);
        static fromObject(data: {
            service?: ReturnType<typeof ServiceResponse.prototype.toObject>[];
        }): ListServiceResponse;
        toObject(): {
            service?: ReturnType<typeof ServiceResponse.prototype.toObject>[];
        };
        serialize(): Uint8Array;
        serialize(w: pb_1.BinaryWriter): void;
        static deserialize(bytes: Uint8Array | pb_1.BinaryReader): ListServiceResponse;
        serializeBinary(): Uint8Array;
        static deserializeBinary(bytes: Uint8Array): ListServiceResponse;
    }
    export class ServiceResponse extends pb_1.Message {
        #private;
        constructor(data?: any[] | {
            name?: string;
        });
        get name(): string;
        set name(value: string);
        static fromObject(data: {
            name?: string;
        }): ServiceResponse;
        toObject(): {
            name?: string;
        };
        serialize(): Uint8Array;
        serialize(w: pb_1.BinaryWriter): void;
        static deserialize(bytes: Uint8Array | pb_1.BinaryReader): ServiceResponse;
        serializeBinary(): Uint8Array;
        static deserializeBinary(bytes: Uint8Array): ServiceResponse;
    }
    export class ErrorResponse extends pb_1.Message {
        #private;
        constructor(data?: any[] | {
            errorCode?: number;
            errorMessage?: string;
        });
        get errorCode(): number;
        set errorCode(value: number);
        get errorMessage(): string;
        set errorMessage(value: string);
        static fromObject(data: {
            errorCode?: number;
            errorMessage?: string;
        }): ErrorResponse;
        toObject(): {
            errorCode?: number;
            errorMessage?: string;
        };
        serialize(): Uint8Array;
        serialize(w: pb_1.BinaryWriter): void;
        static deserialize(bytes: Uint8Array | pb_1.BinaryReader): ErrorResponse;
        serializeBinary(): Uint8Array;
        static deserializeBinary(bytes: Uint8Array): ErrorResponse;
    }
    interface GrpcChunkServiceInterface<P, R> {
        (metadata: grpc_1.Metadata, options?: grpc_1.CallOptions): grpc_1.ClientDuplexStream<P, R>;
        (options?: grpc_1.CallOptions): grpc_1.ClientDuplexStream<P, R>;
    }
    export abstract class UnimplementedServerReflectionService {
        static definition: {
            ServerReflectionInfo: {
                path: string;
                requestStream: boolean;
                responseStream: boolean;
                requestSerialize: (message: ServerReflectionRequest) => Buffer<ArrayBuffer>;
                requestDeserialize: (bytes: Buffer) => ServerReflectionRequest;
                responseSerialize: (message: ServerReflectionResponse) => Buffer<ArrayBuffer>;
                responseDeserialize: (bytes: Buffer) => ServerReflectionResponse;
            };
        };
        [method: string]: grpc_1.UntypedHandleCall;
        abstract ServerReflectionInfo(call: grpc_1.ServerDuplexStream<ServerReflectionRequest, ServerReflectionResponse>): void;
    }
    const ServerReflectionClient_base: grpc_1.ServiceClientConstructor;
    export class ServerReflectionClient extends ServerReflectionClient_base {
        constructor(address: string, credentials: grpc_1.ChannelCredentials, options?: Partial<grpc_1.ChannelOptions>);
        ServerReflectionInfo: GrpcChunkServiceInterface<ServerReflectionRequest, ServerReflectionResponse>;
    }
    export {};
}