// Code generated by protoc-gen-go. DO NOT EDIT.
// source: tunnelservice.proto

package protocol

import (
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	math "math"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package

type TunnelType int32

const (
	TunnelType_BaseData      TunnelType = 1
	TunnelType_Stream        TunnelType = 2
	TunnelType_BaseAndStream TunnelType = 3
)

var TunnelType_name = map[int32]string{
	1: "BaseData",
	2: "Stream",
	3: "BaseAndStream",
}

var TunnelType_value = map[string]int32{
	"BaseData":      1,
	"Stream":        2,
	"BaseAndStream": 3,
}

func (x TunnelType) Enum() *TunnelType {
	p := new(TunnelType)
	*p = x
	return p
}

func (x TunnelType) String() string {
	return proto.EnumName(TunnelType_name, int32(x))
}

func (x *TunnelType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(TunnelType_value, data, "TunnelType")
	if err != nil {
		return err
	}
	*x = TunnelType(value)
	return nil
}

func (TunnelType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_add33052b81b4cd7, []int{0}
}

type ChannelStatus int32

const (
	ChannelStatus_OPEN       ChannelStatus = 1
	ChannelStatus_CLOSING    ChannelStatus = 2
	ChannelStatus_CLOSE      ChannelStatus = 3
	ChannelStatus_TERMINATED ChannelStatus = 4
)

var ChannelStatus_name = map[int32]string{
	1: "OPEN",
	2: "CLOSING",
	3: "CLOSE",
	4: "TERMINATED",
}

var ChannelStatus_value = map[string]int32{
	"OPEN":       1,
	"CLOSING":    2,
	"CLOSE":      3,
	"TERMINATED": 4,
}

func (x ChannelStatus) Enum() *ChannelStatus {
	p := new(ChannelStatus)
	*p = x
	return p
}

func (x ChannelStatus) String() string {
	return proto.EnumName(ChannelStatus_name, int32(x))
}

func (x *ChannelStatus) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(ChannelStatus_value, data, "ChannelStatus")
	if err != nil {
		return err
	}
	*x = ChannelStatus(value)
	return nil
}

func (ChannelStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_add33052b81b4cd7, []int{1}
}

type ActionType int32

const (
	ActionType_PUT_ROW    ActionType = 1
	ActionType_UPDATE_ROW ActionType = 2
	ActionType_DELETE_ROW ActionType = 3
)

var ActionType_name = map[int32]string{
	1: "PUT_ROW",
	2: "UPDATE_ROW",
	3: "DELETE_ROW",
}

var ActionType_value = map[string]int32{
	"PUT_ROW":    1,
	"UPDATE_ROW": 2,
	"DELETE_ROW": 3,
}

func (x ActionType) Enum() *ActionType {
	p := new(ActionType)
	*p = x
	return p
}

func (x ActionType) String() string {
	return proto.EnumName(ActionType_name, int32(x))
}

func (x *ActionType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(ActionType_value, data, "ActionType")
	if err != nil {
		return err
	}
	*x = ActionType(value)
	return nil
}

func (ActionType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_add33052b81b4cd7, []int{2}
}

type StartOffsetFlag int32

const (
	StartOffsetFlag_LATEST   StartOffsetFlag = 0
	StartOffsetFlag_EARLIEST StartOffsetFlag = 1
)

var StartOffsetFlag_name = map[int32]string{
	0: "LATEST",
	1: "EARLIEST",
}

var StartOffsetFlag_value = map[string]int32{
	"LATEST":   0,
	"EARLIEST": 1,
}

func (x StartOffsetFlag) Enum() *StartOffsetFlag {
	p := new(StartOffsetFlag)
	*p = x
	return p
}

func (x StartOffsetFlag) String() string {
	return proto.EnumName(StartOffsetFlag_name, int32(x))
}

func (x *StartOffsetFlag) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(StartOffsetFlag_value, data, "StartOffsetFlag")
	if err != nil {
		return err
	}
	*x = StartOffsetFlag(value)
	return nil
}

func (StartOffsetFlag) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_add33052b81b4cd7, []int{3}
}

