// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: plugin.proto

package pb

import (
	context "context"
	fmt "fmt"
	proto "github.com/gogo/protobuf/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	io "io"
	math "math"
	math_bits "math/bits"
)

// 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.GoGoProtoPackageIsVersion3 // please upgrade the proto package

type Empty struct {
}

func (m *Empty) Reset()         { *m = Empty{} }
func (m *Empty) String() string { return proto.CompactTextString(m) }
func (*Empty) ProtoMessage()    {}
func (*Empty) Descriptor() ([]byte, []int) {
	return fileDescriptor_22a625af4bc1cc87, []int{0}
}
func (m *Empty) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Empty) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Empty.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Empty) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Empty.Merge(m, src)
}
func (m *Empty) XXX_Size() int {
	return m.Size()
}
func (m *Empty) XXX_DiscardUnknown() {
	xxx_messageInfo_Empty.DiscardUnknown(m)
}

var xxx_messageInfo_Empty proto.InternalMessageInfo

type InitializeRequest struct {
	ConfigPath string `protobuf:"bytes,1,opt,name=config_path,json=configPath,proto3" json:"config_path,omitempty"`
	SidecarId  string `protobuf:"bytes,2,opt,name=sidecar_id,json=sidecarId,proto3" json:"sidecar_id,omitempty"`
	Extra      []byte `protobuf:"bytes,3,opt,name=extra,proto3" json:"extra,omitempty"`
}

func (m *InitializeRequest) Reset()         { *m = InitializeRequest{} }
func (m *InitializeRequest) String() string { return proto.CompactTextString(m) }
func (*InitializeRequest) ProtoMessage()    {}
func (*InitializeRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_22a625af4bc1cc87, []int{1}
}
func (m *InitializeRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *InitializeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_InitializeRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *InitializeRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_InitializeRequest.Merge(m, src)
}
func (m *InitializeRequest) XXX_Size() int {
	return m.Size()
}
func (m *InitializeRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_InitializeRequest.DiscardUnknown(m)
}

var xxx_messageInfo_InitializeRequest proto.InternalMessageInfo

func (m *InitializeRequest) GetConfigPath() string {
	if m != nil {
		return m.ConfigPath
	}
	return ""
}

func (m *InitializeRequest) GetSidecarId() string {
	if m != nil {
		return m.SidecarId
	}
	return ""
}

func (m *InitializeRequest) GetExtra() []byte {
	if m != nil {
		return m.Extra
	}
	return nil
}

type SubmitIBTPResponse struct {
	Status  bool   `protobuf:"varint,1,opt,name=status,proto3" json:"status,omitempty"`
	Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	Result  *IBTP  `protobuf:"bytes,3,opt,name=result,proto3" json:"result,omitempty"`
}

func (m *SubmitIBTPResponse) Reset()         { *m = SubmitIBTPResponse{} }
func (m *SubmitIBTPResponse) String() string { return proto.CompactTextString(m) }
func (*SubmitIBTPResponse) ProtoMessage()    {}
func (*SubmitIBTPResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_22a625af4bc1cc87, []int{2}
}
func (m *SubmitIBTPResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SubmitIBTPResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SubmitIBTPResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *SubmitIBTPResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SubmitIBTPResponse.Merge(m, src)
}
func (m *SubmitIBTPResponse) XXX_Size() int {
	return m.Size()
}
func (m *SubmitIBTPResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_SubmitIBTPResponse.DiscardUnknown(m)
}

var xxx_messageInfo_SubmitIBTPResponse proto.InternalMessageInfo

func (m *SubmitIBTPResponse) GetStatus() bool {
	if m != nil {
		return m.Status
	}
	return false
}

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

func (m *SubmitIBTPResponse) GetResult() *IBTP {
	if m != nil {
		return m.Result
	}
	return nil
}

type RollbackIBTPRequest struct {
	Ibtp     *IBTP `protobuf:"bytes,1,opt,name=ibtp,proto3" json:"ibtp,omitempty"`
	SrcChain bool  `protobuf:"varint,2,opt,name=srcChain,proto3" json:"srcChain,omitempty"`
}

