import * as pb_1 from "google-protobuf";
import * as grpc_1 from "@grpc/grpc-js";
export declare namespace grpc.reflection.v1 {
    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 {};
}