type Error struct {
	Code                 *string  `protobuf:"bytes,1,req,name=code" json:"code,omitempty"`
	Message              *string  `protobuf:"bytes,2,opt,name=message" json:"message,omitempty"`
	TunnelId             *string  `protobuf:"bytes,3,opt,name=tunnel_id" json:"tunnel_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Error) Reset()         { *m = Error{} }
func (m *Error) String() string { return proto.CompactTextString(m) }
func (*Error) ProtoMessage()    {}
func (*Error) Descriptor() ([]byte, []int) {
	return fileDescriptor_add33052b81b4cd7, []int{0}
}

func (m *Error) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Error.Unmarshal(m, b)
}
func (m *Error) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Error.Marshal(b, m, deterministic)
}
func (m *Error) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Error.Merge(m, src)
}
func (m *Error) XXX_Size() int {
	return xxx_messageInfo_Error.Size(m)
}
func (m *Error) XXX_DiscardUnknown() {
	xxx_messageInfo_Error.DiscardUnknown(m)
}

var xxx_messageInfo_Error proto.InternalMessageInfo

func (m *Error) GetCode() string {
	if m != nil && m.Code != nil {
		return *m.Code
	}
	return ""
}

func (m *Error) GetMessage() string {
	if m != nil && m.Message != nil {
		return *m.Message
	}
	return ""
}

func (m *Error) GetTunnelId() string {
	if m != nil && m.TunnelId != nil {
		return *m.TunnelId
	}
	return ""
}

type Tunnel struct {
	TableName                *string             `protobuf:"bytes,1,req,name=table_name" json:"table_name,omitempty"`
	TunnelName               *string             `protobuf:"bytes,3,req,name=tunnel_name" json:"tunnel_name,omitempty"`
	TunnelType               *TunnelType         `protobuf:"varint,4,req,name=tunnel_type,enum=protocol.TunnelType" json:"tunnel_type,omitempty"`
	StreamTunnelConfig       *StreamTunnelConfig `protobuf:"bytes,5,opt,name=stream_tunnel_config" json:"stream_tunnel_config,omitempty"`
	NeedAllTimeSeriesColumns *bool               `protobuf:"varint,6,opt,name=need_all_time_series_columns" json:"need_all_time_series_columns,omitempty"`
	XXX_NoUnkeyedLiteral     struct{}            `json:"-"`
	XXX_unrecognized         []byte              `json:"-"`
	XXX_sizecache            int32               `json:"-"`
}

func (m *Tunnel) Reset()         { *m = Tunnel{} }
func (m *Tunnel) String() string { return proto.CompactTextString(m) }
func (*Tunnel) ProtoMessage()    {}
func (*Tunnel) Descriptor() ([]byte, []int) {
	return fileDescriptor_add33052b81b4cd7, []int{1}
}

func (m *Tunnel) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Tunnel.Unmarshal(m, b)
}
func (m *Tunnel) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Tunnel.Marshal(b, m, deterministic)
}
func (m *Tunnel) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Tunnel.Merge(m, src)
}
func (m *Tunnel) XXX_Size() int {
	return xxx_messageInfo_Tunnel.Size(m)
}
func (m *Tunnel) XXX_DiscardUnknown() {
	xxx_messageInfo_Tunnel.DiscardUnknown(m)
}

var xxx_messageInfo_Tunnel proto.InternalMessageInfo

func (m *Tunnel) GetTableName() string {
	if m != nil && m.TableName != nil {
		return *m.TableName
	}
	return ""
}

func (m *Tunnel) GetTunnelName() string {
	if m != nil && m.TunnelName != nil {
		return *m.TunnelName
	}
	return ""
}

func (m *Tunnel) GetTunnelType() TunnelType {
	if m != nil && m.TunnelType != nil {
		return *m.TunnelType
	}
	return TunnelType_BaseData
}

func (m *Tunnel) GetStreamTunnelConfig() *StreamTunnelConfig {
	if m != nil {
		return m.StreamTunnelConfig
	}
	return nil
}

func (m *Tunnel) GetNeedAllTimeSeriesColumns() bool {
	if m != nil && m.NeedAllTimeSeriesColumns != nil {
		return *m.NeedAllTimeSeriesColumns
	}
	return false
}

type CreateTunnelRequest struct {
	Tunnel               *Tunnel  `protobuf:"bytes,1,req,name=tunnel" json:"tunnel,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CreateTunnelRequest) Reset()         { *m = CreateTunnelRequest{} }
func (m *CreateTunnelRequest) String() string { return proto.CompactTextString(m) }
func (*CreateTunnelRequest) ProtoMessage()    {}
func (*CreateTunnelRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_add33052b81b4cd7, []int{2}
}

func (m *CreateTunnelRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CreateTunnelRequest.Unmarshal(m, b)
}
func (m *CreateTunnelRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CreateTunnelRequest.Marshal(b, m, deterministic)
}
func (m *CreateTunnelRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CreateTunnelRequest.Merge(m, src)
}
func (m *CreateTunnelRequest) XXX_Size() int {
	return xxx_messageInfo_CreateTunnelRequest.Size(m)
}
func (m *CreateTunnelRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_CreateTunnelRequest.DiscardUnknown(m)
}

var xxx_messageInfo_CreateTunnelRequest proto.InternalMessageInfo

func (m *CreateTunnelRequest) GetTunnel() *Tunnel {
	if m != nil {
		return m.Tunnel
	}
	return nil
}

type CreateTunnelResponse struct {
	TunnelId             *string  `protobuf:"bytes,1,req,name=tunnel_id" json:"tunnel_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CreateTunnelResponse) Reset()         { *m = CreateTunnelResponse{} }
func (m *CreateTunnelResponse) String() string { return proto.CompactTextString(m) }
func (*CreateTunnelResponse) ProtoMessage()    {}
func (*CreateTunnelResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_add33052b81b4cd7, []int{3}
}

func (m *CreateTunnelResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CreateTunnelResponse.Unmarshal(m, b)
}
func (m *CreateTunnelResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CreateTunnelResponse.Marshal(b, m, deterministic)
}
func (m *CreateTunnelResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CreateTunnelResponse.Merge(m, src)
}
func (m *CreateTunnelResponse) XXX_Size() int {
	return xxx_messageInfo_CreateTunnelResponse.Size(m)
}
func (m *CreateTunnelResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CreateTunnelResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CreateTunnelResponse proto.InternalMessageInfo

func (m *CreateTunnelResponse) GetTunnelId() string {
	if m != nil && m.TunnelId != nil {
		return *m.TunnelId
	}
	return ""
}

type DeleteTunnelRequest struct {
	TableName            *string  `protobuf:"bytes,1,req,name=table_name" json:"table_name,omitempty"`
	TunnelName           *string  `protobuf:"bytes,2,req,name=tunnel_name" json:"tunnel_name,omitempty"`
	TunnelId             *string  `protobuf:"bytes,3,opt,name=tunnel_id" json:"tunnel_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DeleteTunnelRequest) Reset()         { *m = DeleteTunnelRequest{} }
func (m *DeleteTunnelRequest) String() string { return proto.CompactTextString(m) }
func (*DeleteTunnelRequest) ProtoMessage()    {}
func (*DeleteTunnelRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_add33052b81b4cd7, []int{4}
}

func (m *DeleteTunnelRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DeleteTunnelRequest.Unmarshal(m, b)
}
func (m *DeleteTunnelRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DeleteTunnelRequest.Marshal(b, m, deterministic)
}
func (m *DeleteTunnelRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DeleteTunnelRequest.Merge(m, src)
}
func (m *DeleteTunnelRequest) XXX_Size() int {
	return xxx_messageInfo_DeleteTunnelRequest.Size(m)
}
func (m *DeleteTunnelRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_DeleteTunnelRequest.DiscardUnknown(m)
}

var xxx_messageInfo_DeleteTunnelRequest proto.InternalMessageInfo

func (m *DeleteTunnelRequest) GetTableName() string {
	if m != nil && m.TableName != nil {
		return *m.TableName
	}
	return ""
}

func (m *DeleteTunnelRequest) GetTunnelName() string {
	if m != nil && m.TunnelName != nil {
		return *m.TunnelName
	}
	return ""
}

func (m *DeleteTunnelRequest) GetTunnelId() string {
	if m != nil && m.TunnelId != nil {
		return *m.TunnelId
	}
	return ""
}

type DeleteTunnelResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DeleteTunnelResponse) Reset()         { *m = DeleteTunnelResponse{} }
func (m *DeleteTunnelResponse) String() string { return proto.CompactTextString(m) }
func (*DeleteTunnelResponse) ProtoMessage()    {}
func (*DeleteTunnelResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_add33052b81b4cd7, []int{5}
}

func (m *DeleteTunnelResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DeleteTunnelResponse.Unmarshal(m, b)
}
func (m *DeleteTunnelResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DeleteTunnelResponse.Marshal(b, m, deterministic)
}
func (m *DeleteTunnelResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DeleteTunnelResponse.Merge(m, src)
}
func (m *DeleteTunnelResponse) XXX_Size() int {
	return xxx_messageInfo_DeleteTunnelResponse.Size(m)
}
func (m *DeleteTunnelResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_DeleteTunnelResponse.DiscardUnknown(m)
}

var xxx_messageInfo_DeleteTunnelResponse proto.InternalMessageInfo

type ListTunnelRequest struct {
	TableName            *string  `protobuf:"bytes,1,opt,name=table_name" json:"table_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ListTunnelRequest) Reset()         { *m = ListTunnelRequest{} }
func (m *ListTunnelRequest) String() string { return proto.CompactTextString(m) }
func (*ListTunnelRequest) ProtoMessage()    {}
func (*ListTunnelRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_add33052b81b4cd7, []int{6}
}

func (m *ListTunnelRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ListTunnelRequest.Unmarshal(m, b)
}
func (m *ListTunnelRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ListTunnelRequest.Marshal(b, m, deterministic)
}
func (m *ListTunnelRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListTunnelRequest.Merge(m, src)
}
func (m *ListTunnelRequest) XXX_Size() int {
	return xxx_messageInfo_ListTunnelRequest.Size(m)
}
func (m *ListTunnelRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ListTunnelRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ListTunnelRequest proto.InternalMessageInfo

func (m *ListTunnelRequest) GetTableName() string {
	if m != nil && m.TableName != nil {
		return *m.TableName
	}
	return ""
}

type TunnelInfo struct {
	TunnelId             *string             `protobuf:"bytes,1,req,name=tunnel_id" json:"tunnel_id,omitempty"`
	TunnelType           *string             `protobuf:"bytes,2,req,name=tunnel_type" json:"tunnel_type,omitempty"`
	TableName            *string             `protobuf:"bytes,3,req,name=table_name" json:"table_name,omitempty"`
	InstanceName         *string             `protobuf:"bytes,4,req,name=instance_name" json:"instance_name,omitempty"`
	StreamId             *string             `protobuf:"bytes,5,req,name=stream_id" json:"stream_id,omitempty"`
	Stage                *string             `protobuf:"bytes,6,req,name=stage" json:"stage,omitempty"`
	Expired              *bool               `protobuf:"varint,7,opt,name=expired" json:"expired,omitempty"`
	TunnelName           *string             `protobuf:"bytes,8,opt,name=tunnel_name" json:"tunnel_name,omitempty"`
	Public               *bool               `protobuf:"varint,9,opt,name=public" json:"public,omitempty"`
	StreamTunnelConfig   *StreamTunnelConfig `protobuf:"bytes,10,opt,name=stream_tunnel_config" json:"stream_tunnel_config,omitempty"`
	CreateTime           *int64              `protobuf:"varint,11,opt,name=create_time" json:"create_time,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

func (m *TunnelInfo) Reset()         { *m = TunnelInfo{} }
func (m *TunnelInfo) String() string { return proto.CompactTextString(m) }
func (*TunnelInfo) ProtoMessage()    {}
func (*TunnelInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_add33052b81b4cd7, []int{7}
}

func (m *TunnelInfo) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TunnelInfo.Unmarshal(m, b)
}
func (m *TunnelInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TunnelInfo.Marshal(b, m, deterministic)
}
func (m *TunnelInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TunnelInfo.Merge(m, src)
}
func (m *TunnelInfo) XXX_Size() int {
	return xxx_messageInfo_TunnelInfo.Size(m)
}
func (m *TunnelInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_TunnelInfo.DiscardUnknown(m)
}

var xxx_messageInfo_TunnelInfo proto.InternalMessageInfo

func (m *TunnelInfo) GetTunnelId() string {
	if m != nil && m.TunnelId != nil {
		return *m.TunnelId
	}
	return ""
}

func (m *TunnelInfo) GetTunnelType() string {
	if m != nil && m.TunnelType != nil {
		return *m.TunnelType
	}
	return ""
}

func (m *TunnelInfo) GetTableName() string {
	if m != nil && m.TableName != nil {
		return *m.TableName
	}
	return ""
}

func (m *TunnelInfo) GetInstanceName() string {
	if m != nil && m.InstanceName != nil {
		return *m.InstanceName
	}
	return ""
}

func (m *TunnelInfo) GetStreamId() string {
	if m != nil && m.StreamId != nil {
		return *m.StreamId
	}
	return ""
}

func (m *TunnelInfo) GetStage() string {
	if m != nil && m.Stage != nil {
		return *m.Stage
	}
	return ""
}

func (m *TunnelInfo) GetExpired() bool {
	if m != nil && m.Expired != nil {
		return *m.Expired
	}
	return false
}

func (m *TunnelInfo) GetTunnelName() string {
	if m != nil && m.TunnelName != nil {
		return *m.TunnelName
	}
	return ""
}

func (m *TunnelInfo) GetPublic() bool {
	if m != nil && m.Public != nil {
		return *m.Public
	}
	return false
}

func (m *TunnelInfo) GetStreamTunnelConfig() *StreamTunnelConfig {
	if m != nil {
		return m.StreamTunnelConfig
	}
	return nil
}

func (m *TunnelInfo) GetCreateTime() int64 {
	if m != nil && m.CreateTime != nil {
		return *m.CreateTime
	}
	return 0
}

type ListTunnelResponse struct {
	Tunnels              []*TunnelInfo `protobuf:"bytes,1,rep,name=tunnels" json:"tunnels,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func (m *ListTunnelResponse) Reset()         { *m = ListTunnelResponse{} }
func (m *ListTunnelResponse) String() string { return proto.CompactTextString(m) }
func (*ListTunnelResponse) ProtoMessage()    {}
func (*ListTunnelResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_add33052b81b4cd7, []int{8}
}

func (m *ListTunnelResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ListTunnelResponse.Unmarshal(m, b)
}
func (m *ListTunnelResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ListTunnelResponse.Marshal(b, m, deterministic)
}
func (m *ListTunnelResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListTunnelResponse.Merge(m, src)
}
func (m *ListTunnelResponse) XXX_Size() int {
	return xxx_messageInfo_ListTunnelResponse.Size(m)
}
func (m *ListTunnelResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ListTunnelResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ListTunnelResponse proto.InternalMessageInfo

func (m *ListTunnelResponse) GetTunnels() []*TunnelInfo {
	if m != nil {
		return m.Tunnels
	}
	return nil
}

type DescribeTunnelRequest struct {
	TableName            *string  `protobuf:"bytes,1,req,name=table_name" json:"table_name,omitempty"`
	TunnelName           *string  `protobuf:"bytes,2,req,name=tunnel_name" json:"tunnel_name,omitempty"`
	TunnelId             *string  `protobuf:"bytes,3,opt,name=tunnel_id" json:"tunnel_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DescribeTunnelRequest) Reset()         { *m = DescribeTunnelRequest{} }
func (m *DescribeTunnelRequest) String() string { return proto.CompactTextString(m) }
func (*DescribeTunnelRequest) ProtoMessage()    {}
func (*DescribeTunnelRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_add33052b81b4cd7, []int{9}
}

func (m *DescribeTunnelRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DescribeTunnelRequest.Unmarshal(m, b)
}
func (m *DescribeTunnelRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DescribeTunnelRequest.Marshal(b, m, deterministic)
}
func (m *DescribeTunnelRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DescribeTunnelRequest.Merge(m, src)
}
func (m *DescribeTunnelRequest) XXX_Size() int {
	return xxx_messageInfo_DescribeTunnelRequest.Size(m)
}
func (m *DescribeTunnelRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_DescribeTunnelRequest.DiscardUnknown(m)
}

var xxx_messageInfo_DescribeTunnelRequest proto.InternalMessageInfo

func (m *DescribeTunnelRequest) GetTableName() string {
	if m != nil && m.TableName != nil {
		return *m.TableName
	}
	return ""
}

func (m *DescribeTunnelRequest) GetTunnelName() string {
	if m != nil && m.TunnelName != nil {
		return *m.TunnelName
	}
	return ""
}

func (m *DescribeTunnelRequest) GetTunnelId() string {
	if m != nil && m.TunnelId != nil {
		return *m.TunnelId
	}
	return ""
}

type ChannelInfo struct {
	ChannelId            *string  `protobuf:"bytes,1,req,name=channel_id" json:"channel_id,omitempty"`
	ChannelType          *string  `protobuf:"bytes,2,opt,name=channel_type" json:"channel_type,omitempty"`
	ChannelStatus        *string  `protobuf:"bytes,3,opt,name=channel_status" json:"channel_status,omitempty"`
	ClientId             *string  `protobuf:"bytes,4,opt,name=client_id" json:"client_id,omitempty"`
	ChannelRpo           *int64   `protobuf:"varint,5,opt,name=channel_rpo" json:"channel_rpo,omitempty"`
	ChannelCount         *int64   `protobuf:"varint,6,opt,name=channel_count" json:"channel_count,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ChannelInfo) Reset()         { *m = ChannelInfo{} }
func (m *ChannelInfo) String() string { return proto.CompactTextString(m) }
func (*ChannelInfo) ProtoMessage()    {}
func (*ChannelInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_add33052b81b4cd7, []int{10}
}

func (m *ChannelInfo) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ChannelInfo.Unmarshal(m, b)
}
func (m *ChannelInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ChannelInfo.Marshal(b, m, deterministic)
}
func (m *ChannelInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ChannelInfo.Merge(m, src)
}
func (m *ChannelInfo) XXX_Size() int {
	return xxx_messageInfo_ChannelInfo.Size(m)
}
func (m *ChannelInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_ChannelInfo.DiscardUnknown(m)
}

var xxx_messageInfo_ChannelInfo proto.InternalMessageInfo

func (m *ChannelInfo) GetChannelId() string {
	if m != nil && m.ChannelId != nil {
		return *m.ChannelId
	}
	return ""
}

func (m *ChannelInfo) GetChannelType() string {
	if m != nil && m.ChannelType != nil {
		return *m.ChannelType
	}
	return ""
}

func (m *ChannelInfo) GetChannelStatus() string {
	if m != nil && m.ChannelStatus != nil {
		return *m.ChannelStatus
	}
	return ""
}

func (m *ChannelInfo) GetClientId() string {
	if m != nil && m.ClientId != nil {
		return *m.ClientId
	}
	return ""
}

func (m *ChannelInfo) GetChannelRpo() int64 {
	if m != nil && m.ChannelRpo != nil {
		return *m.ChannelRpo
	}
	return 0
}

func (m *ChannelInfo) GetChannelCount() int64 {
	if m != nil && m.ChannelCount != nil {
		return *m.ChannelCount
	}
	return 0
}

type DescribeTunnelResponse struct {
	Tunnel               *TunnelInfo    `protobuf:"bytes,1,req,name=tunnel" json:"tunnel,omitempty"`
	Channels             []*ChannelInfo `protobuf:"bytes,2,rep,name=channels" json:"channels,omitempty"`
	TunnelRpo            *int64         `protobuf:"varint,3,opt,name=tunnel_rpo" json:"tunnel_rpo,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (m *DescribeTunnelResponse) Reset()         { *m = DescribeTunnelResponse{} }
func (m *DescribeTunnelResponse) String() string { return proto.CompactTextString(m) }
func (*DescribeTunnelResponse) ProtoMessage()    {}
func (*DescribeTunnelResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_add33052b81b4cd7, []int{11}
}

func (m *DescribeTunnelResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DescribeTunnelResponse.Unmarshal(m, b)
}
func (m *DescribeTunnelResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DescribeTunnelResponse.Marshal(b, m, deterministic)
}
func (m *DescribeTunnelResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DescribeTunnelResponse.Merge(m, src)
}
func (m *DescribeTunnelResponse) XXX_Size() int {
	return xxx_messageInfo_DescribeTunnelResponse.Size(m)
}
func (m *DescribeTunnelResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_DescribeTunnelResponse.DiscardUnknown(m)
}

var xxx_messageInfo_DescribeTunnelResponse proto.InternalMessageInfo

func (m *DescribeTunnelResponse) GetTunnel() *TunnelInfo {
	if m != nil {
		return m.Tunnel
	}
	return nil
}

func (m *DescribeTunnelResponse) GetChannels() []*ChannelInfo {
	if m != nil {
		return m.Channels
	}
	return nil
}

func (m *DescribeTunnelResponse) GetTunnelRpo() int64 {
	if m != nil && m.TunnelRpo != nil {
		return *m.TunnelRpo
	}
	return 0
}

type GetRpoRequest struct {
	TunnelId             *string  `protobuf:"bytes,1,opt,name=tunnel_id" json:"tunnel_id,omitempty"`
	Limit                *int32   `protobuf:"varint,2,opt,name=limit" json:"limit,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetRpoRequest) Reset()         { *m = GetRpoRequest{} }
func (m *GetRpoRequest) String() string { return proto.CompactTextString(m) }
func (*GetRpoRequest) ProtoMessage()    {}
func (*GetRpoRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_add33052b81b4cd7, []int{12}
}

func (m *GetRpoRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetRpoRequest.Unmarshal(m, b)
}
func (m *GetRpoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetRpoRequest.Marshal(b, m, deterministic)
}
func (m *GetRpoRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetRpoRequest.Merge(m, src)
}
func (m *GetRpoRequest) XXX_Size() int {
	return xxx_messageInfo_GetRpoRequest.Size(m)
}
func (m *GetRpoRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetRpoRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetRpoRequest proto.InternalMessageInfo

func (m *GetRpoRequest) GetTunnelId() string {
	if m != nil && m.TunnelId != nil {
		return *m.TunnelId
	}
	return ""
}

func (m *GetRpoRequest) GetLimit() int32 {
	if m != nil && m.Limit != nil {
		return *m.Limit
	}
	return 0
}

type GetRpoResponse struct {
	RpoInfos             []byte   `protobuf:"bytes,1,opt,name=rpo_infos" json:"rpo_infos,omitempty"`
	TunnelRpoInfos       []byte   `protobuf:"bytes,2,opt,name=tunnel_rpo_infos" json:"tunnel_rpo_infos,omitempty"`
	TunnelId             *string  `protobuf:"bytes,3,opt,name=tunnel_id" json:"tunnel_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetRpoResponse) Reset()         { *m = GetRpoResponse{} }
func (m *GetRpoResponse) String() string { return proto.CompactTextString(m) }
func (*GetRpoResponse) ProtoMessage()    {}
func (*GetRpoResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_add33052b81b4cd7, []int{13}
}

func (m *GetRpoResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetRpoResponse.Unmarshal(m, b)
}
func (m *GetRpoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetRpoResponse.Marshal(b, m, deterministic)
}
func (m *GetRpoResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetRpoResponse.Merge(m, src)
}
func (m *GetRpoResponse) XXX_Size() int {
	return xxx_messageInfo_GetRpoResponse.Size(m)
}
func (m *GetRpoResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GetRpoResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GetRpoResponse proto.InternalMessageInfo

func (m *GetRpoResponse) GetRpoInfos() []byte {
	if m != nil {
		return m.RpoInfos
	}
	return nil
}

func (m *GetRpoResponse) GetTunnelRpoInfos() []byte {
	if m != nil {
		return m.TunnelRpoInfos
	}
	return nil
}

func (m *GetRpoResponse) GetTunnelId() string {
	if m != nil && m.TunnelId != nil {
		return *m.TunnelId
	}
	return ""
}

type ClientConfig struct {
	Timeout              *int64   `protobuf:"varint,1,opt,name=timeout" json:"timeout,omitempty"`
	ClientTag            *string  `protobuf:"bytes,2,opt,name=client_tag" json:"client_tag,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ClientConfig) Reset()         { *m = ClientConfig{} }
func (m *ClientConfig) String() string { return proto.CompactTextString(m) }
func (*ClientConfig) ProtoMessage()    {}
func (*ClientConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_add33052b81b4cd7, []int{14}
}

func (m *ClientConfig) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ClientConfig.Unmarshal(m, b)
}
func (m *ClientConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ClientConfig.Marshal(b, m, deterministic)
}
func (m *ClientConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ClientConfig.Merge(m, src)
}
func (m *ClientConfig) XXX_Size() int {
	return xxx_messageInfo_ClientConfig.Size(m)
}
func (m *ClientConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_ClientConfig.DiscardUnknown(m)
}

var xxx_messageInfo_ClientConfig proto.InternalMessageInfo

func (m *ClientConfig) GetTimeout() int64 {
	if m != nil && m.Timeout != nil {
		return *m.Timeout
	}
	return 0
}

func (m *ClientConfig) GetClientTag() string {
	if m != nil && m.ClientTag != nil {
		return *m.ClientTag
	}
	return ""
}

type ConnectRequest struct {
	TunnelId             *string       `protobuf:"bytes,1,req,name=tunnel_id" json:"tunnel_id,omitempty"`
	ClientConfig         *ClientConfig `protobuf:"bytes,2,opt,name=client_config" json:"client_config,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func (m *ConnectRequest) Reset()         { *m = ConnectRequest{} }
func (m *ConnectRequest) String() string { return proto.CompactTextString(m) }
func (*ConnectRequest) ProtoMessage()    {}
func (*ConnectRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_add33052b81b4cd7, []int{15}
}

func (m *ConnectRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ConnectRequest.Unmarshal(m, b)
}
func (m *ConnectRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ConnectRequest.Marshal(b, m, deterministic)
}
func (m *ConnectRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ConnectRequest.Merge(m, src)
}
func (m *ConnectRequest) XXX_Size() int {
	return xxx_messageInfo_ConnectRequest.Size(m)
}
func (m *ConnectRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ConnectRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ConnectRequest proto.InternalMessageInfo

func (m *ConnectRequest) GetTunnelId() string {
	if m != nil && m.TunnelId != nil {
		return *m.TunnelId
	}
	return ""
}

func (m *ConnectRequest) GetClientConfig() *ClientConfig {
	if m != nil {
		return m.ClientConfig
	}
	return nil
}

type ConnectResponse struct {
	ClientId             *string  `protobuf:"bytes,1,req,name=client_id" json:"client_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ConnectResponse) Reset()         { *m = ConnectResponse{} }
func (m *ConnectResponse) String() string { return proto.CompactTextString(m) }
func (*ConnectResponse) ProtoMessage()    {}
func (*ConnectResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_add33052b81b4cd7, []int{16}
}

func (m *ConnectResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ConnectResponse.Unmarshal(m, b)
}
func (m *ConnectResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ConnectResponse.Marshal(b, m, deterministic)
}
func (m *ConnectResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ConnectResponse.Merge(m, src)
}
func (m *ConnectResponse) XXX_Size() int {
	return xxx_messageInfo_ConnectResponse.Size(m)
}
func (m *ConnectResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ConnectResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ConnectResponse proto.InternalMessageInfo

func (m *ConnectResponse) GetClientId() string {
	if m != nil && m.ClientId != nil {
		return *m.ClientId
	}
	return ""
}

type Channel struct {
	ChannelId            *string        `protobuf:"bytes,1,req,name=channel_id" json:"channel_id,omitempty"`
	Version              *int64         `protobuf:"varint,2,req,name=version" json:"version,omitempty"`
	Status               *ChannelStatus `protobuf:"varint,3,req,name=status,enum=protocol.ChannelStatus" json:"status,omitempty"`
	Detail               []byte         `protobuf:"bytes,4,opt,name=detail" json:"detail,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (m *Channel) Reset()         { *m = Channel{} }
func (m *Channel) String() string { return proto.CompactTextString(m) }
func (*Channel) ProtoMessage()    {}
func (*Channel) Descriptor() ([]byte, []int) {
	return fileDescriptor_add33052b81b4cd7, []int{17}
}

func (m *Channel) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Channel.Unmarshal(m, b)
}
func (m *Channel) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Channel.Marshal(b, m, deterministic)
}
func (m *Channel) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Channel.Merge(m, src)
}
func (m *Channel) XXX_Size() int {
	return xxx_messageInfo_Channel.Size(m)
}
func (m *Channel) XXX_DiscardUnknown() {
	xxx_messageInfo_Channel.DiscardUnknown(m)
}

var xxx_messageInfo_Channel proto.InternalMessageInfo

func (m *Channel) GetChannelId() string {
	if m != nil && m.ChannelId != nil {
		return *m.ChannelId
	}
	return ""
}

func (m *Channel) GetVersion() int64 {
	if m != nil && m.Version != nil {
		return *m.Version
	}
	return 0
}

func (m *Channel) GetStatus() ChannelStatus {
	if m != nil && m.Status != nil {
		return *m.Status
	}
	return ChannelStatus_OPEN
}

func (m *Channel) GetDetail() []byte {
	if m != nil {
		return m.Detail
	}
	return nil
}

type HeartbeatRequest struct {
	TunnelId             *string    `protobuf:"bytes,1,req,name=tunnel_id" json:"tunnel_id,omitempty"`
	ClientId             *string    `protobuf:"bytes,2,req,name=client_id" json:"client_id,omitempty"`
	Channels             []*Channel `protobuf:"bytes,3,rep,name=channels" json:"channels,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *HeartbeatRequest) Reset()         { *m = HeartbeatRequest{} }
func (m *HeartbeatRequest) String() string { return proto.CompactTextString(m) }
func (*HeartbeatRequest) ProtoMessage()    {}
func (*HeartbeatRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_add33052b81b4cd7, []int{18}
}

func (m *HeartbeatRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_HeartbeatRequest.Unmarshal(m, b)
}
func (m *HeartbeatRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_HeartbeatRequest.Marshal(b, m, deterministic)
}
func (m *HeartbeatRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HeartbeatRequest.Merge(m, src)
}
func (m *HeartbeatRequest) XXX_Size() int {
	return xxx_messageInfo_HeartbeatRequest.Size(m)
}
func (m *HeartbeatRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_HeartbeatRequest.DiscardUnknown(m)
}

var xxx_messageInfo_HeartbeatRequest proto.InternalMessageInfo

func (m *HeartbeatRequest) GetTunnelId() string {
	if m != nil && m.TunnelId != nil {
		return *m.TunnelId
	}
	return ""
}

func (m *HeartbeatRequest) GetClientId() string {
	if m != nil && m.ClientId != nil {
		return *m.ClientId
	}
	return ""
}

func (m *HeartbeatRequest) GetChannels() []*Channel {
	if m != nil {
		return m.Channels
	}
	return nil
}

type HeartbeatResponse struct {
	Channels             []*Channel `protobuf:"bytes,1,rep,name=channels" json:"channels,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *HeartbeatResponse) Reset()         { *m = HeartbeatResponse{} }
func (m *HeartbeatResponse) String() string { return proto.CompactTextString(m) }
func (*HeartbeatResponse) ProtoMessage()    {}
func (*HeartbeatResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_add33052b81b4cd7, []int{19}
}

func (m *HeartbeatResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_HeartbeatResponse.Unmarshal(m, b)
}
func (m *HeartbeatResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_HeartbeatResponse.Marshal(b, m, deterministic)
}
func (m *HeartbeatResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HeartbeatResponse.Merge(m, src)
}
func (m *HeartbeatResponse) XXX_Size() int {
	return xxx_messageInfo_HeartbeatResponse.Size(m)
}
func (m *HeartbeatResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_HeartbeatResponse.DiscardUnknown(m)
}

var xxx_messageInfo_HeartbeatResponse proto.InternalMessageInfo

func (m *HeartbeatResponse) GetChannels() []*Channel {
	if m != nil {
		return m.Channels
	}
	return nil
}

type ShutdownRequest struct {
	TunnelId             *string  `protobuf:"bytes,1,req,name=tunnel_id" json:"tunnel_id,omitempty"`
	ClientId             *string  `protobuf:"bytes,2,req,name=client_id" json:"client_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ShutdownRequest) Reset()         { *m = ShutdownRequest{} }
func (m *ShutdownRequest) String() string { return proto.CompactTextString(m) }
func (*ShutdownRequest) ProtoMessage()    {}
func (*ShutdownRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_add33052b81b4cd7, []int{20}
}

func (m *ShutdownRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ShutdownRequest.Unmarshal(m, b)
}
func (m *ShutdownRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ShutdownRequest.Marshal(b, m, deterministic)
}
func (m *ShutdownRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ShutdownRequest.Merge(m, src)
}
func (m *ShutdownRequest) XXX_Size() int {
	return xxx_messageInfo_ShutdownRequest.Size(m)
}
func (m *ShutdownRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ShutdownRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ShutdownRequest proto.InternalMessageInfo

func (m *ShutdownRequest) GetTunnelId() string {
	if m != nil && m.TunnelId != nil {
		return *m.TunnelId
	}
	return ""
}

func (m *ShutdownRequest) GetClientId() string {
	if m != nil && m.ClientId != nil {
		return *m.ClientId
	}
	return ""
}

type ShutdownResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ShutdownResponse) Reset()         { *m = ShutdownResponse{} }
func (m *ShutdownResponse) String() string { return proto.CompactTextString(m) }
func (*ShutdownResponse) ProtoMessage()    {}
func (*ShutdownResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_add33052b81b4cd7, []int{21}
}

func (m *ShutdownResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ShutdownResponse.Unmarshal(m, b)
}
func (m *ShutdownResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ShutdownResponse.Marshal(b, m, deterministic)
}
func (m *ShutdownResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ShutdownResponse.Merge(m, src)
}
func (m *ShutdownResponse) XXX_Size() int {
	return xxx_messageInfo_ShutdownResponse.Size(m)
}
func (m *ShutdownResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ShutdownResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ShutdownResponse proto.InternalMessageInfo

type LockChannelRequest struct {
	TunnelId             *string  `protobuf:"bytes,1,req,name=tunnel_id" json:"tunnel_id,omitempty"`
	ClientId             *string  `protobuf:"bytes,2,req,name=client_id" json:"client_id,omitempty"`
	ChannelId            *string  `protobuf:"bytes,3,req,name=channel_id" json:"channel_id,omitempty"`
	LockId               *string  `protobuf:"bytes,4,req,name=lock_id" json:"lock_id,omitempty"`
	Timeout              *int64   `protobuf:"varint,5,req,name=timeout" json:"timeout,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *LockChannelRequest) Reset()         { *m = LockChannelRequest{} }
func (m *LockChannelRequest) String() string { return proto.CompactTextString(m) }
func (*LockChannelRequest) ProtoMessage()    {}
func (*LockChannelRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_add33052b81b4cd7, []int{22}
}

func (m *LockChannelRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_LockChannelRequest.Unmarshal(m, b)
}
func (m *LockChannelRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_LockChannelRequest.Marshal(b, m, deterministic)
}
func (m *LockChannelRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LockChannelRequest.Merge(m, src)
}
func (m *LockChannelRequest) XXX_Size() int {
	return xxx_messageInfo_LockChannelRequest.Size(m)
}
func (m *LockChannelRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_LockChannelRequest.DiscardUnknown(m)
}

var xxx_messageInfo_LockChannelRequest proto.InternalMessageInfo

func (m *LockChannelRequest) GetTunnelId() string {
	if m != nil && m.TunnelId != nil {
		return *m.TunnelId
	}
	return ""
}

func (m *LockChannelRequest) GetClientId() string {
	if m != nil && m.ClientId != nil {
		return *m.ClientId
	}
	return ""
}

func (m *LockChannelRequest) GetChannelId() string {
	if m != nil && m.ChannelId != nil {
		return *m.ChannelId
	}
	return ""
}

func (m *LockChannelRequest) GetLockId() string {
	if m != nil && m.LockId != nil {
		return *m.LockId
	}
	return ""
}

func (m *LockChannelRequest) GetTimeout() int64 {
	if m != nil && m.Timeout != nil {
		return *m.Timeout
	}
	return 0
}

type LockChannelResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *LockChannelResponse) Reset()         { *m = LockChannelResponse{} }
func (m *LockChannelResponse) String() string { return proto.CompactTextString(m) }
func (*LockChannelResponse) ProtoMessage()    {}
func (*LockChannelResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_add33052b81b4cd7, []int{23}
}

func (m *LockChannelResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_LockChannelResponse.Unmarshal(m, b)
}
func (m *LockChannelResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_LockChannelResponse.Marshal(b, m, deterministic)
}
func (m *LockChannelResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LockChannelResponse.Merge(m, src)
}
func (m *LockChannelResponse) XXX_Size() int {
	return xxx_messageInfo_LockChannelResponse.Size(m)
}
func (m *LockChannelResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_LockChannelResponse.DiscardUnknown(m)
}

var xxx_messageInfo_LockChannelResponse proto.InternalMessageInfo

type UnlockChannelRequest struct {
	TunnelId             *string  `protobuf:"bytes,1,req,name=tunnel_id" json:"tunnel_id,omitempty"`
	ClientId             *string  `protobuf:"bytes,2,req,name=client_id" json:"client_id,omitempty"`
	ChannelId            *string  `protobuf:"bytes,3,req,name=channel_id" json:"channel_id,omitempty"`
	LockId               *string  `protobuf:"bytes,4,req,name=lock_id" json:"lock_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *UnlockChannelRequest) Reset()         { *m = UnlockChannelRequest{} }
func (m *UnlockChannelRequest) String() string { return proto.CompactTextString(m) }
func (*UnlockChannelRequest) ProtoMessage()    {}
func (*UnlockChannelRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_add33052b81b4cd7, []int{24}
}

func (m *UnlockChannelRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_UnlockChannelRequest.Unmarshal(m, b)
}
func (m *UnlockChannelRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_UnlockChannelRequest.Marshal(b, m, deterministic)
}
func (m *UnlockChannelRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UnlockChannelRequest.Merge(m, src)
}
func (m *UnlockChannelRequest) XXX_Size() int {
	return xxx_messageInfo_UnlockChannelRequest.Size(m)
}
func (m *UnlockChannelRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_UnlockChannelRequest.DiscardUnknown(m)
}

var xxx_messageInfo_UnlockChannelRequest proto.InternalMessageInfo

func (m *UnlockChannelRequest) GetTunnelId() string {
	if m != nil && m.TunnelId != nil {
		return *m.TunnelId
	}
	return ""
}

func (m *UnlockChannelRequest) GetClientId() string {
	if m != nil && m.ClientId != nil {
		return *m.ClientId
	}
	return ""
}

func (m *UnlockChannelRequest) GetChannelId() string {
	if m != nil && m.ChannelId != nil {
		return *m.ChannelId
	}
	return ""
}

func (m *UnlockChannelRequest) GetLockId() string {
	if m != nil && m.LockId != nil {
		return *m.LockId
	}
	return ""
}

type UnlockChannelResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *UnlockChannelResponse) Reset()         { *m = UnlockChannelResponse{} }
func (m *UnlockChannelResponse) String() string { return proto.CompactTextString(m) }
func (*UnlockChannelResponse) ProtoMessage()    {}
func (*UnlockChannelResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_add33052b81b4cd7, []int{25}
}

func (m *UnlockChannelResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_UnlockChannelResponse.Unmarshal(m, b)
}
func (m *UnlockChannelResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_UnlockChannelResponse.Marshal(b, m, deterministic)
}
func (m *UnlockChannelResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UnlockChannelResponse.Merge(m, src)
}
func (m *UnlockChannelResponse) XXX_Size() int {
	return xxx_messageInfo_UnlockChannelResponse.Size(m)
}
func (m *UnlockChannelResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_UnlockChannelResponse.DiscardUnknown(m)
}

var xxx_messageInfo_UnlockChannelResponse proto.InternalMessageInfo

type GetCheckpointRequest struct {
	TunnelId             *string  `protobuf:"bytes,1,req,name=tunnel_id" json:"tunnel_id,omitempty"`
	ClientId             *string  `protobuf:"bytes,2,req,name=client_id" json:"client_id,omitempty"`
	ChannelId            *string  `protobuf:"bytes,3,req,name=channel_id" json:"channel_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetCheckpointRequest) Reset()         { *m = GetCheckpointRequest{} }
func (m *GetCheckpointRequest) String() string { return proto.CompactTextString(m) }
func (*GetCheckpointRequest) ProtoMessage()    {}
func (*GetCheckpointRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_add33052b81b4cd7, []int{26}
}

func (m *GetCheckpointRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetCheckpointRequest.Unmarshal(m, b)
}
func (m *GetCheckpointRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetCheckpointRequest.Marshal(b, m, deterministic)
}
func (m *GetCheckpointRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetCheckpointRequest.Merge(m, src)
}
func (m *GetCheckpointRequest) XXX_Size() int {
	return xxx_messageInfo_GetCheckpointRequest.Size(m)
}
func (m *GetCheckpointRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetCheckpointRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetCheckpointRequest proto.InternalMessageInfo

func (m *GetCheckpointRequest) GetTunnelId() string {
	if m != nil && m.TunnelId != nil {
		return *m.TunnelId
	}
	return ""
}

func (m *GetCheckpointRequest) GetClientId() string {
	if m != nil && m.ClientId != nil {
		return *m.ClientId
	}
	return ""
}

func (m *GetCheckpointRequest) GetChannelId() string {
	if m != nil && m.ChannelId != nil {
		return *m.ChannelId
	}
	return ""
}

type GetCheckpointResponse struct {
	Checkpoint           *string  `protobuf:"bytes,1,req,name=checkpoint" json:"checkpoint,omitempty"`
	SequenceNumber       *int64   `protobuf:"varint,2,req,name=sequence_number" json:"sequence_number,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetCheckpointResponse) Reset()         { *m = GetCheckpointResponse{} }
func (m *GetCheckpointResponse) String() string { return proto.CompactTextString(m) }
func (*GetCheckpointResponse) ProtoMessage()    {}
func (*GetCheckpointResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_add33052b81b4cd7, []int{27}
}

func (m *GetCheckpointResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetCheckpointResponse.Unmarshal(m, b)
}
func (m *GetCheckpointResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetCheckpointResponse.Marshal(b, m, deterministic)
}
func (m *GetCheckpointResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetCheckpointResponse.Merge(m, src)
}
func (m *GetCheckpointResponse) XXX_Size() int {
	return xxx_messageInfo_GetCheckpointResponse.Size(m)
}
func (m *GetCheckpointResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GetCheckpointResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GetCheckpointResponse proto.InternalMessageInfo

func (m *GetCheckpointResponse) GetCheckpoint() string {
	if m != nil && m.Checkpoint != nil {
		return *m.Checkpoint
	}
	return ""
}

func (m *GetCheckpointResponse) GetSequenceNumber() int64 {
	if m != nil && m.SequenceNumber != nil {
		return *m.SequenceNumber
	}
	return 0
}

type CheckpointRequest struct {
	TunnelId             *string  `protobuf:"bytes,1,req,name=tunnel_id" json:"tunnel_id,omitempty"`
	ClientId             *string  `protobuf:"bytes,2,req,name=client_id" json:"client_id,omitempty"`
	ChannelId            *string  `protobuf:"bytes,3,req,name=channel_id" json:"channel_id,omitempty"`
	Checkpoint           *string  `protobuf:"bytes,4,req,name=checkpoint" json:"checkpoint,omitempty"`
	SequenceNumber       *int64   `protobuf:"varint,5,req,name=sequence_number" json:"sequence_number,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CheckpointRequest) Reset()         { *m = CheckpointRequest{} }
func (m *CheckpointRequest) String() string { return proto.CompactTextString(m) }
func (*CheckpointRequest) ProtoMessage()    {}
func (*CheckpointRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_add33052b81b4cd7, []int{28}
}

func (m *CheckpointRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CheckpointRequest.Unmarshal(m, b)
}
func (m *CheckpointRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CheckpointRequest.Marshal(b, m, deterministic)
}
func (m *CheckpointRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CheckpointRequest.Merge(m, src)
}
func (m *CheckpointRequest) XXX_Size() int {
	return xxx_messageInfo_CheckpointRequest.Size(m)
}
func (m *CheckpointRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_CheckpointRequest.DiscardUnknown(m)
}

var xxx_messageInfo_CheckpointRequest proto.InternalMessageInfo

func (m *CheckpointRequest) GetTunnelId() string {
	if m != nil && m.TunnelId != nil {
		return *m.TunnelId
	}
	return ""
}

func (m *CheckpointRequest) GetClientId() string {
	if m != nil && m.ClientId != nil {
		return *m.ClientId
	}
	return ""
}

func (m *CheckpointRequest) GetChannelId() string {
	if m != nil && m.ChannelId != nil {
		return *m.ChannelId
	}
	return ""
}

func (m *CheckpointRequest) GetCheckpoint() string {
	if m != nil && m.Checkpoint != nil {
		return *m.Checkpoint
	}
	return ""
}

func (m *CheckpointRequest) GetSequenceNumber() int64 {
	if m != nil && m.SequenceNumber != nil {
		return *m.SequenceNumber
	}
	return 0
}

type CheckpointResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CheckpointResponse) Reset()         { *m = CheckpointResponse{} }
func (m *CheckpointResponse) String() string { return proto.CompactTextString(m) }
func (*CheckpointResponse) ProtoMessage()    {}
func (*CheckpointResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_add33052b81b4cd7, []int{29}
}

func (m *CheckpointResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CheckpointResponse.Unmarshal(m, b)
}
func (m *CheckpointResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CheckpointResponse.Marshal(b, m, deterministic)
}
func (m *CheckpointResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CheckpointResponse.Merge(m, src)
}
func (m *CheckpointResponse) XXX_Size() int {
	return xxx_messageInfo_CheckpointResponse.Size(m)
}
func (m *CheckpointResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CheckpointResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CheckpointResponse proto.InternalMessageInfo

type ReadRecordsRequest struct {
	TunnelId             *string  `protobuf:"bytes,1,req,name=tunnel_id" json:"tunnel_id,omitempty"`
	ClientId             *string  `protobuf:"bytes,2,req,name=client_id" json:"client_id,omitempty"`
	ChannelId            *string  `protobuf:"bytes,3,req,name=channel_id" json:"channel_id,omitempty"`
	Token                *string  `protobuf:"bytes,4,req,name=token" json:"token,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ReadRecordsRequest) Reset()         { *m = ReadRecordsRequest{} }
func (m *ReadRecordsRequest) String() string { return proto.CompactTextString(m) }
func (*ReadRecordsRequest) ProtoMessage()    {}
func (*ReadRecordsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_add33052b81b4cd7, []int{30}
}

func (m *ReadRecordsRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ReadRecordsRequest.Unmarshal(m, b)
}
func (m *ReadRecordsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ReadRecordsRequest.Marshal(b, m, deterministic)
}
func (m *ReadRecordsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReadRecordsRequest.Merge(m, src)
}
func (m *ReadRecordsRequest) XXX_Size() int {
	return xxx_messageInfo_ReadRecordsRequest.Size(m)
}
func (m *ReadRecordsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ReadRecordsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ReadRecordsRequest proto.InternalMessageInfo

func (m *ReadRecordsRequest) GetTunnelId() string {
	if m != nil && m.TunnelId != nil {
		return *m.TunnelId
	}
	return ""
}

func (m *ReadRecordsRequest) GetClientId() string {
	if m != nil && m.ClientId != nil {
		return *m.ClientId
	}
	return ""
}

func (m *ReadRecordsRequest) GetChannelId() string {
	if m != nil && m.ChannelId != nil {
		return *m.ChannelId
	}
	return ""
}

func (m *ReadRecordsRequest) GetToken() string {
	if m != nil && m.Token != nil {
		return *m.Token
	}
	return ""
}

type Record struct {
	ActionType           *ActionType `protobuf:"varint,1,req,name=action_type,enum=protocol.ActionType" json:"action_type,omitempty"`
	Record               []byte      `protobuf:"bytes,2,req,name=record" json:"record,omitempty"`
	OriginRecord         []byte      `protobuf:"bytes,3,opt,name=origin_record" json:"origin_record,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *Record) Reset()         { *m = Record{} }
func (m *Record) String() string { return proto.CompactTextString(m) }
func (*Record) ProtoMessage()    {}
func (*Record) Descriptor() ([]byte, []int) {
	return fileDescriptor_add33052b81b4cd7, []int{31}
}

func (m *Record) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Record.Unmarshal(m, b)
}
func (m *Record) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Record.Marshal(b, m, deterministic)
}
func (m *Record) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Record.Merge(m, src)
}
func (m *Record) XXX_Size() int {
	return xxx_messageInfo_Record.Size(m)
}
func (m *Record) XXX_DiscardUnknown() {
	xxx_messageInfo_Record.DiscardUnknown(m)
}

var xxx_messageInfo_Record proto.InternalMessageInfo

func (m *Record) GetActionType() ActionType {
	if m != nil && m.ActionType != nil {
		return *m.ActionType
	}
	return ActionType_PUT_ROW
}

func (m *Record) GetRecord() []byte {
	if m != nil {
		return m.Record
	}
	return nil
}

func (m *Record) GetOriginRecord() []byte {
	if m != nil {
		return m.OriginRecord
	}
	return nil
}

type ReadRecordsResponse struct {
	Records              []*Record `protobuf:"bytes,1,rep,name=records" json:"records,omitempty"`
	NextToken            *string   `protobuf:"bytes,2,req,name=next_token" json:"next_token,omitempty"`
	MayMoreRecord        *bool     `protobuf:"varint,3,opt,name=may_more_record" json:"may_more_record,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *ReadRecordsResponse) Reset()         { *m = ReadRecordsResponse{} }
func (m *ReadRecordsResponse) String() string { return proto.CompactTextString(m) }
func (*ReadRecordsResponse) ProtoMessage()    {}
func (*ReadRecordsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_add33052b81b4cd7, []int{32}
}

func (m *ReadRecordsResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ReadRecordsResponse.Unmarshal(m, b)
}
func (m *ReadRecordsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ReadRecordsResponse.Marshal(b, m, deterministic)
}
func (m *ReadRecordsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReadRecordsResponse.Merge(m, src)
}
func (m *ReadRecordsResponse) XXX_Size() int {
	return xxx_messageInfo_ReadRecordsResponse.Size(m)
}
func (m *ReadRecordsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ReadRecordsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ReadRecordsResponse proto.InternalMessageInfo

func (m *ReadRecordsResponse) GetRecords() []*Record {
	if m != nil {
		return m.Records
	}
	return nil
}

func (m *ReadRecordsResponse) GetNextToken() string {
	if m != nil && m.NextToken != nil {
		return *m.NextToken
	}
	return ""
}

func (m *ReadRecordsResponse) GetMayMoreRecord() bool {
	if m != nil && m.MayMoreRecord != nil {
		return *m.MayMoreRecord
	}
	return false
}

type Token struct {
	Version              *int64   `protobuf:"varint,1,req,name=version" json:"version,omitempty"`
	Content              []byte   `protobuf:"bytes,2,req,name=content" json:"content,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Token) Reset()         { *m = Token{} }
func (m *Token) String() string { return proto.CompactTextString(m) }
func (*Token) ProtoMessage()    {}
func (*Token) Descriptor() ([]byte, []int) {
	return fileDescriptor_add33052b81b4cd7, []int{33}
}

func (m *Token) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Token.Unmarshal(m, b)
}
func (m *Token) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Token.Marshal(b, m, deterministic)
}
func (m *Token) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Token.Merge(m, src)
}
func (m *Token) XXX_Size() int {
	return xxx_messageInfo_Token.Size(m)
}
func (m *Token) XXX_DiscardUnknown() {
	xxx_messageInfo_Token.DiscardUnknown(m)
}

var xxx_messageInfo_Token proto.InternalMessageInfo

func (m *Token) GetVersion() int64 {
	if m != nil && m.Version != nil {
		return *m.Version
	}
	return 0
}

func (m *Token) GetContent() []byte {
	if m != nil {
		return m.Content
	}
	return nil
}

type TokenContent struct {
	PrimaryKey           []byte   `protobuf:"bytes,1,opt,name=primary_key" json:"primary_key,omitempty"`
	Iterator             *string  `protobuf:"bytes,2,opt,name=iterator" json:"iterator,omitempty"`
	Timestamp            *int64   `protobuf:"varint,3,opt,name=timestamp" json:"timestamp,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TokenContent) Reset()         { *m = TokenContent{} }
func (m *TokenContent) String() string { return proto.CompactTextString(m) }
func (*TokenContent) ProtoMessage()    {}
func (*TokenContent) Descriptor() ([]byte, []int) {
	return fileDescriptor_add33052b81b4cd7, []int{34}
}

func (m *TokenContent) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TokenContent.Unmarshal(m, b)
}
func (m *TokenContent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TokenContent.Marshal(b, m, deterministic)
}
func (m *TokenContent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TokenContent.Merge(m, src)
}
func (m *TokenContent) XXX_Size() int {
	return xxx_messageInfo_TokenContent.Size(m)
}
func (m *TokenContent) XXX_DiscardUnknown() {
	xxx_messageInfo_TokenContent.DiscardUnknown(m)
}

var xxx_messageInfo_TokenContent proto.InternalMessageInfo

func (m *TokenContent) GetPrimaryKey() []byte {
	if m != nil {
		return m.PrimaryKey
	}
	return nil
}

func (m *TokenContent) GetIterator() string {
	if m != nil && m.Iterator != nil {
		return *m.Iterator
	}
	return ""
}

func (m *TokenContent) GetTimestamp() int64 {
	if m != nil && m.Timestamp != nil {
		return *m.Timestamp
	}
	return 0
}

type TokenContentV2 struct {
	PrimaryKey           []byte   `protobuf:"bytes,1,opt,name=primary_key" json:"primary_key,omitempty"`
	Iterator             *string  `protobuf:"bytes,2,opt,name=iterator" json:"iterator,omitempty"`
	Timestamp            *int64   `protobuf:"varint,3,opt,name=timestamp" json:"timestamp,omitempty"`
	TotalCount           *int64   `protobuf:"varint,4,opt,name=total_count" json:"total_count,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TokenContentV2) Reset()         { *m = TokenContentV2{} }
func (m *TokenContentV2) String() string { return proto.CompactTextString(m) }
func (*TokenContentV2) ProtoMessage()    {}
func (*TokenContentV2) Descriptor() ([]byte, []int) {
	return fileDescriptor_add33052b81b4cd7, []int{35}
}

func (m *TokenContentV2) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TokenContentV2.Unmarshal(m, b)
}
func (m *TokenContentV2) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TokenContentV2.Marshal(b, m, deterministic)
}
func (m *TokenContentV2) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TokenContentV2.Merge(m, src)
}
func (m *TokenContentV2) XXX_Size() int {
	return xxx_messageInfo_TokenContentV2.Size(m)
}
func (m *TokenContentV2) XXX_DiscardUnknown() {
	xxx_messageInfo_TokenContentV2.DiscardUnknown(m)
}

var xxx_messageInfo_TokenContentV2 proto.InternalMessageInfo

func (m *TokenContentV2) GetPrimaryKey() []byte {
	if m != nil {
		return m.PrimaryKey
	}
	return nil
}

func (m *TokenContentV2) GetIterator() string {
	if m != nil && m.Iterator != nil {
		return *m.Iterator
	}
	return ""
}

func (m *TokenContentV2) GetTimestamp() int64 {
	if m != nil && m.Timestamp != nil {
		return *m.Timestamp
	}
	return 0
}

func (m *TokenContentV2) GetTotalCount() int64 {
	if m != nil && m.TotalCount != nil {
		return *m.TotalCount
	}
	return 0
}

type StreamTunnelConfig struct {
	Flag                 *StartOffsetFlag `protobuf:"varint,1,opt,name=flag,enum=protocol.StartOffsetFlag" json:"flag,omitempty"`
	StartOffset          *uint64          `protobuf:"varint,2,opt,name=startOffset" json:"startOffset,omitempty"`
	EndOffset            *uint64          `protobuf:"varint,3,opt,name=endOffset" json:"endOffset,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (m *StreamTunnelConfig) Reset()         { *m = StreamTunnelConfig{} }
func (m *StreamTunnelConfig) String() string { return proto.CompactTextString(m) }
func (*StreamTunnelConfig) ProtoMessage()    {}
func (*StreamTunnelConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_add33052b81b4cd7, []int{36}
}

func (m *StreamTunnelConfig) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StreamTunnelConfig.Unmarshal(m, b)
}
func (m *StreamTunnelConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StreamTunnelConfig.Marshal(b, m, deterministic)
}
func (m *StreamTunnelConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StreamTunnelConfig.Merge(m, src)
}
func (m *StreamTunnelConfig) XXX_Size() int {
	return xxx_messageInfo_StreamTunnelConfig.Size(m)
}
func (m *StreamTunnelConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_StreamTunnelConfig.DiscardUnknown(m)
}

var xxx_messageInfo_StreamTunnelConfig proto.InternalMessageInfo

func (m *StreamTunnelConfig) GetFlag() StartOffsetFlag {
	if m != nil && m.Flag != nil {
		return *m.Flag
	}
	return StartOffsetFlag_LATEST
}

func (m *StreamTunnelConfig) GetStartOffset() uint64 {
	if m != nil && m.StartOffset != nil {
		return *m.StartOffset
	}
	return 0
}

func (m *StreamTunnelConfig) GetEndOffset() uint64 {
	if m != nil && m.EndOffset != nil {
		return *m.EndOffset
	}
	return 0
}

type ScheduleRequest struct {
	TunnelId             *string    `protobuf:"bytes,1,req,name=tunnel_id" json:"tunnel_id,omitempty"`
	Channels             []*Channel `protobuf:"bytes,3,rep,name=channels" json:"channels,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *ScheduleRequest) Reset()         { *m = ScheduleRequest{} }
func (m *ScheduleRequest) String() string { return proto.CompactTextString(m) }
func (*ScheduleRequest) ProtoMessage()    {}
func (*ScheduleRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_add33052b81b4cd7, []int{37}
}

func (m *ScheduleRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ScheduleRequest.Unmarshal(m, b)
}
func (m *ScheduleRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ScheduleRequest.Marshal(b, m, deterministic)
}
func (m *ScheduleRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ScheduleRequest.Merge(m, src)
}
func (m *ScheduleRequest) XXX_Size() int {
	return xxx_messageInfo_ScheduleRequest.Size(m)
}
func (m *ScheduleRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ScheduleRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ScheduleRequest proto.InternalMessageInfo

func (m *ScheduleRequest) GetTunnelId() string {
	if m != nil && m.TunnelId != nil {
		return *m.TunnelId
	}
	return ""
}

func (m *ScheduleRequest) GetChannels() []*Channel {
	if m != nil {
		return m.Channels
	}
	return nil
}

type ScheduleResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ScheduleResponse) Reset()         { *m = ScheduleResponse{} }
func (m *ScheduleResponse) String() string { return proto.CompactTextString(m) }
func (*ScheduleResponse) ProtoMessage()    {}
func (*ScheduleResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_add33052b81b4cd7, []int{38}
}

func (m *ScheduleResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ScheduleResponse.Unmarshal(m, b)
}
func (m *ScheduleResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ScheduleResponse.Marshal(b, m, deterministic)
}
func (m *ScheduleResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ScheduleResponse.Merge(m, src)
}
func (m *ScheduleResponse) XXX_Size() int {
	return xxx_messageInfo_ScheduleResponse.Size(m)
}
func (m *ScheduleResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ScheduleResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ScheduleResponse proto.InternalMessageInfo

func init() {
	proto.RegisterEnum("protocol.TunnelType", TunnelType_name, TunnelType_value)
	proto.RegisterEnum("protocol.ChannelStatus", ChannelStatus_name, ChannelStatus_value)
	proto.RegisterEnum("protocol.ActionType", ActionType_name, ActionType_value)
	proto.RegisterEnum("protocol.StartOffsetFlag", StartOffsetFlag_name, StartOffsetFlag_value)
	proto.RegisterType((*Error)(nil), "protocol.Error")
	proto.RegisterType((*Tunnel)(nil), "protocol.Tunnel")
	proto.RegisterType((*CreateTunnelRequest)(nil), "protocol.CreateTunnelRequest")
	proto.RegisterType((*CreateTunnelResponse)(nil), "protocol.CreateTunnelResponse")
	proto.RegisterType((*DeleteTunnelRequest)(nil), "protocol.DeleteTunnelRequest")
	proto.RegisterType((*DeleteTunnelResponse)(nil), "protocol.DeleteTunnelResponse")
	proto.RegisterType((*ListTunnelRequest)(nil), "protocol.ListTunnelRequest")
	proto.RegisterType((*TunnelInfo)(nil), "protocol.TunnelInfo")
	proto.RegisterType((*ListTunnelResponse)(nil), "protocol.ListTunnelResponse")
	proto.RegisterType((*DescribeTunnelRequest)(nil), "protocol.DescribeTunnelRequest")
	proto.RegisterType((*ChannelInfo)(nil), "protocol.ChannelInfo")
	proto.RegisterType((*DescribeTunnelResponse)(nil), "protocol.DescribeTunnelResponse")
	proto.RegisterType((*GetRpoRequest)(nil), "protocol.GetRpoRequest")
	proto.RegisterType((*GetRpoResponse)(nil), "protocol.GetRpoResponse")
	proto.RegisterType((*ClientConfig)(nil), "protocol.ClientConfig")
	proto.RegisterType((*ConnectRequest)(nil), "protocol.ConnectRequest")
	proto.RegisterType((*ConnectResponse)(nil), "protocol.ConnectResponse")
	proto.RegisterType((*Channel)(nil), "protocol.Channel")
	proto.RegisterType((*HeartbeatRequest)(nil), "protocol.HeartbeatRequest")
	proto.RegisterType((*HeartbeatResponse)(nil), "protocol.HeartbeatResponse")
	proto.RegisterType((*ShutdownRequest)(nil), "protocol.ShutdownRequest")
	proto.RegisterType((*ShutdownResponse)(nil), "protocol.ShutdownResponse")
	proto.RegisterType((*LockChannelRequest)(nil), "protocol.LockChannelRequest")
	proto.RegisterType((*LockChannelResponse)(nil), "protocol.LockChannelResponse")
	proto.RegisterType((*UnlockChannelRequest)(nil), "protocol.UnlockChannelRequest")
	proto.RegisterType((*UnlockChannelResponse)(nil), "protocol.UnlockChannelResponse")
	proto.RegisterType((*GetCheckpointRequest)(nil), "protocol.GetCheckpointRequest")
	proto.RegisterType((*GetCheckpointResponse)(nil), "protocol.GetCheckpointResponse")
	proto.RegisterType((*CheckpointRequest)(nil), "protocol.CheckpointRequest")
	proto.RegisterType((*CheckpointResponse)(nil), "protocol.CheckpointResponse")
	proto.RegisterType((*ReadRecordsRequest)(nil), "protocol.ReadRecordsRequest")
	proto.RegisterType((*Record)(nil), "protocol.Record")
	proto.RegisterType((*ReadRecordsResponse)(nil), "protocol.ReadRecordsResponse")
	proto.RegisterType((*Token)(nil), "protocol.Token")
	proto.RegisterType((*TokenContent)(nil), "protocol.TokenContent")
	proto.RegisterType((*TokenContentV2)(nil), "protocol.TokenContentV2")
	proto.RegisterType((*StreamTunnelConfig)(nil), "protocol.StreamTunnelConfig")
	proto.RegisterType((*ScheduleRequest)(nil), "protocol.ScheduleRequest")
	proto.RegisterType((*ScheduleResponse)(nil), "protocol.ScheduleResponse")
}

func init() { proto.RegisterFile("tunnelservice.proto", fileDescriptor_add33052b81b4cd7) }

var fileDescriptor_add33052b81b4cd7 = []byte{
	// 1243 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0xdd, 0x6e, 0xdb, 0x46,
	0x13, 0xfd, 0x28, 0xea, 0xcf, 0x23, 0x59, 0xa2, 0x57, 0xb2, 0xc3, 0x0f, 0xc8, 0x85, 0xca, 0xa6,
	0xb0, 0x92, 0xa2, 0x01, 0xea, 0x5e, 0xa4, 0x69, 0xaf, 0x54, 0x49, 0x4d, 0x0c, 0xb8, 0xb1, 0x2b,
	0x29, 0x2d, 0x50, 0x20, 0x20, 0xd6, 0xd4, 0xd8, 0x26, 0x4c, 0xed, 0xb2, 0xdc, 0x55, 0x1a, 0xb7,
	0x2f, 0xd0, 0xab, 0x3e, 0x52, 0x9f, 0xad, 0xd8, 0x1f, 0x5a, 0x94, 0x6c, 0x07, 0x49, 0x93, 0x5e,
	0x11, 0x3b, 0xdc, 0x99, 0x33, 0x7b, 0xce, 0xd9, 0x1f, 0xe8, 0xc8, 0x25, 0x63, 0x98, 0x08, 0xcc,
	0x5e, 0xc7, 0x11, 0x3e, 0x4e, 0x33, 0x2e, 0x39, 0xa9, 0xeb, 0x4f, 0xc4, 0x93, 0xe0, 0x29, 0x54,
	0xc6, 0x59, 0xc6, 0x33, 0xd2, 0x84, 0x72, 0xc4, 0xe7, 0xe8, 0x3b, 0xbd, 0x52, 0x7f, 0x8b, 0xb4,
	0xa1, 0xb6, 0x40, 0x21, 0xe8, 0x39, 0xfa, 0xa5, 0x9e, 0xd3, 0xdf, 0x22, 0x3b, 0xb0, 0x65, 0x0a,
	0x85, 0xf1, 0xdc, 0x77, 0x55, 0x28, 0xf8, 0xdb, 0x81, 0xea, 0x4c, 0xc7, 0x08, 0x01, 0x90, 0xf4,
	0x34, 0xc1, 0x90, 0xd1, 0x45, 0x5e, 0xa2, 0x03, 0x0d, 0x9b, 0xa1, 0x83, 0xae, 0x0e, 0x3e, 0xbc,
	0x0e, 0xca, 0xab, 0x14, 0xfd, 0x72, 0xaf, 0xd4, 0x6f, 0x1d, 0x74, 0x1f, 0xe7, 0xed, 0x3c, 0x36,
	0xf5, 0x66, 0x57, 0x29, 0x92, 0x6f, 0xa0, 0x2b, 0x64, 0x86, 0x74, 0x11, 0xda, 0x8c, 0x88, 0xb3,
	0xb3, 0xf8, 0xdc, 0xaf, 0xf4, 0x9c, 0x7e, 0xe3, 0xe0, 0xfe, 0x2a, 0x67, 0xaa, 0x67, 0x99, 0xcc,
	0xa1, 0x9e, 0x43, 0x1e, 0xc0, 0x7d, 0x86, 0x38, 0x0f, 0x69, 0x92, 0x84, 0x32, 0x5e, 0x60, 0x28,
	0x30, 0x8b, 0x51, 0x84, 0x11, 0x4f, 0x96, 0x0b, 0x26, 0xfc, 0x6a, 0xcf, 0xe9, 0xd7, 0x83, 0x27,
	0xd0, 0x19, 0x66, 0x48, 0x25, 0x9a, 0xdc, 0x09, 0xfe, 0xba, 0x44, 0x21, 0x49, 0x0f, 0xaa, 0x06,
	0x51, 0x2f, 0xa4, 0x71, 0xe0, 0x6d, 0xb6, 0x17, 0x3c, 0x84, 0xee, 0x7a, 0xa2, 0x48, 0x39, 0x13,
	0xb8, 0x4e, 0x92, 0x66, 0x21, 0xf8, 0x11, 0x3a, 0x23, 0x4c, 0x70, 0x13, 0xe3, 0x1d, 0x08, 0x2b,
	0xe9, 0xe0, 0x2d, 0xbc, 0xef, 0x41, 0x77, 0xbd, 0xa4, 0x41, 0x0f, 0xf6, 0x61, 0xe7, 0x28, 0x16,
	0xf2, 0xed, 0x40, 0xaa, 0xc0, 0x9f, 0x25, 0x00, 0x33, 0xeb, 0x90, 0x9d, 0xf1, 0x5b, 0xba, 0x2e,
	0xb4, 0xa2, 0x65, 0x32, 0xad, 0xac, 0x97, 0x32, 0x7a, 0xee, 0xc2, 0x76, 0xcc, 0x84, 0xa4, 0x2c,
	0xb2, 0xe1, 0x72, 0xde, 0xb5, 0xd5, 0x2e, 0x9e, 0xfb, 0x15, 0x1d, 0xda, 0x86, 0x8a, 0x90, 0xca,
	0x4f, 0xd5, 0xdc, 0x60, 0xf8, 0x26, 0x8d, 0x33, 0x9c, 0xfb, 0x35, 0x25, 0xc6, 0xe6, 0xea, 0xeb,
	0xda, 0x75, 0x2d, 0xa8, 0xa6, 0xcb, 0xd3, 0x24, 0x8e, 0xfc, 0x2d, 0x3d, 0xe9, 0x2e, 0x4f, 0xc0,
	0x3b, 0x78, 0xa2, 0x03, 0x8d, 0x48, 0x8b, 0xa6, 0x1d, 0xe1, 0x37, 0x7a, 0x4e, 0xdf, 0x0d, 0xbe,
	0x05, 0x52, 0xe4, 0xcc, 0xea, 0xf8, 0x19, 0xd4, 0xec, 0xae, 0xf1, 0x9d, 0x9e, 0xdb, 0x6f, 0xdc,
	0x74, 0xa8, 0x22, 0x2e, 0x98, 0xc2, 0xee, 0x08, 0x45, 0x94, 0xc5, 0xa7, 0x1f, 0x51, 0xdd, 0xbf,
	0x1c, 0x68, 0x0c, 0x2f, 0xe8, 0xb5, 0x3a, 0x04, 0x20, 0x32, 0xc3, 0x95, 0x3c, 0x5d, 0x68, 0xe6,
	0x31, 0xab, 0x8f, 0x22, 0x6b, 0x0f, 0x5a, 0x79, 0x54, 0x48, 0x2a, 0x97, 0xc2, 0x54, 0x54, 0x20,
	0x51, 0x12, 0x23, 0x93, 0xaa, 0x40, 0x59, 0x87, 0x14, 0x17, 0x76, 0x6a, 0x96, 0x72, 0xbd, 0xa5,
	0x5c, 0xa5, 0x65, 0x1e, 0x8c, 0xf8, 0x92, 0x49, 0xbd, 0x4b, 0xdc, 0xe0, 0x0f, 0xd8, 0xdb, 0x5c,
	0xa5, 0xa5, 0xe9, 0xc1, 0xc6, 0x46, 0xb9, 0x95, 0x25, 0xb2, 0x0f, 0x75, 0x5b, 0x56, 0xf8, 0x25,
	0xcd, 0xe6, 0xee, 0x6a, 0xde, 0xc6, 0x4a, 0x2d, 0x19, 0xaa, 0x27, 0x57, 0x83, 0x7f, 0x09, 0xdb,
	0xcf, 0x50, 0x4e, 0x52, 0x9e, 0x53, 0xbb, 0x61, 0x56, 0xc7, 0x38, 0x2b, 0x89, 0x17, 0xb1, 0xd4,
	0x34, 0x54, 0x82, 0x13, 0x68, 0xe5, 0x29, 0xab, 0x6d, 0x99, 0xa5, 0x3c, 0x8c, 0xd9, 0x19, 0x17,
	0x3a, 0xa7, 0x49, 0x7c, 0xf0, 0x56, 0x58, 0xf6, 0x4f, 0x49, 0xff, 0xb9, 0x45, 0x92, 0xaf, 0xa0,
	0x39, 0xd4, 0x04, 0x5a, 0x27, 0xb5, 0xa1, 0xa6, 0x2c, 0xc4, 0x97, 0x52, 0x57, 0x73, 0xb5, 0x46,
	0x86, 0x61, 0x49, 0xcf, 0x8d, 0x1a, 0xc1, 0x04, 0x5a, 0x43, 0xce, 0x18, 0x46, 0xf2, 0x8e, 0xd6,
	0x95, 0x90, 0x5f, 0xc0, 0xb6, 0x4d, 0xb4, 0x46, 0x2e, 0x69, 0x23, 0xef, 0x15, 0x08, 0x2a, 0x00,
	0x07, 0x0f, 0xa0, 0x7d, 0x5d, 0x73, 0xb5, 0xb6, 0x95, 0xb8, 0xe6, 0xc8, 0x39, 0x87, 0x9a, 0xa5,
	0xf5, 0x56, 0xf3, 0xb4, 0xa1, 0xf6, 0x1a, 0x33, 0x11, 0x73, 0xa6, 0x4d, 0xe8, 0x92, 0x7d, 0xa8,
	0x5e, 0xfb, 0x45, 0x1d, 0xc7, 0xf7, 0x6e, 0xc8, 0x33, 0xd5, 0xbf, 0xd5, 0x6e, 0x9c, 0xa3, 0xa4,
	0x71, 0xa2, 0x5d, 0xd4, 0x0c, 0x5e, 0x81, 0xf7, 0x1c, 0x69, 0x26, 0x4f, 0x91, 0xbe, 0x6d, 0x91,
	0x6b, 0x2d, 0x1a, 0xdf, 0x7f, 0x5a, 0xf0, 0x84, 0xab, 0x3d, 0xb1, 0x73, 0x03, 0x34, 0xf8, 0x1a,
	0x76, 0x0a, 0xe5, 0xed, 0x7a, 0x8b, 0x99, 0xce, 0x5d, 0x99, 0x4f, 0xa0, 0x3d, 0xbd, 0x58, 0xca,
	0x39, 0xff, 0x8d, 0xbd, 0x57, 0x5f, 0x01, 0x01, 0x6f, 0x95, 0x68, 0x8f, 0xd5, 0x14, 0xc8, 0x11,
	0x8f, 0x2e, 0x6d, 0xed, 0xf7, 0x5b, 0xe7, 0x3a, 0xff, 0x6e, 0xce, 0x7f, 0xc2, 0xa3, 0x4b, 0xb3,
	0x19, 0x6d, 0x20, 0xb7, 0x93, 0x3a, 0x2a, 0xdd, 0x60, 0x17, 0x3a, 0x6b, 0x88, 0xb6, 0x11, 0x0a,
	0xdd, 0x97, 0x2c, 0xf9, 0x2f, 0x5b, 0x09, 0xee, 0xc1, 0xee, 0x06, 0x84, 0xc5, 0x3e, 0x81, 0xee,
	0x33, 0x94, 0xc3, 0x0b, 0x8c, 0x2e, 0x53, 0x1e, 0x33, 0xf9, 0xc1, 0xd8, 0xc1, 0x08, 0x76, 0x37,
	0x2a, 0x5a, 0x85, 0xf5, 0xe4, 0x3c, 0x6a, 0x6b, 0xde, 0x83, 0xb6, 0x50, 0x88, 0xfa, 0x9a, 0x59,
	0x2e, 0x4e, 0x31, 0x33, 0xde, 0x0d, 0x7e, 0x87, 0x9d, 0x8f, 0xd8, 0xd4, 0x06, 0x76, 0xf9, 0x2e,
	0x6c, 0x23, 0x53, 0x17, 0xc8, 0xcd, 0xf6, 0x83, 0x57, 0x40, 0x26, 0x48, 0xe7, 0x13, 0x8c, 0x78,
	0x36, 0x17, 0x1f, 0xde, 0xd2, 0x36, 0x54, 0x24, 0xbf, 0x44, 0x66, 0x15, 0xfa, 0x05, 0xaa, 0xa6,
	0xb4, 0x7a, 0x4a, 0xd1, 0x48, 0xc6, 0x9c, 0x99, 0x3b, 0xc0, 0xd9, 0x7c, 0x4a, 0x0d, 0xf4, 0x4f,
	0xfd, 0x94, 0x6a, 0x41, 0x35, 0xd3, 0x49, 0x1a, 0xa7, 0xa9, 0x4e, 0x7a, 0x9e, 0xc5, 0xe7, 0x31,
	0x0b, 0x6d, 0xd8, 0xd5, 0xfb, 0x19, 0xa1, 0xb3, 0xd6, 0xba, 0x15, 0xe4, 0x13, 0xa8, 0x99, 0x69,
	0xf9, 0x8e, 0x2b, 0x3c, 0x88, 0x6c, 0x2f, 0x04, 0x80, 0xe1, 0x1b, 0x19, 0x9a, 0x4e, 0x4b, 0x39,
	0x6f, 0x0b, 0x7a, 0x15, 0x2e, 0x78, 0x86, 0x45, 0x98, 0x7a, 0xf0, 0x10, 0x2a, 0x33, 0x35, 0xaf,
	0x78, 0x12, 0x39, 0xfa, 0x24, 0x6a, 0x43, 0x2d, 0xe2, 0x4c, 0x22, 0x93, 0xa6, 0xd1, 0xe0, 0x39,
	0x34, 0xf5, 0xd4, 0xa1, 0x89, 0xaa, 0x7b, 0x2b, 0xcd, 0xe2, 0x05, 0xcd, 0xae, 0xc2, 0x4b, 0xbc,
	0xb2, 0x67, 0xb9, 0x07, 0xf5, 0x58, 0x62, 0x46, 0x25, 0xcf, 0x0a, 0x8f, 0xd5, 0x78, 0x81, 0x42,
	0xd2, 0x45, 0x6a, 0x2f, 0x92, 0x10, 0x5a, 0xc5, 0x4a, 0x3f, 0x1d, 0xfc, 0xfb, 0x5a, 0xfa, 0x2a,
	0xe7, 0x92, 0xe6, 0xd7, 0x64, 0x59, 0x03, 0x20, 0x90, 0x5b, 0x1e, 0x1d, 0xfb, 0x50, 0x3e, 0x4b,
	0xe8, 0xb9, 0xae, 0xde, 0x3a, 0xf8, 0x7f, 0xf1, 0x81, 0x42, 0x33, 0x79, 0x7c, 0x76, 0x26, 0x50,
	0x7e, 0x9f, 0x50, 0xfd, 0x3a, 0x11, 0xab, 0x90, 0xc6, 0x2e, 0x2b, 0x6c, 0x64, 0x73, 0x1b, 0x52,
	0xd8, 0xe5, 0xe0, 0x10, 0xda, 0xd3, 0xe8, 0x02, 0xe7, 0xcb, 0x04, 0xdf, 0xe2, 0xad, 0x77, 0x3a,
	0x5f, 0xd5, 0x61, 0x77, 0x5d, 0xca, 0x68, 0xfd, 0xe8, 0x69, 0xfe, 0x32, 0xd4, 0xbe, 0x69, 0x42,
	0xfd, 0x3b, 0x2a, 0x70, 0x44, 0x25, 0xf5, 0x1c, 0x02, 0x50, 0x35, 0x2b, 0xf4, 0x4a, 0x64, 0x07,
	0xb6, 0xd5, 0x9f, 0x01, 0x9b, 0xdb, 0x90, 0xfb, 0x68, 0x00, 0xdb, 0xeb, 0xd7, 0x45, 0x1d, 0xca,
	0xc7, 0x27, 0xe3, 0x17, 0x9e, 0x43, 0x1a, 0x50, 0x1b, 0x1e, 0x1d, 0x4f, 0x0f, 0x5f, 0x3c, 0xf3,
	0x4a, 0x64, 0x0b, 0x2a, 0x6a, 0x30, 0xf6, 0x5c, 0xd2, 0x02, 0x98, 0x8d, 0x27, 0x3f, 0x1c, 0xbe,
	0x18, 0xcc, 0xc6, 0x23, 0xaf, 0xac, 0xd0, 0x0b, 0xae, 0x6d, 0x40, 0xed, 0xe4, 0xe5, 0x2c, 0x9c,
	0x1c, 0xff, 0xec, 0x39, 0x6a, 0xea, 0xcb, 0x93, 0xd1, 0x60, 0x36, 0xd6, 0xe3, 0x92, 0x1a, 0x8f,
	0xc6, 0x47, 0x63, 0x3b, 0x76, 0x1f, 0x7d, 0x0e, 0xed, 0x4d, 0x4a, 0x01, 0xaa, 0x47, 0x83, 0xd9,
	0x78, 0x3a, 0xf3, 0xfe, 0xa7, 0x56, 0x32, 0x1e, 0x4c, 0x8e, 0x0e, 0xd5, 0xc8, 0xf9, 0x27, 0x00,
	0x00, 0xff, 0xff, 0xf2, 0x4e, 0x53, 0x2e, 0x14, 0x0d, 0x00, 0x00,
}