func (m *RollbackIBTPRequest) Reset()         { *m = RollbackIBTPRequest{} }
func (m *RollbackIBTPRequest) String() string { return proto.CompactTextString(m) }
func (*RollbackIBTPRequest) ProtoMessage()    {}
func (*RollbackIBTPRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_22a625af4bc1cc87, []int{3}
}
func (m *RollbackIBTPRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RollbackIBTPRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RollbackIBTPRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RollbackIBTPRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RollbackIBTPRequest.Merge(m, src)
}
func (m *RollbackIBTPRequest) XXX_Size() int {
	return m.Size()
}
func (m *RollbackIBTPRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RollbackIBTPRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RollbackIBTPRequest proto.InternalMessageInfo

func (m *RollbackIBTPRequest) GetIbtp() *IBTP {
	if m != nil {
		return m.Ibtp
	}
	return nil
}

func (m *RollbackIBTPRequest) GetSrcChain() bool {
	if m != nil {
		return m.SrcChain
	}
	return false
}

type RollbackIBTPResponse struct {
	Status  bool   `protobuf:"varint,1,opt,name=status,proto3" json:"status,omitempty"`
	Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
}

func (m *RollbackIBTPResponse) Reset()         { *m = RollbackIBTPResponse{} }
func (m *RollbackIBTPResponse) String() string { return proto.CompactTextString(m) }
func (*RollbackIBTPResponse) ProtoMessage()    {}
func (*RollbackIBTPResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_22a625af4bc1cc87, []int{4}
}
func (m *RollbackIBTPResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RollbackIBTPResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RollbackIBTPResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RollbackIBTPResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RollbackIBTPResponse.Merge(m, src)
}
func (m *RollbackIBTPResponse) XXX_Size() int {
	return m.Size()
}
func (m *RollbackIBTPResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RollbackIBTPResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RollbackIBTPResponse proto.InternalMessageInfo

func (m *RollbackIBTPResponse) GetStatus() bool {
	if m != nil {
		return m.Status
	}
	return false
}

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

type GetOutMessageRequest struct {
	To  string `protobuf:"bytes,1,opt,name=to,proto3" json:"to,omitempty"`
	Idx uint64 `protobuf:"varint,2,opt,name=idx,proto3" json:"idx,omitempty"`
}

func (m *GetOutMessageRequest) Reset()         { *m = GetOutMessageRequest{} }
func (m *GetOutMessageRequest) String() string { return proto.CompactTextString(m) }
func (*GetOutMessageRequest) ProtoMessage()    {}
func (*GetOutMessageRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_22a625af4bc1cc87, []int{5}
}
func (m *GetOutMessageRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetOutMessageRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetOutMessageRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetOutMessageRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetOutMessageRequest.Merge(m, src)
}
func (m *GetOutMessageRequest) XXX_Size() int {
	return m.Size()
}
func (m *GetOutMessageRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetOutMessageRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetOutMessageRequest proto.InternalMessageInfo

func (m *GetOutMessageRequest) GetTo() string {
	if m != nil {
		return m.To
	}
	return ""
}

func (m *GetOutMessageRequest) GetIdx() uint64 {
	if m != nil {
		return m.Idx
	}
	return 0
}

type GetInMessageRequest struct {
	From string `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty"`
	Idx  uint64 `protobuf:"varint,2,opt,name=idx,proto3" json:"idx,omitempty"`
}

func (m *GetInMessageRequest) Reset()         { *m = GetInMessageRequest{} }
func (m *GetInMessageRequest) String() string { return proto.CompactTextString(m) }
func (*GetInMessageRequest) ProtoMessage()    {}
func (*GetInMessageRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_22a625af4bc1cc87, []int{6}
}
func (m *GetInMessageRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetInMessageRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetInMessageRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetInMessageRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetInMessageRequest.Merge(m, src)
}
func (m *GetInMessageRequest) XXX_Size() int {
	return m.Size()
}
func (m *GetInMessageRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetInMessageRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetInMessageRequest proto.InternalMessageInfo

func (m *GetInMessageRequest) GetFrom() string {
	if m != nil {
		return m.From
	}
	return ""
}

func (m *GetInMessageRequest) GetIdx() uint64 {
	if m != nil {
		return m.Idx
	}
	return 0
}

type GetInMessageResponse struct {
	Result [][]byte `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"`
}

func (m *GetInMessageResponse) Reset()         { *m = GetInMessageResponse{} }
func (m *GetInMessageResponse) String() string { return proto.CompactTextString(m) }
func (*GetInMessageResponse) ProtoMessage()    {}
func (*GetInMessageResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_22a625af4bc1cc87, []int{7}
}
func (m *GetInMessageResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetInMessageResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetInMessageResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetInMessageResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetInMessageResponse.Merge(m, src)
}
func (m *GetInMessageResponse) XXX_Size() int {
	return m.Size()
}
func (m *GetInMessageResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GetInMessageResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GetInMessageResponse proto.InternalMessageInfo

func (m *GetInMessageResponse) GetResult() [][]byte {
	if m != nil {
		return m.Result
	}
	return nil
}

type GetMetaResponse struct {
	Meta map[string]uint64 `protobuf:"bytes,1,rep,name=meta,proto3" json:"meta,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
}

func (m *GetMetaResponse) Reset()         { *m = GetMetaResponse{} }
func (m *GetMetaResponse) String() string { return proto.CompactTextString(m) }
func (*GetMetaResponse) ProtoMessage()    {}
func (*GetMetaResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_22a625af4bc1cc87, []int{8}
}
func (m *GetMetaResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetMetaResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetMetaResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetMetaResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetMetaResponse.Merge(m, src)
}
func (m *GetMetaResponse) XXX_Size() int {
	return m.Size()
}
func (m *GetMetaResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GetMetaResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GetMetaResponse proto.InternalMessageInfo

func (m *GetMetaResponse) GetMeta() map[string]uint64 {
	if m != nil {
		return m.Meta
	}
	return nil
}

type NameResponse struct {
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
}

func (m *NameResponse) Reset()         { *m = NameResponse{} }
func (m *NameResponse) String() string { return proto.CompactTextString(m) }
func (*NameResponse) ProtoMessage()    {}
func (*NameResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_22a625af4bc1cc87, []int{9}
}
func (m *NameResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *NameResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_NameResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *NameResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NameResponse.Merge(m, src)
}
func (m *NameResponse) XXX_Size() int {
	return m.Size()
}
func (m *NameResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_NameResponse.DiscardUnknown(m)
}

var xxx_messageInfo_NameResponse proto.InternalMessageInfo

func (m *NameResponse) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

type TypeResponse struct {
	Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
}

func (m *TypeResponse) Reset()         { *m = TypeResponse{} }
func (m *TypeResponse) String() string { return proto.CompactTextString(m) }
func (*TypeResponse) ProtoMessage()    {}
func (*TypeResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_22a625af4bc1cc87, []int{10}
}
func (m *TypeResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TypeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TypeResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TypeResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TypeResponse.Merge(m, src)
}
func (m *TypeResponse) XXX_Size() int {
	return m.Size()
}
func (m *TypeResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_TypeResponse.DiscardUnknown(m)
}

var xxx_messageInfo_TypeResponse proto.InternalMessageInfo

func (m *TypeResponse) GetType() string {
	if m != nil {
		return m.Type
	}
	return ""
}

func init() {
	proto.RegisterType((*Empty)(nil), "pb.Empty")
	proto.RegisterType((*InitializeRequest)(nil), "pb.InitializeRequest")
	proto.RegisterType((*SubmitIBTPResponse)(nil), "pb.SubmitIBTPResponse")
	proto.RegisterType((*RollbackIBTPRequest)(nil), "pb.RollbackIBTPRequest")
	proto.RegisterType((*RollbackIBTPResponse)(nil), "pb.RollbackIBTPResponse")
	proto.RegisterType((*GetOutMessageRequest)(nil), "pb.GetOutMessageRequest")
	proto.RegisterType((*GetInMessageRequest)(nil), "pb.GetInMessageRequest")
	proto.RegisterType((*GetInMessageResponse)(nil), "pb.GetInMessageResponse")
	proto.RegisterType((*GetMetaResponse)(nil), "pb.GetMetaResponse")
	proto.RegisterMapType((map[string]uint64)(nil), "pb.GetMetaResponse.MetaEntry")
	proto.RegisterType((*NameResponse)(nil), "pb.NameResponse")
	proto.RegisterType((*TypeResponse)(nil), "pb.TypeResponse")
}

func init() { proto.RegisterFile("plugin.proto", fileDescriptor_22a625af4bc1cc87) }

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

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// AppchainPluginClient is the client API for AppchainPlugin service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type AppchainPluginClient interface {
	Initialize(ctx context.Context, in *InitializeRequest, opts ...grpc.CallOption) (*Empty, error)
	Start(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Empty, error)
	Stop(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Empty, error)
	GetIBTP(ctx context.Context, in *Empty, opts ...grpc.CallOption) (AppchainPlugin_GetIBTPClient, error)
	SubmitIBTP(ctx context.Context, in *IBTP, opts ...grpc.CallOption) (*SubmitIBTPResponse, error)
	RollbackIBTP(ctx context.Context, in *RollbackIBTPRequest, opts ...grpc.CallOption) (*RollbackIBTPResponse, error)
	IncreaseInMeta(ctx context.Context, in *IBTP, opts ...grpc.CallOption) (*IBTP, error)
	GetOutMessage(ctx context.Context, in *GetOutMessageRequest, opts ...grpc.CallOption) (*IBTP, error)
	GetInMessage(ctx context.Context, in *GetInMessageRequest, opts ...grpc.CallOption) (*GetInMessageResponse, error)
	GetInMeta(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*GetMetaResponse, error)
	GetOutMeta(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*GetMetaResponse, error)
	GetCallbackMeta(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*GetMetaResponse, error)
	CommitCallback(ctx context.Context, in *IBTP, opts ...grpc.CallOption) (*Empty, error)
	GetReceipt(ctx context.Context, in *IBTP, opts ...grpc.CallOption) (*IBTP, error)
	Name(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*NameResponse, error)
	Type(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*TypeResponse, error)
}

type appchainPluginClient struct {
	cc *grpc.ClientConn
}

func NewAppchainPluginClient(cc *grpc.ClientConn) AppchainPluginClient {
	return &appchainPluginClient{cc}
}

func (c *appchainPluginClient) Initialize(ctx context.Context, in *InitializeRequest, opts ...grpc.CallOption) (*Empty, error) {
	out := new(Empty)
	err := c.cc.Invoke(ctx, "/pb.AppchainPlugin/Initialize", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *appchainPluginClient) Start(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Empty, error) {
	out := new(Empty)
	err := c.cc.Invoke(ctx, "/pb.AppchainPlugin/Start", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *appchainPluginClient) Stop(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Empty, error) {
	out := new(Empty)
	err := c.cc.Invoke(ctx, "/pb.AppchainPlugin/Stop", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *appchainPluginClient) GetIBTP(ctx context.Context, in *Empty, opts ...grpc.CallOption) (AppchainPlugin_GetIBTPClient, error) {
	stream, err := c.cc.NewStream(ctx, &_AppchainPlugin_serviceDesc.Streams[0], "/pb.AppchainPlugin/GetIBTP", opts...)
	if err != nil {
		return nil, err
	}
	x := &appchainPluginGetIBTPClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type AppchainPlugin_GetIBTPClient interface {
	Recv() (*IBTP, error)
	grpc.ClientStream
}

type appchainPluginGetIBTPClient struct {
	grpc.ClientStream
}

func (x *appchainPluginGetIBTPClient) Recv() (*IBTP, error) {
	m := new(IBTP)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *appchainPluginClient) SubmitIBTP(ctx context.Context, in *IBTP, opts ...grpc.CallOption) (*SubmitIBTPResponse, error) {
	out := new(SubmitIBTPResponse)
	err := c.cc.Invoke(ctx, "/pb.AppchainPlugin/SubmitIBTP", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *appchainPluginClient) RollbackIBTP(ctx context.Context, in *RollbackIBTPRequest, opts ...grpc.CallOption) (*RollbackIBTPResponse, error) {
	out := new(RollbackIBTPResponse)
	err := c.cc.Invoke(ctx, "/pb.AppchainPlugin/RollbackIBTP", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *appchainPluginClient) IncreaseInMeta(ctx context.Context, in *IBTP, opts ...grpc.CallOption) (*IBTP, error) {
	out := new(IBTP)
	err := c.cc.Invoke(ctx, "/pb.AppchainPlugin/IncreaseInMeta", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *appchainPluginClient) GetOutMessage(ctx context.Context, in *GetOutMessageRequest, opts ...grpc.CallOption) (*IBTP, error) {
	out := new(IBTP)
	err := c.cc.Invoke(ctx, "/pb.AppchainPlugin/GetOutMessage", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *appchainPluginClient) GetInMessage(ctx context.Context, in *GetInMessageRequest, opts ...grpc.CallOption) (*GetInMessageResponse, error) {
	out := new(GetInMessageResponse)
	err := c.cc.Invoke(ctx, "/pb.AppchainPlugin/GetInMessage", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *appchainPluginClient) GetInMeta(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*GetMetaResponse, error) {
	out := new(GetMetaResponse)
	err := c.cc.Invoke(ctx, "/pb.AppchainPlugin/GetInMeta", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *appchainPluginClient) GetOutMeta(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*GetMetaResponse, error) {
	out := new(GetMetaResponse)
	err := c.cc.Invoke(ctx, "/pb.AppchainPlugin/GetOutMeta", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *appchainPluginClient) GetCallbackMeta(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*GetMetaResponse, error) {
	out := new(GetMetaResponse)
	err := c.cc.Invoke(ctx, "/pb.AppchainPlugin/GetCallbackMeta", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *appchainPluginClient) CommitCallback(ctx context.Context, in *IBTP, opts ...grpc.CallOption) (*Empty, error) {
	out := new(Empty)
	err := c.cc.Invoke(ctx, "/pb.AppchainPlugin/CommitCallback", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *appchainPluginClient) GetReceipt(ctx context.Context, in *IBTP, opts ...grpc.CallOption) (*IBTP, error) {
	out := new(IBTP)
	err := c.cc.Invoke(ctx, "/pb.AppchainPlugin/GetReceipt", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *appchainPluginClient) Name(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*NameResponse, error) {
	out := new(NameResponse)
	err := c.cc.Invoke(ctx, "/pb.AppchainPlugin/Name", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *appchainPluginClient) Type(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*TypeResponse, error) {
	out := new(TypeResponse)
	err := c.cc.Invoke(ctx, "/pb.AppchainPlugin/Type", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// AppchainPluginServer is the server API for AppchainPlugin service.
type AppchainPluginServer interface {
	Initialize(context.Context, *InitializeRequest) (*Empty, error)
	Start(context.Context, *Empty) (*Empty, error)
	Stop(context.Context, *Empty) (*Empty, error)
	GetIBTP(*Empty, AppchainPlugin_GetIBTPServer) error
	SubmitIBTP(context.Context, *IBTP) (*SubmitIBTPResponse, error)
	RollbackIBTP(context.Context, *RollbackIBTPRequest) (*RollbackIBTPResponse, error)
	IncreaseInMeta(context.Context, *IBTP) (*IBTP, error)
	GetOutMessage(context.Context, *GetOutMessageRequest) (*IBTP, error)
	GetInMessage(context.Context, *GetInMessageRequest) (*GetInMessageResponse, error)
	GetInMeta(context.Context, *Empty) (*GetMetaResponse, error)
	GetOutMeta(context.Context, *Empty) (*GetMetaResponse, error)
	GetCallbackMeta(context.Context, *Empty) (*GetMetaResponse, error)
	CommitCallback(context.Context, *IBTP) (*Empty, error)
	GetReceipt(context.Context, *IBTP) (*IBTP, error)
	Name(context.Context, *Empty) (*NameResponse, error)
	Type(context.Context, *Empty) (*TypeResponse, error)
}

// UnimplementedAppchainPluginServer can be embedded to have forward compatible implementations.
type UnimplementedAppchainPluginServer struct {
}

func (*UnimplementedAppchainPluginServer) Initialize(ctx context.Context, req *InitializeRequest) (*Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Initialize not implemented")
}
func (*UnimplementedAppchainPluginServer) Start(ctx context.Context, req *Empty) (*Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Start not implemented")
}
func (*UnimplementedAppchainPluginServer) Stop(ctx context.Context, req *Empty) (*Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Stop not implemented")
}
func (*UnimplementedAppchainPluginServer) GetIBTP(req *Empty, srv AppchainPlugin_GetIBTPServer) error {
	return status.Errorf(codes.Unimplemented, "method GetIBTP not implemented")
}
func (*UnimplementedAppchainPluginServer) SubmitIBTP(ctx context.Context, req *IBTP) (*SubmitIBTPResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SubmitIBTP not implemented")
}
func (*UnimplementedAppchainPluginServer) RollbackIBTP(ctx context.Context, req *RollbackIBTPRequest) (*RollbackIBTPResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RollbackIBTP not implemented")
}
func (*UnimplementedAppchainPluginServer) IncreaseInMeta(ctx context.Context, req *IBTP) (*IBTP, error) {
	return nil, status.Errorf(codes.Unimplemented, "method IncreaseInMeta not implemented")
}
func (*UnimplementedAppchainPluginServer) GetOutMessage(ctx context.Context, req *GetOutMessageRequest) (*IBTP, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetOutMessage not implemented")
}
func (*UnimplementedAppchainPluginServer) GetInMessage(ctx context.Context, req *GetInMessageRequest) (*GetInMessageResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetInMessage not implemented")
}
func (*UnimplementedAppchainPluginServer) GetInMeta(ctx context.Context, req *Empty) (*GetMetaResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetInMeta not implemented")
}
func (*UnimplementedAppchainPluginServer) GetOutMeta(ctx context.Context, req *Empty) (*GetMetaResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetOutMeta not implemented")
}
func (*UnimplementedAppchainPluginServer) GetCallbackMeta(ctx context.Context, req *Empty) (*GetMetaResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetCallbackMeta not implemented")
}
func (*UnimplementedAppchainPluginServer) CommitCallback(ctx context.Context, req *IBTP) (*Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CommitCallback not implemented")
}
func (*UnimplementedAppchainPluginServer) GetReceipt(ctx context.Context, req *IBTP) (*IBTP, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetReceipt not implemented")
}
func (*UnimplementedAppchainPluginServer) Name(ctx context.Context, req *Empty) (*NameResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Name not implemented")
}
func (*UnimplementedAppchainPluginServer) Type(ctx context.Context, req *Empty) (*TypeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Type not implemented")
}

func RegisterAppchainPluginServer(s *grpc.Server, srv AppchainPluginServer) {
	s.RegisterService(&_AppchainPlugin_serviceDesc, srv)
}

func _AppchainPlugin_Initialize_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InitializeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AppchainPluginServer).Initialize(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.AppchainPlugin/Initialize",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AppchainPluginServer).Initialize(ctx, req.(*InitializeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AppchainPlugin_Start_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AppchainPluginServer).Start(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.AppchainPlugin/Start",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AppchainPluginServer).Start(ctx, req.(*Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _AppchainPlugin_Stop_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AppchainPluginServer).Stop(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.AppchainPlugin/Stop",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AppchainPluginServer).Stop(ctx, req.(*Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _AppchainPlugin_GetIBTP_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(Empty)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AppchainPluginServer).GetIBTP(m, &appchainPluginGetIBTPServer{stream})
}

type AppchainPlugin_GetIBTPServer interface {
	Send(*IBTP) error
	grpc.ServerStream
}

type appchainPluginGetIBTPServer struct {
	grpc.ServerStream
}

func (x *appchainPluginGetIBTPServer) Send(m *IBTP) error {
	return x.ServerStream.SendMsg(m)
}

func _AppchainPlugin_SubmitIBTP_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(IBTP)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AppchainPluginServer).SubmitIBTP(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.AppchainPlugin/SubmitIBTP",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AppchainPluginServer).SubmitIBTP(ctx, req.(*IBTP))
	}
	return interceptor(ctx, in, info, handler)
}

func _AppchainPlugin_RollbackIBTP_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RollbackIBTPRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AppchainPluginServer).RollbackIBTP(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.AppchainPlugin/RollbackIBTP",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AppchainPluginServer).RollbackIBTP(ctx, req.(*RollbackIBTPRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AppchainPlugin_IncreaseInMeta_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(IBTP)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AppchainPluginServer).IncreaseInMeta(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.AppchainPlugin/IncreaseInMeta",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AppchainPluginServer).IncreaseInMeta(ctx, req.(*IBTP))
	}
	return interceptor(ctx, in, info, handler)
}

func _AppchainPlugin_GetOutMessage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetOutMessageRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AppchainPluginServer).GetOutMessage(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.AppchainPlugin/GetOutMessage",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AppchainPluginServer).GetOutMessage(ctx, req.(*GetOutMessageRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AppchainPlugin_GetInMessage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetInMessageRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AppchainPluginServer).GetInMessage(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.AppchainPlugin/GetInMessage",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AppchainPluginServer).GetInMessage(ctx, req.(*GetInMessageRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AppchainPlugin_GetInMeta_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AppchainPluginServer).GetInMeta(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.AppchainPlugin/GetInMeta",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AppchainPluginServer).GetInMeta(ctx, req.(*Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _AppchainPlugin_GetOutMeta_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AppchainPluginServer).GetOutMeta(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.AppchainPlugin/GetOutMeta",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AppchainPluginServer).GetOutMeta(ctx, req.(*Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _AppchainPlugin_GetCallbackMeta_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AppchainPluginServer).GetCallbackMeta(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.AppchainPlugin/GetCallbackMeta",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AppchainPluginServer).GetCallbackMeta(ctx, req.(*Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _AppchainPlugin_CommitCallback_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(IBTP)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AppchainPluginServer).CommitCallback(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.AppchainPlugin/CommitCallback",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AppchainPluginServer).CommitCallback(ctx, req.(*IBTP))
	}
	return interceptor(ctx, in, info, handler)
}

func _AppchainPlugin_GetReceipt_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(IBTP)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AppchainPluginServer).GetReceipt(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.AppchainPlugin/GetReceipt",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AppchainPluginServer).GetReceipt(ctx, req.(*IBTP))
	}
	return interceptor(ctx, in, info, handler)
}

func _AppchainPlugin_Name_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AppchainPluginServer).Name(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.AppchainPlugin/Name",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AppchainPluginServer).Name(ctx, req.(*Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _AppchainPlugin_Type_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AppchainPluginServer).Type(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.AppchainPlugin/Type",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AppchainPluginServer).Type(ctx, req.(*Empty))
	}
	return interceptor(ctx, in, info, handler)
}

var _AppchainPlugin_serviceDesc = grpc.ServiceDesc{
	ServiceName: "pb.AppchainPlugin",
	HandlerType: (*AppchainPluginServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Initialize",
			Handler:    _AppchainPlugin_Initialize_Handler,
		},
		{
			MethodName: "Start",
			Handler:    _AppchainPlugin_Start_Handler,
		},
		{
			MethodName: "Stop",
			Handler:    _AppchainPlugin_Stop_Handler,
		},
		{
			MethodName: "SubmitIBTP",
			Handler:    _AppchainPlugin_SubmitIBTP_Handler,
		},
		{
			MethodName: "RollbackIBTP",
			Handler:    _AppchainPlugin_RollbackIBTP_Handler,
		},
		{
			MethodName: "IncreaseInMeta",
			Handler:    _AppchainPlugin_IncreaseInMeta_Handler,
		},
		{
			MethodName: "GetOutMessage",
			Handler:    _AppchainPlugin_GetOutMessage_Handler,
		},
		{
			MethodName: "GetInMessage",
			Handler:    _AppchainPlugin_GetInMessage_Handler,
		},
		{
			MethodName: "GetInMeta",
			Handler:    _AppchainPlugin_GetInMeta_Handler,
		},
		{
			MethodName: "GetOutMeta",
			Handler:    _AppchainPlugin_GetOutMeta_Handler,
		},
		{
			MethodName: "GetCallbackMeta",
			Handler:    _AppchainPlugin_GetCallbackMeta_Handler,
		},
		{
			MethodName: "CommitCallback",
			Handler:    _AppchainPlugin_CommitCallback_Handler,
		},
		{
			MethodName: "GetReceipt",
			Handler:    _AppchainPlugin_GetReceipt_Handler,
		},
		{
			MethodName: "Name",
			Handler:    _AppchainPlugin_Name_Handler,
		},
		{
			MethodName: "Type",
			Handler:    _AppchainPlugin_Type_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GetIBTP",
			Handler:       _AppchainPlugin_GetIBTP_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "plugin.proto",
}

func (m *Empty) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Empty) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Empty) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *InitializeRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *InitializeRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *InitializeRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Extra) > 0 {
		i -= len(m.Extra)
		copy(dAtA[i:], m.Extra)
		i = encodeVarintPlugin(dAtA, i, uint64(len(m.Extra)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.SidecarId) > 0 {
		i -= len(m.SidecarId)
		copy(dAtA[i:], m.SidecarId)
		i = encodeVarintPlugin(dAtA, i, uint64(len(m.SidecarId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ConfigPath) > 0 {
		i -= len(m.ConfigPath)
		copy(dAtA[i:], m.ConfigPath)
		i = encodeVarintPlugin(dAtA, i, uint64(len(m.ConfigPath)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *SubmitIBTPResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *SubmitIBTPResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SubmitIBTPResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Result != nil {
		{
			size, err := m.Result.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintPlugin(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Message) > 0 {
		i -= len(m.Message)
		copy(dAtA[i:], m.Message)
		i = encodeVarintPlugin(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0x12
	}
	if m.Status {
		i--
		if m.Status {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RollbackIBTPRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RollbackIBTPRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RollbackIBTPRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.SrcChain {
		i--
		if m.SrcChain {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if m.Ibtp != nil {
		{
			size, err := m.Ibtp.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintPlugin(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RollbackIBTPResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RollbackIBTPResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RollbackIBTPResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Message) > 0 {
		i -= len(m.Message)
		copy(dAtA[i:], m.Message)
		i = encodeVarintPlugin(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0x12
	}
	if m.Status {
		i--
		if m.Status {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *GetOutMessageRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetOutMessageRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetOutMessageRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Idx != 0 {
		i = encodeVarintPlugin(dAtA, i, uint64(m.Idx))
		i--
		dAtA[i] = 0x10
	}
	if len(m.To) > 0 {
		i -= len(m.To)
		copy(dAtA[i:], m.To)
		i = encodeVarintPlugin(dAtA, i, uint64(len(m.To)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *GetInMessageRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetInMessageRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetInMessageRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Idx != 0 {
		i = encodeVarintPlugin(dAtA, i, uint64(m.Idx))
		i--
		dAtA[i] = 0x10
	}
	if len(m.From) > 0 {
		i -= len(m.From)
		copy(dAtA[i:], m.From)
		i = encodeVarintPlugin(dAtA, i, uint64(len(m.From)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *GetInMessageResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetInMessageResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetInMessageResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Result) > 0 {
		for iNdEx := len(m.Result) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Result[iNdEx])
			copy(dAtA[i:], m.Result[iNdEx])
			i = encodeVarintPlugin(dAtA, i, uint64(len(m.Result[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *GetMetaResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetMetaResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetMetaResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Meta) > 0 {
		for k := range m.Meta {
			v := m.Meta[k]
			baseI := i
			i = encodeVarintPlugin(dAtA, i, uint64(v))
			i--
			dAtA[i] = 0x10
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintPlugin(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintPlugin(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *NameResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *NameResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *NameResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintPlugin(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *TypeResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TypeResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TypeResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Type) > 0 {
		i -= len(m.Type)
		copy(dAtA[i:], m.Type)
		i = encodeVarintPlugin(dAtA, i, uint64(len(m.Type)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintPlugin(dAtA []byte, offset int, v uint64) int {
	offset -= sovPlugin(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *Empty) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *InitializeRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ConfigPath)
	if l > 0 {
		n += 1 + l + sovPlugin(uint64(l))
	}
	l = len(m.SidecarId)
	if l > 0 {
		n += 1 + l + sovPlugin(uint64(l))
	}
	l = len(m.Extra)
	if l > 0 {
		n += 1 + l + sovPlugin(uint64(l))
	}
	return n
}

func (m *SubmitIBTPResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Status {
		n += 2
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovPlugin(uint64(l))
	}
	if m.Result != nil {
		l = m.Result.Size()
		n += 1 + l + sovPlugin(uint64(l))
	}
	return n
}

func (m *RollbackIBTPRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Ibtp != nil {
		l = m.Ibtp.Size()
		n += 1 + l + sovPlugin(uint64(l))
	}
	if m.SrcChain {
		n += 2
	}
	return n
}

func (m *RollbackIBTPResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Status {
		n += 2
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovPlugin(uint64(l))
	}
	return n
}

func (m *GetOutMessageRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.To)
	if l > 0 {
		n += 1 + l + sovPlugin(uint64(l))
	}
	if m.Idx != 0 {
		n += 1 + sovPlugin(uint64(m.Idx))
	}
	return n
}

func (m *GetInMessageRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.From)
	if l > 0 {
		n += 1 + l + sovPlugin(uint64(l))
	}
	if m.Idx != 0 {
		n += 1 + sovPlugin(uint64(m.Idx))
	}
	return n
}

func (m *GetInMessageResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Result) > 0 {
		for _, b := range m.Result {
			l = len(b)
			n += 1 + l + sovPlugin(uint64(l))
		}
	}
	return n
}

func (m *GetMetaResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Meta) > 0 {
		for k, v := range m.Meta {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovPlugin(uint64(len(k))) + 1 + sovPlugin(uint64(v))
			n += mapEntrySize + 1 + sovPlugin(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *NameResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovPlugin(uint64(l))
	}
	return n
}

func (m *TypeResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Type)
	if l > 0 {
		n += 1 + l + sovPlugin(uint64(l))
	}
	return n
}

func sovPlugin(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozPlugin(x uint64) (n int) {
	return sovPlugin(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Empty) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowPlugin
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Empty: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Empty: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipPlugin(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthPlugin
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthPlugin
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *InitializeRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowPlugin
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: InitializeRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: InitializeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConfigPath", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPlugin
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthPlugin
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthPlugin
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ConfigPath = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SidecarId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPlugin
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthPlugin
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthPlugin
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SidecarId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Extra", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPlugin
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthPlugin
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthPlugin
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Extra = append(m.Extra[:0], dAtA[iNdEx:postIndex]...)
			if m.Extra == nil {
				m.Extra = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipPlugin(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthPlugin
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthPlugin
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SubmitIBTPResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowPlugin
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SubmitIBTPResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SubmitIBTPResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPlugin
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Status = bool(v != 0)
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPlugin
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthPlugin
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthPlugin
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPlugin
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPlugin
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthPlugin
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Result == nil {
				m.Result = &IBTP{}
			}
			if err := m.Result.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipPlugin(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthPlugin
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthPlugin
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RollbackIBTPRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowPlugin
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RollbackIBTPRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RollbackIBTPRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ibtp", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPlugin
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPlugin
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthPlugin
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Ibtp == nil {
				m.Ibtp = &IBTP{}
			}
			if err := m.Ibtp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SrcChain", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPlugin
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.SrcChain = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipPlugin(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthPlugin
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthPlugin
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RollbackIBTPResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowPlugin
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RollbackIBTPResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RollbackIBTPResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPlugin
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Status = bool(v != 0)
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPlugin
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthPlugin
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthPlugin
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipPlugin(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthPlugin
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthPlugin
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetOutMessageRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowPlugin
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetOutMessageRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetOutMessageRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field To", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPlugin
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthPlugin
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthPlugin
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.To = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Idx", wireType)
			}
			m.Idx = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPlugin
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Idx |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipPlugin(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthPlugin
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthPlugin
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetInMessageRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowPlugin
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetInMessageRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetInMessageRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field From", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPlugin
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthPlugin
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthPlugin
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.From = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Idx", wireType)
			}
			m.Idx = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPlugin
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Idx |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipPlugin(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthPlugin
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthPlugin
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetInMessageResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowPlugin
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetInMessageResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetInMessageResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPlugin
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthPlugin
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthPlugin
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Result = append(m.Result, make([]byte, postIndex-iNdEx))
			copy(m.Result[len(m.Result)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipPlugin(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthPlugin
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthPlugin
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetMetaResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowPlugin
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetMetaResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetMetaResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Meta", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPlugin
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPlugin
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthPlugin
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Meta == nil {
				m.Meta = make(map[string]uint64)
			}
			var mapkey string
			var mapvalue uint64
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowPlugin
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowPlugin
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthPlugin
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthPlugin
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowPlugin
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipPlugin(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthPlugin
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Meta[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipPlugin(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthPlugin
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthPlugin
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NameResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowPlugin
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: NameResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NameResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPlugin
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthPlugin
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthPlugin
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipPlugin(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthPlugin
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthPlugin
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TypeResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowPlugin
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TypeResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TypeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPlugin
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthPlugin
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthPlugin
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Type = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipPlugin(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthPlugin
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthPlugin
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipPlugin(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowPlugin
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowPlugin
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowPlugin
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthPlugin
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupPlugin
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthPlugin
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthPlugin        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowPlugin          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupPlugin = fmt.Errorf("proto: unexpected end of group")
)