func (*HandshakerResp) Descriptor() ([]byte, []int) {
	return file_grpc_gcp_handshaker_proto_rawDescGZIP(), []int{9}
}
Deprecated: Use HandshakerResp.ProtoReflect.Descriptor instead.
package grpc_gcp
import (
	proto "github.com/golang/protobuf/proto"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	reflect "reflect"
	sync "sync"
)
const (
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
const _ = proto.ProtoPackageIsVersion4
type HandshakeProtocol int32
const (
	HandshakeProtocol_HANDSHAKE_PROTOCOL_UNSPECIFIED HandshakeProtocol = 0
	HandshakeProtocol_TLS HandshakeProtocol = 1
	HandshakeProtocol_ALTS HandshakeProtocol = 2
)
var (
	HandshakeProtocol_name = map[int32]string{
		0: "HANDSHAKE_PROTOCOL_UNSPECIFIED",
		1: "TLS",
		2: "ALTS",
	}
	HandshakeProtocol_value = map[string]int32{
		"HANDSHAKE_PROTOCOL_UNSPECIFIED": 0,
		"TLS":                            1,
		"ALTS":                           2,
	}
)
func (x HandshakeProtocol) Enum() *HandshakeProtocol {
	p := new(HandshakeProtocol)
	*p = x
	return p
}
func (x HandshakeProtocol) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (HandshakeProtocol) Descriptor() protoreflect.EnumDescriptor {
	return file_grpc_gcp_handshaker_proto_enumTypes[0].Descriptor()
}
func (HandshakeProtocol) Type() protoreflect.EnumType {
	return &file_grpc_gcp_handshaker_proto_enumTypes[0]
}
func (x HandshakeProtocol) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}
func (HandshakeProtocol) EnumDescriptor() ([]byte, []int) {
	return file_grpc_gcp_handshaker_proto_rawDescGZIP(), []int{0}
}
type NetworkProtocol int32
const (
	NetworkProtocol_NETWORK_PROTOCOL_UNSPECIFIED NetworkProtocol = 0
	NetworkProtocol_TCP                          NetworkProtocol = 1
	NetworkProtocol_UDP                          NetworkProtocol = 2
)
var (
	NetworkProtocol_name = map[int32]string{
		0: "NETWORK_PROTOCOL_UNSPECIFIED",
		1: "TCP",
		2: "UDP",
	}
	NetworkProtocol_value = map[string]int32{
		"NETWORK_PROTOCOL_UNSPECIFIED": 0,
		"TCP":                          1,
		"UDP":                          2,
	}
)
func (x NetworkProtocol) Enum() *NetworkProtocol {
	p := new(NetworkProtocol)
	*p = x
	return p
}
func (x NetworkProtocol) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (NetworkProtocol) Descriptor() protoreflect.EnumDescriptor {
	return file_grpc_gcp_handshaker_proto_enumTypes[1].Descriptor()
}
func (NetworkProtocol) Type() protoreflect.EnumType {
	return &file_grpc_gcp_handshaker_proto_enumTypes[1]
}
func (x NetworkProtocol) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}
func (NetworkProtocol) EnumDescriptor() ([]byte, []int) {
	return file_grpc_gcp_handshaker_proto_rawDescGZIP(), []int{1}
}
type Endpoint struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields
	IpAddress string `protobuf:"bytes,1,opt,name=ip_address,json=ipAddress,proto3" json:"ip_address,omitempty"`
	Port int32 `protobuf:"varint,2,opt,name=port,proto3" json:"port,omitempty"`
	Protocol NetworkProtocol `protobuf:"varint,3,opt,name=protocol,proto3,enum=grpc.gcp.NetworkProtocol" json:"protocol,omitempty"`
}
func (x *Endpoint) Reset() {
	*x = Endpoint{}
	if protoimpl.UnsafeEnabled {
		mi := &file_grpc_gcp_handshaker_proto_msgTypes[0]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}
func (x *Endpoint) String() string {
	return protoimpl.X.MessageStringOf(x)
}
func (*Endpoint) ProtoMessage() {}
func (x *Endpoint) ProtoReflect() protoreflect.Message {
	mi := &file_grpc_gcp_handshaker_proto_msgTypes[0]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}
func (*Endpoint) Descriptor() ([]byte, []int) {
	return file_grpc_gcp_handshaker_proto_rawDescGZIP(), []int{0}
}
func (x *Endpoint) GetIpAddress() string {
	if x != nil {
		return x.IpAddress
	}
	return ""
}
func (x *Endpoint) GetPort() int32 {
	if x != nil {
		return x.Port
	}
	return 0
}
func (x *Endpoint) GetProtocol() NetworkProtocol {
	if x != nil {
		return x.Protocol
	}
	return NetworkProtocol_NETWORK_PROTOCOL_UNSPECIFIED
}
type Identity struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields
	IdentityOneof isIdentity_IdentityOneof `protobuf_oneof:"identity_oneof"`
	Attributes map[string]string `protobuf:"bytes,3,rep,name=attributes,proto3" json:"attributes,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *Identity) Reset() {
	*x = Identity{}
	if protoimpl.UnsafeEnabled {
		mi := &file_grpc_gcp_handshaker_proto_msgTypes[1]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}
func (x *Identity) String() string {
	return protoimpl.X.MessageStringOf(x)
}
func (*Identity) ProtoMessage() {}
func (x *Identity) ProtoReflect() protoreflect.Message {
	mi := &file_grpc_gcp_handshaker_proto_msgTypes[1]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}
func (*Identity) Descriptor() ([]byte, []int) {
	return file_grpc_gcp_handshaker_proto_rawDescGZIP(), []int{1}
}
func (m *Identity) GetIdentityOneof() isIdentity_IdentityOneof {
	if m != nil {
		return m.IdentityOneof
	}
	return nil
}
func (x *Identity) GetServiceAccount() string {
	if x, ok := x.GetIdentityOneof().(*Identity_ServiceAccount); ok {
		return x.ServiceAccount
	}
	return ""
}
func (x *Identity) GetHostname() string {
	if x, ok := x.GetIdentityOneof().(*Identity_Hostname); ok {
		return x.Hostname
	}
	return ""
}
func (x *Identity) GetAttributes() map[string]string {
	if x != nil {
		return x.Attributes
	}
	return nil
}
type isIdentity_IdentityOneof interface {
	isIdentity_IdentityOneof()
}
type Identity_ServiceAccount struct {
	ServiceAccount string `protobuf:"bytes,1,opt,name=service_account,json=serviceAccount,proto3,oneof"`
}
type Identity_Hostname struct {
	Hostname string `protobuf:"bytes,2,opt,name=hostname,proto3,oneof"`
}
func (*Identity_ServiceAccount) isIdentity_IdentityOneof() {}
func (*Identity_Hostname) isIdentity_IdentityOneof() {}
type StartClientHandshakeReq struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields
	HandshakeSecurityProtocol HandshakeProtocol `protobuf:"varint,1,opt,name=handshake_security_protocol,json=handshakeSecurityProtocol,proto3,enum=grpc.gcp.HandshakeProtocol" json:"handshake_security_protocol,omitempty"`
	ApplicationProtocols []string `protobuf:"bytes,2,rep,name=application_protocols,json=applicationProtocols,proto3" json:"application_protocols,omitempty"`
	RecordProtocols []string `protobuf:"bytes,3,rep,name=record_protocols,json=recordProtocols,proto3" json:"record_protocols,omitempty"`
	TargetIdentities []*Identity `protobuf:"bytes,4,rep,name=target_identities,json=targetIdentities,proto3" json:"target_identities,omitempty"`
	LocalIdentity *Identity `protobuf:"bytes,5,opt,name=local_identity,json=localIdentity,proto3" json:"local_identity,omitempty"`
	LocalEndpoint *Endpoint `protobuf:"bytes,6,opt,name=local_endpoint,json=localEndpoint,proto3" json:"local_endpoint,omitempty"`
	RemoteEndpoint *Endpoint `protobuf:"bytes,7,opt,name=remote_endpoint,json=remoteEndpoint,proto3" json:"remote_endpoint,omitempty"`
	TargetName string `protobuf:"bytes,8,opt,name=target_name,json=targetName,proto3" json:"target_name,omitempty"`
	RpcVersions *RpcProtocolVersions `protobuf:"bytes,9,opt,name=rpc_versions,json=rpcVersions,proto3" json:"rpc_versions,omitempty"`
	MaxFrameSize uint32 `protobuf:"varint,10,opt,name=max_frame_size,json=maxFrameSize,proto3" json:"max_frame_size,omitempty"`
}
func (x *StartClientHandshakeReq) Reset() {
	*x = StartClientHandshakeReq{}
	if protoimpl.UnsafeEnabled {
		mi := &file_grpc_gcp_handshaker_proto_msgTypes[2]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}
func (x *StartClientHandshakeReq) String() string {
	return protoimpl.X.MessageStringOf(x)
}
func (*StartClientHandshakeReq) ProtoMessage() {}
func (x *StartClientHandshakeReq) ProtoReflect() protoreflect.Message {
	mi := &file_grpc_gcp_handshaker_proto_msgTypes[2]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}
func (*StartClientHandshakeReq) Descriptor() ([]byte, []int) {
	return file_grpc_gcp_handshaker_proto_rawDescGZIP(), []int{2}
}
func (x *StartClientHandshakeReq) GetHandshakeSecurityProtocol() HandshakeProtocol {
	if x != nil {
		return x.HandshakeSecurityProtocol
	}
	return HandshakeProtocol_HANDSHAKE_PROTOCOL_UNSPECIFIED
}
func (x *StartClientHandshakeReq) GetApplicationProtocols() []string {
	if x != nil {
		return x.ApplicationProtocols
	}
	return nil
}
func (x *StartClientHandshakeReq) GetRecordProtocols() []string {
	if x != nil {
		return x.RecordProtocols
	}
	return nil
}
func (x *StartClientHandshakeReq) GetTargetIdentities() []*Identity {
	if x != nil {
		return x.TargetIdentities
	}
	return nil
}
func (x *StartClientHandshakeReq) GetLocalIdentity() *Identity {
	if x != nil {
		return x.LocalIdentity
	}
	return nil
}
func (x *StartClientHandshakeReq) GetLocalEndpoint() *Endpoint {
	if x != nil {
		return x.LocalEndpoint
	}
	return nil
}
func (x *StartClientHandshakeReq) GetRemoteEndpoint() *Endpoint {
	if x != nil {
		return x.RemoteEndpoint
	}
	return nil
}
func (x *StartClientHandshakeReq) GetTargetName() string {
	if x != nil {
		return x.TargetName
	}
	return ""
}
func (x *StartClientHandshakeReq) GetRpcVersions() *RpcProtocolVersions {
	if x != nil {
		return x.RpcVersions
	}
	return nil
}
func (x *StartClientHandshakeReq) GetMaxFrameSize() uint32 {
	if x != nil {
		return x.MaxFrameSize
	}
	return 0
}
type ServerHandshakeParameters struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields
	RecordProtocols []string `protobuf:"bytes,1,rep,name=record_protocols,json=recordProtocols,proto3" json:"record_protocols,omitempty"`
	LocalIdentities []*Identity `protobuf:"bytes,2,rep,name=local_identities,json=localIdentities,proto3" json:"local_identities,omitempty"`
}
func (x *ServerHandshakeParameters) Reset() {
	*x = ServerHandshakeParameters{}
	if protoimpl.UnsafeEnabled {
		mi := &file_grpc_gcp_handshaker_proto_msgTypes[3]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}
func (x *ServerHandshakeParameters) String() string {
	return protoimpl.X.MessageStringOf(x)
}
func (*ServerHandshakeParameters) ProtoMessage() {}
func (x *ServerHandshakeParameters) ProtoReflect() protoreflect.Message {
	mi := &file_grpc_gcp_handshaker_proto_msgTypes[3]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}
func (*ServerHandshakeParameters) Descriptor() ([]byte, []int) {
	return file_grpc_gcp_handshaker_proto_rawDescGZIP(), []int{3}
}
func (x *ServerHandshakeParameters) GetRecordProtocols() []string {
	if x != nil {
		return x.RecordProtocols
	}
	return nil
}
func (x *ServerHandshakeParameters) GetLocalIdentities() []*Identity {
	if x != nil {
		return x.LocalIdentities
	}
	return nil
}
type StartServerHandshakeReq struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields
	ApplicationProtocols []string `protobuf:"bytes,1,rep,name=application_protocols,json=applicationProtocols,proto3" json:"application_protocols,omitempty"`
	HandshakeParameters map[int32]*ServerHandshakeParameters `protobuf:"bytes,2,rep,name=handshake_parameters,json=handshakeParameters,proto3" json:"handshake_parameters,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	InBytes []byte `protobuf:"bytes,3,opt,name=in_bytes,json=inBytes,proto3" json:"in_bytes,omitempty"`
	LocalEndpoint *Endpoint `protobuf:"bytes,4,opt,name=local_endpoint,json=localEndpoint,proto3" json:"local_endpoint,omitempty"`
	RemoteEndpoint *Endpoint `protobuf:"bytes,5,opt,name=remote_endpoint,json=remoteEndpoint,proto3" json:"remote_endpoint,omitempty"`
	RpcVersions *RpcProtocolVersions `protobuf:"bytes,6,opt,name=rpc_versions,json=rpcVersions,proto3" json:"rpc_versions,omitempty"`
	MaxFrameSize uint32 `protobuf:"varint,7,opt,name=max_frame_size,json=maxFrameSize,proto3" json:"max_frame_size,omitempty"`
}
func (x *StartServerHandshakeReq) Reset() {
	*x = StartServerHandshakeReq{}
	if protoimpl.UnsafeEnabled {
		mi := &file_grpc_gcp_handshaker_proto_msgTypes[4]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}
func (x *StartServerHandshakeReq) String() string {
	return protoimpl.X.MessageStringOf(x)
}
func (*StartServerHandshakeReq) ProtoMessage() {}
func (x *StartServerHandshakeReq) ProtoReflect() protoreflect.Message {
	mi := &file_grpc_gcp_handshaker_proto_msgTypes[4]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}
func (*StartServerHandshakeReq) Descriptor() ([]byte, []int) {
	return file_grpc_gcp_handshaker_proto_rawDescGZIP(), []int{4}
}
func (x *StartServerHandshakeReq) GetApplicationProtocols() []string {
	if x != nil {
		return x.ApplicationProtocols
	}
	return nil
}
func (x *StartServerHandshakeReq) GetHandshakeParameters() map[int32]*ServerHandshakeParameters {
	if x != nil {
		return x.HandshakeParameters
	}
	return nil
}
func (x *StartServerHandshakeReq) GetInBytes() []byte {
	if x != nil {
		return x.InBytes
	}
	return nil
}
func (x *StartServerHandshakeReq) GetLocalEndpoint() *Endpoint {
	if x != nil {
		return x.LocalEndpoint
	}
	return nil
}
func (x *StartServerHandshakeReq) GetRemoteEndpoint() *Endpoint {
	if x != nil {
		return x.RemoteEndpoint
	}
	return nil
}
func (x *StartServerHandshakeReq) GetRpcVersions() *RpcProtocolVersions {
	if x != nil {
		return x.RpcVersions
	}
	return nil
}
func (x *StartServerHandshakeReq) GetMaxFrameSize() uint32 {
	if x != nil {
		return x.MaxFrameSize
	}
	return 0
}
type NextHandshakeMessageReq struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields
	InBytes []byte `protobuf:"bytes,1,opt,name=in_bytes,json=inBytes,proto3" json:"in_bytes,omitempty"`
}
func (x *NextHandshakeMessageReq) Reset() {
	*x = NextHandshakeMessageReq{}
	if protoimpl.UnsafeEnabled {
		mi := &file_grpc_gcp_handshaker_proto_msgTypes[5]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}
func (x *NextHandshakeMessageReq) String() string {
	return protoimpl.X.MessageStringOf(x)
}
func (*NextHandshakeMessageReq) ProtoMessage() {}
func (x *NextHandshakeMessageReq) ProtoReflect() protoreflect.Message {
	mi := &file_grpc_gcp_handshaker_proto_msgTypes[5]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}
func (*NextHandshakeMessageReq) Descriptor() ([]byte, []int) {
	return file_grpc_gcp_handshaker_proto_rawDescGZIP(), []int{5}
}
func (x *NextHandshakeMessageReq) GetInBytes() []byte {
	if x != nil {
		return x.InBytes
	}
	return nil
}
type HandshakerReq struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields
	ReqOneof isHandshakerReq_ReqOneof `protobuf_oneof:"req_oneof"`
}
func (x *HandshakerReq) Reset() {
	*x = HandshakerReq{}
	if protoimpl.UnsafeEnabled {
		mi := &file_grpc_gcp_handshaker_proto_msgTypes[6]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}
func (x *HandshakerReq) String() string {
	return protoimpl.X.MessageStringOf(x)
}
func (*HandshakerReq) ProtoMessage() {}
func (x *HandshakerReq) ProtoReflect() protoreflect.Message {
	mi := &file_grpc_gcp_handshaker_proto_msgTypes[6]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}
func (*HandshakerReq) Descriptor() ([]byte, []int) {
	return file_grpc_gcp_handshaker_proto_rawDescGZIP(), []int{6}
}
func (m *HandshakerReq) GetReqOneof() isHandshakerReq_ReqOneof {
	if m != nil {
		return m.ReqOneof
	}
	return nil
}
func (x *HandshakerReq) GetClientStart() *StartClientHandshakeReq {
	if x, ok := x.GetReqOneof().(*HandshakerReq_ClientStart); ok {
		return x.ClientStart
	}
	return nil
}
func (x *HandshakerReq) GetServerStart() *StartServerHandshakeReq {
	if x, ok := x.GetReqOneof().(*HandshakerReq_ServerStart); ok {
		return x.ServerStart
	}
	return nil
}
func (x *HandshakerReq) GetNext() *NextHandshakeMessageReq {
	if x, ok := x.GetReqOneof().(*HandshakerReq_Next); ok {
		return x.Next
	}
	return nil
}
type isHandshakerReq_ReqOneof interface {
	isHandshakerReq_ReqOneof()
}
type HandshakerReq_ClientStart struct {
	ClientStart *StartClientHandshakeReq `protobuf:"bytes,1,opt,name=client_start,json=clientStart,proto3,oneof"`
}
type HandshakerReq_ServerStart struct {
	ServerStart *StartServerHandshakeReq `protobuf:"bytes,2,opt,name=server_start,json=serverStart,proto3,oneof"`
}
type HandshakerReq_Next struct {
	Next *NextHandshakeMessageReq `protobuf:"bytes,3,opt,name=next,proto3,oneof"`
}
func (*HandshakerReq_ClientStart) isHandshakerReq_ReqOneof() {}
func (*HandshakerReq_ServerStart) isHandshakerReq_ReqOneof() {}
func (*HandshakerReq_Next) isHandshakerReq_ReqOneof() {}
type HandshakerResult struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields
	ApplicationProtocol string `protobuf:"bytes,1,opt,name=application_protocol,json=applicationProtocol,proto3" json:"application_protocol,omitempty"`
	RecordProtocol string `protobuf:"bytes,2,opt,name=record_protocol,json=recordProtocol,proto3" json:"record_protocol,omitempty"`
	KeyData []byte `protobuf:"bytes,3,opt,name=key_data,json=keyData,proto3" json:"key_data,omitempty"`
	PeerIdentity *Identity `protobuf:"bytes,4,opt,name=peer_identity,json=peerIdentity,proto3" json:"peer_identity,omitempty"`
	LocalIdentity *Identity `protobuf:"bytes,5,opt,name=local_identity,json=localIdentity,proto3" json:"local_identity,omitempty"`
	KeepChannelOpen bool `protobuf:"varint,6,opt,name=keep_channel_open,json=keepChannelOpen,proto3" json:"keep_channel_open,omitempty"`
	PeerRpcVersions *RpcProtocolVersions `protobuf:"bytes,7,opt,name=peer_rpc_versions,json=peerRpcVersions,proto3" json:"peer_rpc_versions,omitempty"`
	MaxFrameSize uint32 `protobuf:"varint,8,opt,name=max_frame_size,json=maxFrameSize,proto3" json:"max_frame_size,omitempty"`
}
func (x *HandshakerResult) Reset() {
	*x = HandshakerResult{}
	if protoimpl.UnsafeEnabled {
		mi := &file_grpc_gcp_handshaker_proto_msgTypes[7]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}
func (x *HandshakerResult) String() string {
	return protoimpl.X.MessageStringOf(x)
}
func (*HandshakerResult) ProtoMessage() {}
func (x *HandshakerResult) ProtoReflect() protoreflect.Message {
	mi := &file_grpc_gcp_handshaker_proto_msgTypes[7]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}
func (*HandshakerResult) Descriptor() ([]byte, []int) {
	return file_grpc_gcp_handshaker_proto_rawDescGZIP(), []int{7}
}
func (x *HandshakerResult) GetApplicationProtocol() string {
	if x != nil {
		return x.ApplicationProtocol
	}
	return ""
}
func (x *HandshakerResult) GetRecordProtocol() string {
	if x != nil {
		return x.RecordProtocol
	}
	return ""
}
func (x *HandshakerResult) GetKeyData() []byte {
	if x != nil {
		return x.KeyData
	}
	return nil
}
func (x *HandshakerResult) GetPeerIdentity() *Identity {
	if x != nil {
		return x.PeerIdentity
	}
	return nil
}
func (x *HandshakerResult) GetLocalIdentity() *Identity {
	if x != nil {
		return x.LocalIdentity
	}
	return nil
}
func (x *HandshakerResult) GetKeepChannelOpen() bool {
	if x != nil {
		return x.KeepChannelOpen
	}
	return false
}
func (x *HandshakerResult) GetPeerRpcVersions() *RpcProtocolVersions {
	if x != nil {
		return x.PeerRpcVersions
	}
	return nil
}
func (x *HandshakerResult) GetMaxFrameSize() uint32 {
	if x != nil {
		return x.MaxFrameSize
	}
	return 0
}
type HandshakerStatus struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields
	Code uint32 `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"`
	Details string `protobuf:"bytes,2,opt,name=details,proto3" json:"details,omitempty"`
}
func (x *HandshakerStatus) Reset() {
	*x = HandshakerStatus{}
	if protoimpl.UnsafeEnabled {
		mi := &file_grpc_gcp_handshaker_proto_msgTypes[8]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}
func (x *HandshakerStatus) String() string {
	return protoimpl.X.MessageStringOf(x)
}
func (*HandshakerStatus) ProtoMessage() {}
func (x *HandshakerStatus) ProtoReflect() protoreflect.Message {
	mi := &file_grpc_gcp_handshaker_proto_msgTypes[8]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}
func (*HandshakerStatus) Descriptor() ([]byte, []int) {
	return file_grpc_gcp_handshaker_proto_rawDescGZIP(), []int{8}
}
func (x *HandshakerStatus) GetCode() uint32 {
	if x != nil {
		return x.Code
	}
	return 0
}
func (x *HandshakerStatus) GetDetails() string {
	if x != nil {
		return x.Details
	}
	return ""
}
type HandshakerResp struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields
	OutFrames []byte `protobuf:"bytes,1,opt,name=out_frames,json=outFrames,proto3" json:"out_frames,omitempty"`
	BytesConsumed uint32 `protobuf:"varint,2,opt,name=bytes_consumed,json=bytesConsumed,proto3" json:"bytes_consumed,omitempty"`
	Result *HandshakerResult `protobuf:"bytes,3,opt,name=result,proto3" json:"result,omitempty"`
	Status *HandshakerStatus `protobuf:"bytes,4,opt,name=status,proto3" json:"status,omitempty"`
}
func (x *HandshakerResp) Reset() {
	*x = HandshakerResp{}
	if protoimpl.UnsafeEnabled {
		mi := &file_grpc_gcp_handshaker_proto_msgTypes[9]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}
func (x *HandshakerResp) String() string {
	return protoimpl.X.MessageStringOf(x)
}
func (*HandshakerResp) ProtoMessage() {}
func (x *HandshakerResp) ProtoReflect() protoreflect.Message {
	mi := &file_grpc_gcp_handshaker_proto_msgTypes[9]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}