/*
 * Copyright 2022 CECTC, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

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

package api

import (
	bytes "bytes"
	fmt "fmt"
	io "io"
	math "math"
	math_bits "math/bits"
	reflect "reflect"
	strconv "strconv"
	strings "strings"

	proto "github.com/gogo/protobuf/proto"
)

// 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 ResultCode int32

const (
	ResultCodeFailed  ResultCode = 0
	ResultCodeSuccess ResultCode = 1
)

var ResultCode_name = map[int32]string{
	0: "ResultCodeFailed",
	1: "ResultCodeSuccess",
}

var ResultCode_value = map[string]int32{
	"ResultCodeFailed":  0,
	"ResultCodeSuccess": 1,
}

func (ResultCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{0}
}

type GlobalSession_GlobalStatus int32

const (
	Begin       GlobalSession_GlobalStatus = 0
	Committing  GlobalSession_GlobalStatus = 1
	Rollbacking GlobalSession_GlobalStatus = 2
	Finished    GlobalSession_GlobalStatus = 3
)

var GlobalSession_GlobalStatus_name = map[int32]string{
	0: "Begin",
	1: "Committing",
	2: "Rollbacking",
	3: "Finished",
}

var GlobalSession_GlobalStatus_value = map[string]int32{
	"Begin":       0,
	"Committing":  1,
	"Rollbacking": 2,
	"Finished":    3,
}

func (GlobalSession_GlobalStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{0, 0}
}

type BranchSession_BranchType int32

const (
	AT   BranchSession_BranchType = 0
	TCC  BranchSession_BranchType = 1
	SAGA BranchSession_BranchType = 2
	XA   BranchSession_BranchType = 3
)

var BranchSession_BranchType_name = map[int32]string{
	0: "AT",
	1: "TCC",
	2: "SAGA",
	3: "XA",
}

var BranchSession_BranchType_value = map[string]int32{
	"AT":   0,
	"TCC":  1,
	"SAGA": 2,
	"XA":   3,
}

func (BranchSession_BranchType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{1, 0}
}

type BranchSession_BranchStatus int32

const (
	Registered          BranchSession_BranchStatus = 0
	PhaseOneFailed      BranchSession_BranchStatus = 1
	PhaseTwoCommitting  BranchSession_BranchStatus = 2
	PhaseTwoRollbacking BranchSession_BranchStatus = 3
	Complete            BranchSession_BranchStatus = 4
)

var BranchSession_BranchStatus_name = map[int32]string{
	0: "Registered",
	1: "PhaseOneFailed",
	2: "PhaseTwoCommitting",
	3: "PhaseTwoRollbacking",
	4: "Complete",
}

var BranchSession_BranchStatus_value = map[string]int32{
	"Registered":          0,
	"PhaseOneFailed":      1,
	"PhaseTwoCommitting":  2,
	"PhaseTwoRollbacking": 3,
	"Complete":            4,
}

func (BranchSession_BranchStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{1, 1}
}

type GlobalSession struct {
	XID             string                     `protobuf:"bytes,1,opt,name=XID,proto3" json:"XID,omitempty"`
	ApplicationID   string                     `protobuf:"bytes,2,opt,name=ApplicationID,proto3" json:"ApplicationID,omitempty"`
	TransactionID   int64                      `protobuf:"varint,3,opt,name=TransactionID,proto3" json:"TransactionID,omitempty"`
	TransactionName string                     `protobuf:"bytes,4,opt,name=TransactionName,proto3" json:"TransactionName,omitempty"`
	Timeout         int32                      `protobuf:"varint,5,opt,name=Timeout,proto3" json:"Timeout,omitempty"`
	BeginTime       int64                      `protobuf:"varint,6,opt,name=BeginTime,proto3" json:"BeginTime,omitempty"`
	Status          GlobalSession_GlobalStatus `protobuf:"varint,7,opt,name=Status,proto3,enum=api.GlobalSession_GlobalStatus" json:"Status,omitempty"`
}

func (m *GlobalSession) Reset()      { *m = GlobalSession{} }
func (*GlobalSession) ProtoMessage() {}
func (*GlobalSession) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{0}
}
func (m *GlobalSession) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GlobalSession) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GlobalSession.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 *GlobalSession) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GlobalSession.Merge(m, src)
}
func (m *GlobalSession) XXX_Size() int {
	return m.Size()
}
func (m *GlobalSession) XXX_DiscardUnknown() {
	xxx_messageInfo_GlobalSession.DiscardUnknown(m)
}

var xxx_messageInfo_GlobalSession proto.InternalMessageInfo

func (m *GlobalSession) GetXID() string {
	if m != nil {
		return m.XID
	}
	return ""
}

func (m *GlobalSession) GetApplicationID() string {
	if m != nil {
		return m.ApplicationID
	}
	return ""
}

func (m *GlobalSession) GetTransactionID() int64 {
	if m != nil {
		return m.TransactionID
	}
	return 0
}

func (m *GlobalSession) GetTransactionName() string {
	if m != nil {
		return m.TransactionName
	}
	return ""
}

func (m *GlobalSession) GetTimeout() int32 {
	if m != nil {
		return m.Timeout
	}
	return 0
}

func (m *GlobalSession) GetBeginTime() int64 {
	if m != nil {
		return m.BeginTime
	}
	return 0
}

func (m *GlobalSession) GetStatus() GlobalSession_GlobalStatus {
	if m != nil {
		return m.Status
	}
	return Begin
}

type BranchSession struct {
	BranchID        string                     `protobuf:"bytes,1,opt,name=BranchID,proto3" json:"BranchID,omitempty"`
	ApplicationID   string                     `protobuf:"bytes,2,opt,name=ApplicationID,proto3" json:"ApplicationID,omitempty"`
	BranchSessionID int64                      `protobuf:"varint,3,opt,name=BranchSessionID,proto3" json:"BranchSessionID,omitempty"`
	XID             string                     `protobuf:"bytes,4,opt,name=XID,proto3" json:"XID,omitempty"`
	TransactionID   int64                      `protobuf:"varint,5,opt,name=TransactionID,proto3" json:"TransactionID,omitempty"`
	ResourceID      string                     `protobuf:"bytes,6,opt,name=ResourceID,proto3" json:"ResourceID,omitempty"`
	LockKey         string                     `protobuf:"bytes,7,opt,name=LockKey,proto3" json:"LockKey,omitempty"`
	Type            BranchSession_BranchType   `protobuf:"varint,8,opt,name=Type,proto3,enum=api.BranchSession_BranchType" json:"Type,omitempty"`
	Status          BranchSession_BranchStatus `protobuf:"varint,9,opt,name=Status,proto3,enum=api.BranchSession_BranchStatus" json:"Status,omitempty"`
	ApplicationData []byte                     `protobuf:"bytes,10,opt,name=ApplicationData,proto3" json:"ApplicationData,omitempty"`
	BeginTime       int64                      `protobuf:"varint,11,opt,name=BeginTime,proto3" json:"BeginTime,omitempty"`
}

func (m *BranchSession) Reset()      { *m = BranchSession{} }
func (*BranchSession) ProtoMessage() {}
func (*BranchSession) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{1}
}
func (m *BranchSession) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BranchSession) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BranchSession.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 *BranchSession) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BranchSession.Merge(m, src)
}
func (m *BranchSession) XXX_Size() int {
	return m.Size()
}
func (m *BranchSession) XXX_DiscardUnknown() {
	xxx_messageInfo_BranchSession.DiscardUnknown(m)
}

var xxx_messageInfo_BranchSession proto.InternalMessageInfo

func (m *BranchSession) GetBranchID() string {
	if m != nil {
		return m.BranchID
	}
	return ""
}

func (m *BranchSession) GetApplicationID() string {
	if m != nil {
		return m.ApplicationID
	}
	return ""
}

func (m *BranchSession) GetBranchSessionID() int64 {
	if m != nil {
		return m.BranchSessionID
	}
	return 0
}

func (m *BranchSession) GetXID() string {
	if m != nil {
		return m.XID
	}
	return ""
}

func (m *BranchSession) GetTransactionID() int64 {
	if m != nil {
		return m.TransactionID
	}
	return 0
}

func (m *BranchSession) GetResourceID() string {
	if m != nil {
		return m.ResourceID
	}
	return ""
}

func (m *BranchSession) GetLockKey() string {
	if m != nil {
		return m.LockKey
	}
	return ""
}

func (m *BranchSession) GetType() BranchSession_BranchType {
	if m != nil {
		return m.Type
	}
	return AT
}

func (m *BranchSession) GetStatus() BranchSession_BranchStatus {
	if m != nil {
		return m.Status
	}
	return Registered
}

func (m *BranchSession) GetApplicationData() []byte {
	if m != nil {
		return m.ApplicationData
	}
	return nil
}

func (m *BranchSession) GetBeginTime() int64 {
	if m != nil {
		return m.BeginTime
	}
	return 0
}

// GlobalBeginRequest represents a global transaction begin
type GlobalBeginRequest struct {
	ApplicationID   string `protobuf:"bytes,1,opt,name=ApplicationID,proto3" json:"ApplicationID,omitempty"`
	Timeout         int32  `protobuf:"varint,2,opt,name=Timeout,proto3" json:"Timeout,omitempty"`
	TransactionName string `protobuf:"bytes,3,opt,name=TransactionName,proto3" json:"TransactionName,omitempty"`
}

func (m *GlobalBeginRequest) Reset()      { *m = GlobalBeginRequest{} }
func (*GlobalBeginRequest) ProtoMessage() {}
func (*GlobalBeginRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{2}
}
func (m *GlobalBeginRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GlobalBeginRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GlobalBeginRequest.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 *GlobalBeginRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GlobalBeginRequest.Merge(m, src)
}
func (m *GlobalBeginRequest) XXX_Size() int {
	return m.Size()
}
func (m *GlobalBeginRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GlobalBeginRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GlobalBeginRequest proto.InternalMessageInfo

func (m *GlobalBeginRequest) GetApplicationID() string {
	if m != nil {
		return m.ApplicationID
	}
	return ""
}

func (m *GlobalBeginRequest) GetTimeout() int32 {
	if m != nil {
		return m.Timeout
	}
	return 0
}

func (m *GlobalBeginRequest) GetTransactionName() string {
	if m != nil {
		return m.TransactionName
	}
	return ""
}

// GlobalBeginResponse represents a response to GlobalBeginRequest
type GlobalBeginResponse struct {
	ResultCode ResultCode `protobuf:"varint,1,opt,name=ResultCode,proto3,enum=api.ResultCode" json:"ResultCode,omitempty"`
	Message    string     `protobuf:"bytes,2,opt,name=Message,proto3" json:"Message,omitempty"`
	XID        string     `protobuf:"bytes,4,opt,name=XID,proto3" json:"XID,omitempty"`
}

func (m *GlobalBeginResponse) Reset()      { *m = GlobalBeginResponse{} }
func (*GlobalBeginResponse) ProtoMessage() {}
func (*GlobalBeginResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{3}
}
func (m *GlobalBeginResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GlobalBeginResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GlobalBeginResponse.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 *GlobalBeginResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GlobalBeginResponse.Merge(m, src)
}
func (m *GlobalBeginResponse) XXX_Size() int {
	return m.Size()
}
func (m *GlobalBeginResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GlobalBeginResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GlobalBeginResponse proto.InternalMessageInfo

func (m *GlobalBeginResponse) GetResultCode() ResultCode {
	if m != nil {
		return m.ResultCode
	}
	return ResultCodeFailed
}

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

func (m *GlobalBeginResponse) GetXID() string {
	if m != nil {
		return m.XID
	}
	return ""
}

// BranchRegisterRequest represents a branch transaction join in the global transaction
type BranchRegisterRequest struct {
	XID             string                   `protobuf:"bytes,1,opt,name=XID,proto3" json:"XID,omitempty"`
	ResourceID      string                   `protobuf:"bytes,2,opt,name=ResourceID,proto3" json:"ResourceID,omitempty"`
	LockKey         string                   `protobuf:"bytes,3,opt,name=LockKey,proto3" json:"LockKey,omitempty"`
	BranchType      BranchSession_BranchType `protobuf:"varint,4,opt,name=BranchType,proto3,enum=api.BranchSession_BranchType" json:"BranchType,omitempty"`
	ApplicationData []byte                   `protobuf:"bytes,5,opt,name=ApplicationData,proto3" json:"ApplicationData,omitempty"`
}

func (m *BranchRegisterRequest) Reset()      { *m = BranchRegisterRequest{} }
func (*BranchRegisterRequest) ProtoMessage() {}
func (*BranchRegisterRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{4}
}
func (m *BranchRegisterRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BranchRegisterRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BranchRegisterRequest.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 *BranchRegisterRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BranchRegisterRequest.Merge(m, src)
}
func (m *BranchRegisterRequest) XXX_Size() int {
	return m.Size()
}
func (m *BranchRegisterRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_BranchRegisterRequest.DiscardUnknown(m)
}

var xxx_messageInfo_BranchRegisterRequest proto.InternalMessageInfo

func (m *BranchRegisterRequest) GetXID() string {
	if m != nil {
		return m.XID
	}
	return ""
}

func (m *BranchRegisterRequest) GetResourceID() string {
	if m != nil {
		return m.ResourceID
	}
	return ""
}

func (m *BranchRegisterRequest) GetLockKey() string {
	if m != nil {
		return m.LockKey
	}
	return ""
}

func (m *BranchRegisterRequest) GetBranchType() BranchSession_BranchType {
	if m != nil {
		return m.BranchType
	}
	return AT
}

func (m *BranchRegisterRequest) GetApplicationData() []byte {
	if m != nil {
		return m.ApplicationData
	}
	return nil
}

// BranchRegisterResponse represents a response to BranchRegisterRequest
type BranchRegisterResponse struct {
	ResultCode      ResultCode `protobuf:"varint,1,opt,name=ResultCode,proto3,enum=api.ResultCode" json:"ResultCode,omitempty"`
	Message         string     `protobuf:"bytes,2,opt,name=Message,proto3" json:"Message,omitempty"`
	BranchID        string     `protobuf:"bytes,3,opt,name=BranchID,proto3" json:"BranchID,omitempty"`
	BranchSessionID int64      `protobuf:"varint,4,opt,name=BranchSessionID,proto3" json:"BranchSessionID,omitempty"`
}

func (m *BranchRegisterResponse) Reset()      { *m = BranchRegisterResponse{} }
func (*BranchRegisterResponse) ProtoMessage() {}
func (*BranchRegisterResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{5}
}
func (m *BranchRegisterResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BranchRegisterResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BranchRegisterResponse.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 *BranchRegisterResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BranchRegisterResponse.Merge(m, src)
}
func (m *BranchRegisterResponse) XXX_Size() int {
	return m.Size()
}
func (m *BranchRegisterResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_BranchRegisterResponse.DiscardUnknown(m)
}

var xxx_messageInfo_BranchRegisterResponse proto.InternalMessageInfo

func (m *BranchRegisterResponse) GetResultCode() ResultCode {
	if m != nil {
		return m.ResultCode
	}
	return ResultCodeFailed
}

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

func (m *BranchRegisterResponse) GetBranchID() string {
	if m != nil {
		return m.BranchID
	}
	return ""
}

func (m *BranchRegisterResponse) GetBranchSessionID() int64 {
	if m != nil {
		return m.BranchSessionID
	}
	return 0
}

// BranchReportRequest represents a request to report branch transaction execution status
type BranchReportRequest struct {
	BranchID     string                     `protobuf:"bytes,1,opt,name=BranchID,proto3" json:"BranchID,omitempty"`
	BranchStatus BranchSession_BranchStatus `protobuf:"varint,2,opt,name=BranchStatus,proto3,enum=api.BranchSession_BranchStatus" json:"BranchStatus,omitempty"`
}

func (m *BranchReportRequest) Reset()      { *m = BranchReportRequest{} }
func (*BranchReportRequest) ProtoMessage() {}
func (*BranchReportRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{6}
}
func (m *BranchReportRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BranchReportRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BranchReportRequest.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 *BranchReportRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BranchReportRequest.Merge(m, src)
}
func (m *BranchReportRequest) XXX_Size() int {
	return m.Size()
}
func (m *BranchReportRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_BranchReportRequest.DiscardUnknown(m)
}

var xxx_messageInfo_BranchReportRequest proto.InternalMessageInfo

func (m *BranchReportRequest) GetBranchID() string {
	if m != nil {
		return m.BranchID
	}
	return ""
}

func (m *BranchReportRequest) GetBranchStatus() BranchSession_BranchStatus {
	if m != nil {
		return m.BranchStatus
	}
	return Registered
}

// BranchReportResponse represents a response to BranchReportRequest
type BranchReportResponse struct {
	ResultCode ResultCode `protobuf:"varint,1,opt,name=ResultCode,proto3,enum=api.ResultCode" json:"ResultCode,omitempty"`
	Message    string     `protobuf:"bytes,2,opt,name=Message,proto3" json:"Message,omitempty"`
}

func (m *BranchReportResponse) Reset()      { *m = BranchReportResponse{} }
func (*BranchReportResponse) ProtoMessage() {}
func (*BranchReportResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{7}
}
func (m *BranchReportResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BranchReportResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BranchReportResponse.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 *BranchReportResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BranchReportResponse.Merge(m, src)
}
func (m *BranchReportResponse) XXX_Size() int {
	return m.Size()
}
func (m *BranchReportResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_BranchReportResponse.DiscardUnknown(m)
}

var xxx_messageInfo_BranchReportResponse proto.InternalMessageInfo

func (m *BranchReportResponse) GetResultCode() ResultCode {
	if m != nil {
		return m.ResultCode
	}
	return ResultCodeFailed
}

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

// GlobalLockQueryRequest represents a request to query the global lock
type GlobalLockQueryRequest struct {
	ResourceID string `protobuf:"bytes,1,opt,name=ResourceID,proto3" json:"ResourceID,omitempty"`
	LockKey    string `protobuf:"bytes,2,opt,name=LockKey,proto3" json:"LockKey,omitempty"`
}

func (m *GlobalLockQueryRequest) Reset()      { *m = GlobalLockQueryRequest{} }
func (*GlobalLockQueryRequest) ProtoMessage() {}
func (*GlobalLockQueryRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{8}
}
func (m *GlobalLockQueryRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GlobalLockQueryRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GlobalLockQueryRequest.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 *GlobalLockQueryRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GlobalLockQueryRequest.Merge(m, src)
}
func (m *GlobalLockQueryRequest) XXX_Size() int {
	return m.Size()
}
func (m *GlobalLockQueryRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GlobalLockQueryRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GlobalLockQueryRequest proto.InternalMessageInfo

func (m *GlobalLockQueryRequest) GetResourceID() string {
	if m != nil {
		return m.ResourceID
	}
	return ""
}

func (m *GlobalLockQueryRequest) GetLockKey() string {
	if m != nil {
		return m.LockKey
	}
	return ""
}

// GlobalLockQueryResponse represents a response to GlobalLockQueryRequest
type GlobalLockQueryResponse struct {
	ResultCode ResultCode `protobuf:"varint,1,opt,name=ResultCode,proto3,enum=api.ResultCode" json:"ResultCode,omitempty"`
	Message    string     `protobuf:"bytes,2,opt,name=Message,proto3" json:"Message,omitempty"`
	Lockable   bool       `protobuf:"varint,3,opt,name=Lockable,proto3" json:"Lockable,omitempty"`
}

func (m *GlobalLockQueryResponse) Reset()      { *m = GlobalLockQueryResponse{} }
func (*GlobalLockQueryResponse) ProtoMessage() {}
func (*GlobalLockQueryResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{9}
}
func (m *GlobalLockQueryResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GlobalLockQueryResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GlobalLockQueryResponse.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 *GlobalLockQueryResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GlobalLockQueryResponse.Merge(m, src)
}
func (m *GlobalLockQueryResponse) XXX_Size() int {
	return m.Size()
}
func (m *GlobalLockQueryResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GlobalLockQueryResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GlobalLockQueryResponse proto.InternalMessageInfo

func (m *GlobalLockQueryResponse) GetResultCode() ResultCode {
	if m != nil {
		return m.ResultCode
	}
	return ResultCodeFailed
}

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

func (m *GlobalLockQueryResponse) GetLockable() bool {
	if m != nil {
		return m.Lockable
	}
	return false
}

// GlobalStatusRequest represents a request to query the global transaction status
type GlobalStatusRequest struct {
	XID string `protobuf:"bytes,1,opt,name=XID,proto3" json:"XID,omitempty"`
}

func (m *GlobalStatusRequest) Reset()      { *m = GlobalStatusRequest{} }
func (*GlobalStatusRequest) ProtoMessage() {}
func (*GlobalStatusRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{10}
}
func (m *GlobalStatusRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GlobalStatusRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GlobalStatusRequest.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 *GlobalStatusRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GlobalStatusRequest.Merge(m, src)
}
func (m *GlobalStatusRequest) XXX_Size() int {
	return m.Size()
}
func (m *GlobalStatusRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GlobalStatusRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GlobalStatusRequest proto.InternalMessageInfo

func (m *GlobalStatusRequest) GetXID() string {
	if m != nil {
		return m.XID
	}
	return ""
}

// GlobalStatusResponse represents a response to GlobalStatusRequest
type GlobalStatusResponse struct {
	ResultCode   ResultCode                 `protobuf:"varint,1,opt,name=ResultCode,proto3,enum=api.ResultCode" json:"ResultCode,omitempty"`
	Message      string                     `protobuf:"bytes,2,opt,name=Message,proto3" json:"Message,omitempty"`
	GlobalStatus GlobalSession_GlobalStatus `protobuf:"varint,3,opt,name=GlobalStatus,proto3,enum=api.GlobalSession_GlobalStatus" json:"GlobalStatus,omitempty"`
}

func (m *GlobalStatusResponse) Reset()      { *m = GlobalStatusResponse{} }
func (*GlobalStatusResponse) ProtoMessage() {}
func (*GlobalStatusResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{11}
}
func (m *GlobalStatusResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GlobalStatusResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GlobalStatusResponse.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 *GlobalStatusResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GlobalStatusResponse.Merge(m, src)
}
func (m *GlobalStatusResponse) XXX_Size() int {
	return m.Size()
}
func (m *GlobalStatusResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GlobalStatusResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GlobalStatusResponse proto.InternalMessageInfo

func (m *GlobalStatusResponse) GetResultCode() ResultCode {
	if m != nil {
		return m.ResultCode
	}
	return ResultCodeFailed
}

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

func (m *GlobalStatusResponse) GetGlobalStatus() GlobalSession_GlobalStatus {
	if m != nil {
		return m.GlobalStatus
	}
	return Begin
}

// GlobalCommitRequest represents a request to commit global transaction
type GlobalCommitRequest struct {
	XID string `protobuf:"bytes,1,opt,name=XID,proto3" json:"XID,omitempty"`
}

func (m *GlobalCommitRequest) Reset()      { *m = GlobalCommitRequest{} }
func (*GlobalCommitRequest) ProtoMessage() {}
func (*GlobalCommitRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{12}
}
func (m *GlobalCommitRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GlobalCommitRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GlobalCommitRequest.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 *GlobalCommitRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GlobalCommitRequest.Merge(m, src)
}
func (m *GlobalCommitRequest) XXX_Size() int {
	return m.Size()
}
func (m *GlobalCommitRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GlobalCommitRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GlobalCommitRequest proto.InternalMessageInfo

func (m *GlobalCommitRequest) GetXID() string {
	if m != nil {
		return m.XID
	}
	return ""
}

// GlobalCommitResponse represents a response to GlobalCommitRequest
type GlobalCommitResponse struct {
	ResultCode   ResultCode                 `protobuf:"varint,1,opt,name=ResultCode,proto3,enum=api.ResultCode" json:"ResultCode,omitempty"`
	Message      string                     `protobuf:"bytes,2,opt,name=Message,proto3" json:"Message,omitempty"`
	GlobalStatus GlobalSession_GlobalStatus `protobuf:"varint,3,opt,name=GlobalStatus,proto3,enum=api.GlobalSession_GlobalStatus" json:"GlobalStatus,omitempty"`
}

func (m *GlobalCommitResponse) Reset()      { *m = GlobalCommitResponse{} }
func (*GlobalCommitResponse) ProtoMessage() {}
func (*GlobalCommitResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{13}
}
func (m *GlobalCommitResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GlobalCommitResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GlobalCommitResponse.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 *GlobalCommitResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GlobalCommitResponse.Merge(m, src)
}
func (m *GlobalCommitResponse) XXX_Size() int {
	return m.Size()
}
func (m *GlobalCommitResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GlobalCommitResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GlobalCommitResponse proto.InternalMessageInfo

func (m *GlobalCommitResponse) GetResultCode() ResultCode {
	if m != nil {
		return m.ResultCode
	}
	return ResultCodeFailed
}

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

func (m *GlobalCommitResponse) GetGlobalStatus() GlobalSession_GlobalStatus {
	if m != nil {
		return m.GlobalStatus
	}
	return Begin
}

// GlobalRollbackRequest represents a request to rollback global transaction
type GlobalRollbackRequest struct {
	XID string `protobuf:"bytes,1,opt,name=XID,proto3" json:"XID,omitempty"`
}

func (m *GlobalRollbackRequest) Reset()      { *m = GlobalRollbackRequest{} }
func (*GlobalRollbackRequest) ProtoMessage() {}
func (*GlobalRollbackRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{14}
}
func (m *GlobalRollbackRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GlobalRollbackRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GlobalRollbackRequest.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 *GlobalRollbackRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GlobalRollbackRequest.Merge(m, src)
}
func (m *GlobalRollbackRequest) XXX_Size() int {
	return m.Size()
}
func (m *GlobalRollbackRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GlobalRollbackRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GlobalRollbackRequest proto.InternalMessageInfo

func (m *GlobalRollbackRequest) GetXID() string {
	if m != nil {
		return m.XID
	}
	return ""
}

// GlobalRollbackResponse represents a response to GlobalRollbackRequest
type GlobalRollbackResponse struct {
	ResultCode   ResultCode                 `protobuf:"varint,1,opt,name=ResultCode,proto3,enum=api.ResultCode" json:"ResultCode,omitempty"`
	Message      string                     `protobuf:"bytes,2,opt,name=Message,proto3" json:"Message,omitempty"`
	GlobalStatus GlobalSession_GlobalStatus `protobuf:"varint,3,opt,name=GlobalStatus,proto3,enum=api.GlobalSession_GlobalStatus" json:"GlobalStatus,omitempty"`
}

func (m *GlobalRollbackResponse) Reset()      { *m = GlobalRollbackResponse{} }
func (*GlobalRollbackResponse) ProtoMessage() {}
func (*GlobalRollbackResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{15}
}
func (m *GlobalRollbackResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GlobalRollbackResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GlobalRollbackResponse.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 *GlobalRollbackResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GlobalRollbackResponse.Merge(m, src)
}
func (m *GlobalRollbackResponse) XXX_Size() int {
	return m.Size()
}
func (m *GlobalRollbackResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GlobalRollbackResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GlobalRollbackResponse proto.InternalMessageInfo

func (m *GlobalRollbackResponse) GetResultCode() ResultCode {
	if m != nil {
		return m.ResultCode
	}
	return ResultCodeFailed
}

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

func (m *GlobalRollbackResponse) GetGlobalStatus() GlobalSession_GlobalStatus {
	if m != nil {
		return m.GlobalStatus
	}
	return Begin
}

// GlobalReportRequest represents a request to report global transaction execution status
type GlobalReportRequest struct {
	XID          string                     `protobuf:"bytes,1,opt,name=XID,proto3" json:"XID,omitempty"`
	GlobalStatus GlobalSession_GlobalStatus `protobuf:"varint,2,opt,name=GlobalStatus,proto3,enum=api.GlobalSession_GlobalStatus" json:"GlobalStatus,omitempty"`
}

func (m *GlobalReportRequest) Reset()      { *m = GlobalReportRequest{} }
func (*GlobalReportRequest) ProtoMessage() {}
func (*GlobalReportRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{16}
}
func (m *GlobalReportRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GlobalReportRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GlobalReportRequest.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 *GlobalReportRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GlobalReportRequest.Merge(m, src)
}
func (m *GlobalReportRequest) XXX_Size() int {
	return m.Size()
}
func (m *GlobalReportRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GlobalReportRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GlobalReportRequest proto.InternalMessageInfo

func (m *GlobalReportRequest) GetXID() string {
	if m != nil {
		return m.XID
	}
	return ""
}

func (m *GlobalReportRequest) GetGlobalStatus() GlobalSession_GlobalStatus {
	if m != nil {
		return m.GlobalStatus
	}
	return Begin
}

// GlobalReportResponse represents a response to GlobalReportRequest
type GlobalReportResponse struct {
	ResultCode   ResultCode                 `protobuf:"varint,1,opt,name=ResultCode,proto3,enum=api.ResultCode" json:"ResultCode,omitempty"`
	Message      string                     `protobuf:"bytes,2,opt,name=Message,proto3" json:"Message,omitempty"`
	GlobalStatus GlobalSession_GlobalStatus `protobuf:"varint,3,opt,name=GlobalStatus,proto3,enum=api.GlobalSession_GlobalStatus" json:"GlobalStatus,omitempty"`
}

func (m *GlobalReportResponse) Reset()      { *m = GlobalReportResponse{} }
func (*GlobalReportResponse) ProtoMessage() {}
func (*GlobalReportResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{17}
}
func (m *GlobalReportResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GlobalReportResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GlobalReportResponse.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 *GlobalReportResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GlobalReportResponse.Merge(m, src)
}
func (m *GlobalReportResponse) XXX_Size() int {
	return m.Size()
}
func (m *GlobalReportResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GlobalReportResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GlobalReportResponse proto.InternalMessageInfo

func (m *GlobalReportResponse) GetResultCode() ResultCode {
	if m != nil {
		return m.ResultCode
	}
	return ResultCodeFailed
}

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

func (m *GlobalReportResponse) GetGlobalStatus() GlobalSession_GlobalStatus {
	if m != nil {
		return m.GlobalStatus
	}
	return Begin
}

func init() {
	proto.RegisterEnum("api.ResultCode", ResultCode_name, ResultCode_value)
	proto.RegisterEnum("api.GlobalSession_GlobalStatus", GlobalSession_GlobalStatus_name, GlobalSession_GlobalStatus_value)
	proto.RegisterEnum("api.BranchSession_BranchType", BranchSession_BranchType_name, BranchSession_BranchType_value)
	proto.RegisterEnum("api.BranchSession_BranchStatus", BranchSession_BranchStatus_name, BranchSession_BranchStatus_value)
	proto.RegisterType((*GlobalSession)(nil), "api.GlobalSession")
	proto.RegisterType((*BranchSession)(nil), "api.BranchSession")
	proto.RegisterType((*GlobalBeginRequest)(nil), "api.GlobalBeginRequest")
	proto.RegisterType((*GlobalBeginResponse)(nil), "api.GlobalBeginResponse")
	proto.RegisterType((*BranchRegisterRequest)(nil), "api.BranchRegisterRequest")
	proto.RegisterType((*BranchRegisterResponse)(nil), "api.BranchRegisterResponse")
	proto.RegisterType((*BranchReportRequest)(nil), "api.BranchReportRequest")
	proto.RegisterType((*BranchReportResponse)(nil), "api.BranchReportResponse")
	proto.RegisterType((*GlobalLockQueryRequest)(nil), "api.GlobalLockQueryRequest")
	proto.RegisterType((*GlobalLockQueryResponse)(nil), "api.GlobalLockQueryResponse")
	proto.RegisterType((*GlobalStatusRequest)(nil), "api.GlobalStatusRequest")
	proto.RegisterType((*GlobalStatusResponse)(nil), "api.GlobalStatusResponse")
	proto.RegisterType((*GlobalCommitRequest)(nil), "api.GlobalCommitRequest")
	proto.RegisterType((*GlobalCommitResponse)(nil), "api.GlobalCommitResponse")
	proto.RegisterType((*GlobalRollbackRequest)(nil), "api.GlobalRollbackRequest")
	proto.RegisterType((*GlobalRollbackResponse)(nil), "api.GlobalRollbackResponse")
	proto.RegisterType((*GlobalReportRequest)(nil), "api.GlobalReportRequest")
	proto.RegisterType((*GlobalReportResponse)(nil), "api.GlobalReportResponse")
}

func init() { proto.RegisterFile("api.proto", fileDescriptor_00212fb1f9d3bf1c) }

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

func (x ResultCode) String() string {
	s, ok := ResultCode_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x GlobalSession_GlobalStatus) String() string {
	s, ok := GlobalSession_GlobalStatus_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x BranchSession_BranchType) String() string {
	s, ok := BranchSession_BranchType_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x BranchSession_BranchStatus) String() string {
	s, ok := BranchSession_BranchStatus_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (this *GlobalSession) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GlobalSession)
	if !ok {
		that2, ok := that.(GlobalSession)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.XID != that1.XID {
		return false
	}
	if this.ApplicationID != that1.ApplicationID {
		return false
	}
	if this.TransactionID != that1.TransactionID {
		return false
	}
	if this.TransactionName != that1.TransactionName {
		return false
	}
	if this.Timeout != that1.Timeout {
		return false
	}
	if this.BeginTime != that1.BeginTime {
		return false
	}
	if this.Status != that1.Status {
		return false
	}
	return true
}
func (this *BranchSession) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*BranchSession)
	if !ok {
		that2, ok := that.(BranchSession)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.BranchID != that1.BranchID {
		return false
	}
	if this.ApplicationID != that1.ApplicationID {
		return false
	}
	if this.BranchSessionID != that1.BranchSessionID {
		return false
	}
	if this.XID != that1.XID {
		return false
	}
	if this.TransactionID != that1.TransactionID {
		return false
	}
	if this.ResourceID != that1.ResourceID {
		return false
	}
	if this.LockKey != that1.LockKey {
		return false
	}
	if this.Type != that1.Type {
		return false
	}
	if this.Status != that1.Status {
		return false
	}
	if !bytes.Equal(this.ApplicationData, that1.ApplicationData) {
		return false
	}
	if this.BeginTime != that1.BeginTime {
		return false
	}
	return true
}
func (this *GlobalBeginRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GlobalBeginRequest)
	if !ok {
		that2, ok := that.(GlobalBeginRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ApplicationID != that1.ApplicationID {
		return false
	}
	if this.Timeout != that1.Timeout {
		return false
	}
	if this.TransactionName != that1.TransactionName {
		return false
	}
	return true
}
func (this *GlobalBeginResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GlobalBeginResponse)
	if !ok {
		that2, ok := that.(GlobalBeginResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ResultCode != that1.ResultCode {
		return false
	}
	if this.Message != that1.Message {
		return false
	}
	if this.XID != that1.XID {
		return false
	}
	return true
}
func (this *BranchRegisterRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*BranchRegisterRequest)
	if !ok {
		that2, ok := that.(BranchRegisterRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.XID != that1.XID {
		return false
	}
	if this.ResourceID != that1.ResourceID {
		return false
	}
	if this.LockKey != that1.LockKey {
		return false
	}
	if this.BranchType != that1.BranchType {
		return false
	}
	if !bytes.Equal(this.ApplicationData, that1.ApplicationData) {
		return false
	}
	return true
}
func (this *BranchRegisterResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*BranchRegisterResponse)
	if !ok {
		that2, ok := that.(BranchRegisterResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ResultCode != that1.ResultCode {
		return false
	}
	if this.Message != that1.Message {
		return false
	}
	if this.BranchID != that1.BranchID {
		return false
	}
	if this.BranchSessionID != that1.BranchSessionID {
		return false
	}
	return true
}
func (this *BranchReportRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*BranchReportRequest)
	if !ok {
		that2, ok := that.(BranchReportRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.BranchID != that1.BranchID {
		return false
	}
	if this.BranchStatus != that1.BranchStatus {
		return false
	}
	return true
}
func (this *BranchReportResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*BranchReportResponse)
	if !ok {
		that2, ok := that.(BranchReportResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ResultCode != that1.ResultCode {
		return false
	}
	if this.Message != that1.Message {
		return false
	}
	return true
}
func (this *GlobalLockQueryRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GlobalLockQueryRequest)
	if !ok {
		that2, ok := that.(GlobalLockQueryRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ResourceID != that1.ResourceID {
		return false
	}
	if this.LockKey != that1.LockKey {
		return false
	}
	return true
}
func (this *GlobalLockQueryResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GlobalLockQueryResponse)
	if !ok {
		that2, ok := that.(GlobalLockQueryResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ResultCode != that1.ResultCode {
		return false
	}
	if this.Message != that1.Message {
		return false
	}
	if this.Lockable != that1.Lockable {
		return false
	}
	return true
}
func (this *GlobalStatusRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GlobalStatusRequest)
	if !ok {
		that2, ok := that.(GlobalStatusRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.XID != that1.XID {
		return false
	}
	return true
}
func (this *GlobalStatusResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GlobalStatusResponse)
	if !ok {
		that2, ok := that.(GlobalStatusResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ResultCode != that1.ResultCode {
		return false
	}
	if this.Message != that1.Message {
		return false
	}
	if this.GlobalStatus != that1.GlobalStatus {
		return false
	}
	return true
}
func (this *GlobalCommitRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GlobalCommitRequest)
	if !ok {
		that2, ok := that.(GlobalCommitRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.XID != that1.XID {
		return false
	}
	return true
}
func (this *GlobalCommitResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GlobalCommitResponse)
	if !ok {
		that2, ok := that.(GlobalCommitResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ResultCode != that1.ResultCode {
		return false
	}
	if this.Message != that1.Message {
		return false
	}
	if this.GlobalStatus != that1.GlobalStatus {
		return false
	}
	return true
}
func (this *GlobalRollbackRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GlobalRollbackRequest)
	if !ok {
		that2, ok := that.(GlobalRollbackRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.XID != that1.XID {
		return false
	}
	return true
}
func (this *GlobalRollbackResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GlobalRollbackResponse)
	if !ok {
		that2, ok := that.(GlobalRollbackResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ResultCode != that1.ResultCode {
		return false
	}
	if this.Message != that1.Message {
		return false
	}
	if this.GlobalStatus != that1.GlobalStatus {
		return false
	}
	return true
}
func (this *GlobalReportRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GlobalReportRequest)
	if !ok {
		that2, ok := that.(GlobalReportRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.XID != that1.XID {
		return false
	}
	if this.GlobalStatus != that1.GlobalStatus {
		return false
	}
	return true
}
func (this *GlobalReportResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GlobalReportResponse)
	if !ok {
		that2, ok := that.(GlobalReportResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ResultCode != that1.ResultCode {
		return false
	}
	if this.Message != that1.Message {
		return false
	}
	if this.GlobalStatus != that1.GlobalStatus {
		return false
	}
	return true
}
func (this *GlobalSession) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 11)
	s = append(s, "&api.GlobalSession{")
	s = append(s, "XID: "+fmt.Sprintf("%#v", this.XID)+",\n")
	s = append(s, "ApplicationID: "+fmt.Sprintf("%#v", this.ApplicationID)+",\n")
	s = append(s, "TransactionID: "+fmt.Sprintf("%#v", this.TransactionID)+",\n")
	s = append(s, "TransactionName: "+fmt.Sprintf("%#v", this.TransactionName)+",\n")
	s = append(s, "Timeout: "+fmt.Sprintf("%#v", this.Timeout)+",\n")
	s = append(s, "BeginTime: "+fmt.Sprintf("%#v", this.BeginTime)+",\n")
	s = append(s, "Status: "+fmt.Sprintf("%#v", this.Status)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *BranchSession) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 15)
	s = append(s, "&api.BranchSession{")
	s = append(s, "BranchID: "+fmt.Sprintf("%#v", this.BranchID)+",\n")
	s = append(s, "ApplicationID: "+fmt.Sprintf("%#v", this.ApplicationID)+",\n")
	s = append(s, "BranchSessionID: "+fmt.Sprintf("%#v", this.BranchSessionID)+",\n")
	s = append(s, "XID: "+fmt.Sprintf("%#v", this.XID)+",\n")
	s = append(s, "TransactionID: "+fmt.Sprintf("%#v", this.TransactionID)+",\n")
	s = append(s, "ResourceID: "+fmt.Sprintf("%#v", this.ResourceID)+",\n")
	s = append(s, "LockKey: "+fmt.Sprintf("%#v", this.LockKey)+",\n")
	s = append(s, "Type: "+fmt.Sprintf("%#v", this.Type)+",\n")
	s = append(s, "Status: "+fmt.Sprintf("%#v", this.Status)+",\n")
	s = append(s, "ApplicationData: "+fmt.Sprintf("%#v", this.ApplicationData)+",\n")
	s = append(s, "BeginTime: "+fmt.Sprintf("%#v", this.BeginTime)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *GlobalBeginRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&api.GlobalBeginRequest{")
	s = append(s, "ApplicationID: "+fmt.Sprintf("%#v", this.ApplicationID)+",\n")
	s = append(s, "Timeout: "+fmt.Sprintf("%#v", this.Timeout)+",\n")
	s = append(s, "TransactionName: "+fmt.Sprintf("%#v", this.TransactionName)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *GlobalBeginResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&api.GlobalBeginResponse{")
	s = append(s, "ResultCode: "+fmt.Sprintf("%#v", this.ResultCode)+",\n")
	s = append(s, "Message: "+fmt.Sprintf("%#v", this.Message)+",\n")
	s = append(s, "XID: "+fmt.Sprintf("%#v", this.XID)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *BranchRegisterRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 9)
	s = append(s, "&api.BranchRegisterRequest{")
	s = append(s, "XID: "+fmt.Sprintf("%#v", this.XID)+",\n")
	s = append(s, "ResourceID: "+fmt.Sprintf("%#v", this.ResourceID)+",\n")
	s = append(s, "LockKey: "+fmt.Sprintf("%#v", this.LockKey)+",\n")
	s = append(s, "BranchType: "+fmt.Sprintf("%#v", this.BranchType)+",\n")
	s = append(s, "ApplicationData: "+fmt.Sprintf("%#v", this.ApplicationData)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *BranchRegisterResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&api.BranchRegisterResponse{")
	s = append(s, "ResultCode: "+fmt.Sprintf("%#v", this.ResultCode)+",\n")
	s = append(s, "Message: "+fmt.Sprintf("%#v", this.Message)+",\n")
	s = append(s, "BranchID: "+fmt.Sprintf("%#v", this.BranchID)+",\n")
	s = append(s, "BranchSessionID: "+fmt.Sprintf("%#v", this.BranchSessionID)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *BranchReportRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&api.BranchReportRequest{")
	s = append(s, "BranchID: "+fmt.Sprintf("%#v", this.BranchID)+",\n")
	s = append(s, "BranchStatus: "+fmt.Sprintf("%#v", this.BranchStatus)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *BranchReportResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&api.BranchReportResponse{")
	s = append(s, "ResultCode: "+fmt.Sprintf("%#v", this.ResultCode)+",\n")
	s = append(s, "Message: "+fmt.Sprintf("%#v", this.Message)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *GlobalLockQueryRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&api.GlobalLockQueryRequest{")
	s = append(s, "ResourceID: "+fmt.Sprintf("%#v", this.ResourceID)+",\n")
	s = append(s, "LockKey: "+fmt.Sprintf("%#v", this.LockKey)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *GlobalLockQueryResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&api.GlobalLockQueryResponse{")
	s = append(s, "ResultCode: "+fmt.Sprintf("%#v", this.ResultCode)+",\n")
	s = append(s, "Message: "+fmt.Sprintf("%#v", this.Message)+",\n")
	s = append(s, "Lockable: "+fmt.Sprintf("%#v", this.Lockable)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *GlobalStatusRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&api.GlobalStatusRequest{")
	s = append(s, "XID: "+fmt.Sprintf("%#v", this.XID)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *GlobalStatusResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&api.GlobalStatusResponse{")
	s = append(s, "ResultCode: "+fmt.Sprintf("%#v", this.ResultCode)+",\n")
	s = append(s, "Message: "+fmt.Sprintf("%#v", this.Message)+",\n")
	s = append(s, "GlobalStatus: "+fmt.Sprintf("%#v", this.GlobalStatus)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *GlobalCommitRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&api.GlobalCommitRequest{")
	s = append(s, "XID: "+fmt.Sprintf("%#v", this.XID)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *GlobalCommitResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&api.GlobalCommitResponse{")
	s = append(s, "ResultCode: "+fmt.Sprintf("%#v", this.ResultCode)+",\n")
	s = append(s, "Message: "+fmt.Sprintf("%#v", this.Message)+",\n")
	s = append(s, "GlobalStatus: "+fmt.Sprintf("%#v", this.GlobalStatus)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *GlobalRollbackRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&api.GlobalRollbackRequest{")
	s = append(s, "XID: "+fmt.Sprintf("%#v", this.XID)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *GlobalRollbackResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&api.GlobalRollbackResponse{")
	s = append(s, "ResultCode: "+fmt.Sprintf("%#v", this.ResultCode)+",\n")
	s = append(s, "Message: "+fmt.Sprintf("%#v", this.Message)+",\n")
	s = append(s, "GlobalStatus: "+fmt.Sprintf("%#v", this.GlobalStatus)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *GlobalReportRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&api.GlobalReportRequest{")
	s = append(s, "XID: "+fmt.Sprintf("%#v", this.XID)+",\n")
	s = append(s, "GlobalStatus: "+fmt.Sprintf("%#v", this.GlobalStatus)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *GlobalReportResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&api.GlobalReportResponse{")
	s = append(s, "ResultCode: "+fmt.Sprintf("%#v", this.ResultCode)+",\n")
	s = append(s, "Message: "+fmt.Sprintf("%#v", this.Message)+",\n")
	s = append(s, "GlobalStatus: "+fmt.Sprintf("%#v", this.GlobalStatus)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func valueToGoStringApi(v interface{}, typ string) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
}
func (m *GlobalSession) 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 *GlobalSession) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GlobalSession) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Status != 0 {
		i = encodeVarintApi(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x38
	}
	if m.BeginTime != 0 {
		i = encodeVarintApi(dAtA, i, uint64(m.BeginTime))
		i--
		dAtA[i] = 0x30
	}
	if m.Timeout != 0 {
		i = encodeVarintApi(dAtA, i, uint64(m.Timeout))
		i--
		dAtA[i] = 0x28
	}
	if len(m.TransactionName) > 0 {
		i -= len(m.TransactionName)
		copy(dAtA[i:], m.TransactionName)
		i = encodeVarintApi(dAtA, i, uint64(len(m.TransactionName)))
		i--
		dAtA[i] = 0x22
	}
	if m.TransactionID != 0 {
		i = encodeVarintApi(dAtA, i, uint64(m.TransactionID))
		i--
		dAtA[i] = 0x18
	}
	if len(m.ApplicationID) > 0 {
		i -= len(m.ApplicationID)
		copy(dAtA[i:], m.ApplicationID)
		i = encodeVarintApi(dAtA, i, uint64(len(m.ApplicationID)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.XID) > 0 {
		i -= len(m.XID)
		copy(dAtA[i:], m.XID)
		i = encodeVarintApi(dAtA, i, uint64(len(m.XID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *BranchSession) 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 *BranchSession) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BranchSession) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.BeginTime != 0 {
		i = encodeVarintApi(dAtA, i, uint64(m.BeginTime))
		i--
		dAtA[i] = 0x58
	}
	if len(m.ApplicationData) > 0 {
		i -= len(m.ApplicationData)
		copy(dAtA[i:], m.ApplicationData)
		i = encodeVarintApi(dAtA, i, uint64(len(m.ApplicationData)))
		i--
		dAtA[i] = 0x52
	}
	if m.Status != 0 {
		i = encodeVarintApi(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x48
	}
	if m.Type != 0 {
		i = encodeVarintApi(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x40
	}
	if len(m.LockKey) > 0 {
		i -= len(m.LockKey)
		copy(dAtA[i:], m.LockKey)
		i = encodeVarintApi(dAtA, i, uint64(len(m.LockKey)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.ResourceID) > 0 {
		i -= len(m.ResourceID)
		copy(dAtA[i:], m.ResourceID)
		i = encodeVarintApi(dAtA, i, uint64(len(m.ResourceID)))
		i--
		dAtA[i] = 0x32
	}
	if m.TransactionID != 0 {
		i = encodeVarintApi(dAtA, i, uint64(m.TransactionID))
		i--
		dAtA[i] = 0x28
	}
	if len(m.XID) > 0 {
		i -= len(m.XID)
		copy(dAtA[i:], m.XID)
		i = encodeVarintApi(dAtA, i, uint64(len(m.XID)))
		i--
		dAtA[i] = 0x22
	}
	if m.BranchSessionID != 0 {
		i = encodeVarintApi(dAtA, i, uint64(m.BranchSessionID))
		i--
		dAtA[i] = 0x18
	}
	if len(m.ApplicationID) > 0 {
		i -= len(m.ApplicationID)
		copy(dAtA[i:], m.ApplicationID)
		i = encodeVarintApi(dAtA, i, uint64(len(m.ApplicationID)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.BranchID) > 0 {
		i -= len(m.BranchID)
		copy(dAtA[i:], m.BranchID)
		i = encodeVarintApi(dAtA, i, uint64(len(m.BranchID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *GlobalBeginRequest) 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 *GlobalBeginRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GlobalBeginRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.TransactionName) > 0 {
		i -= len(m.TransactionName)
		copy(dAtA[i:], m.TransactionName)
		i = encodeVarintApi(dAtA, i, uint64(len(m.TransactionName)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Timeout != 0 {
		i = encodeVarintApi(dAtA, i, uint64(m.Timeout))
		i--
		dAtA[i] = 0x10
	}
	if len(m.ApplicationID) > 0 {
		i -= len(m.ApplicationID)
		copy(dAtA[i:], m.ApplicationID)
		i = encodeVarintApi(dAtA, i, uint64(len(m.ApplicationID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *GlobalBeginResponse) 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 *GlobalBeginResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GlobalBeginResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.XID) > 0 {
		i -= len(m.XID)
		copy(dAtA[i:], m.XID)
		i = encodeVarintApi(dAtA, i, uint64(len(m.XID)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Message) > 0 {
		i -= len(m.Message)
		copy(dAtA[i:], m.Message)
		i = encodeVarintApi(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0x12
	}
	if m.ResultCode != 0 {
		i = encodeVarintApi(dAtA, i, uint64(m.ResultCode))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *BranchRegisterRequest) 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 *BranchRegisterRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BranchRegisterRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ApplicationData) > 0 {
		i -= len(m.ApplicationData)
		copy(dAtA[i:], m.ApplicationData)
		i = encodeVarintApi(dAtA, i, uint64(len(m.ApplicationData)))
		i--
		dAtA[i] = 0x2a
	}
	if m.BranchType != 0 {
		i = encodeVarintApi(dAtA, i, uint64(m.BranchType))
		i--
		dAtA[i] = 0x20
	}
	if len(m.LockKey) > 0 {
		i -= len(m.LockKey)
		copy(dAtA[i:], m.LockKey)
		i = encodeVarintApi(dAtA, i, uint64(len(m.LockKey)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.ResourceID) > 0 {
		i -= len(m.ResourceID)
		copy(dAtA[i:], m.ResourceID)
		i = encodeVarintApi(dAtA, i, uint64(len(m.ResourceID)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.XID) > 0 {
		i -= len(m.XID)
		copy(dAtA[i:], m.XID)
		i = encodeVarintApi(dAtA, i, uint64(len(m.XID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *BranchRegisterResponse) 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 *BranchRegisterResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BranchRegisterResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.BranchSessionID != 0 {
		i = encodeVarintApi(dAtA, i, uint64(m.BranchSessionID))
		i--
		dAtA[i] = 0x20
	}
	if len(m.BranchID) > 0 {
		i -= len(m.BranchID)
		copy(dAtA[i:], m.BranchID)
		i = encodeVarintApi(dAtA, i, uint64(len(m.BranchID)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Message) > 0 {
		i -= len(m.Message)
		copy(dAtA[i:], m.Message)
		i = encodeVarintApi(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0x12
	}
	if m.ResultCode != 0 {
		i = encodeVarintApi(dAtA, i, uint64(m.ResultCode))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *BranchReportRequest) 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 *BranchReportRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *BranchReportResponse) 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 *BranchReportResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BranchReportResponse) 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 = encodeVarintApi(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0x12
	}
	if m.ResultCode != 0 {
		i = encodeVarintApi(dAtA, i, uint64(m.ResultCode))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *GlobalLockQueryRequest) 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 *GlobalLockQueryRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *GlobalLockQueryResponse) 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 *GlobalLockQueryResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *GlobalStatusRequest) 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 *GlobalStatusRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *GlobalStatusResponse) 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 *GlobalStatusResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GlobalStatusResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.GlobalStatus != 0 {
		i = encodeVarintApi(dAtA, i, uint64(m.GlobalStatus))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Message) > 0 {
		i -= len(m.Message)
		copy(dAtA[i:], m.Message)
		i = encodeVarintApi(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0x12
	}
	if m.ResultCode != 0 {
		i = encodeVarintApi(dAtA, i, uint64(m.ResultCode))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *GlobalCommitRequest) 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 *GlobalCommitRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *GlobalCommitResponse) 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 *GlobalCommitResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GlobalCommitResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.GlobalStatus != 0 {
		i = encodeVarintApi(dAtA, i, uint64(m.GlobalStatus))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Message) > 0 {
		i -= len(m.Message)
		copy(dAtA[i:], m.Message)
		i = encodeVarintApi(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0x12
	}
	if m.ResultCode != 0 {
		i = encodeVarintApi(dAtA, i, uint64(m.ResultCode))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *GlobalRollbackRequest) 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 *GlobalRollbackRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *GlobalRollbackResponse) 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 *GlobalRollbackResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GlobalRollbackResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.GlobalStatus != 0 {
		i = encodeVarintApi(dAtA, i, uint64(m.GlobalStatus))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Message) > 0 {
		i -= len(m.Message)
		copy(dAtA[i:], m.Message)
		i = encodeVarintApi(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0x12
	}
	if m.ResultCode != 0 {
		i = encodeVarintApi(dAtA, i, uint64(m.ResultCode))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *GlobalReportRequest) 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 *GlobalReportRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *GlobalReportResponse) 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 *GlobalReportResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GlobalReportResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.GlobalStatus != 0 {
		i = encodeVarintApi(dAtA, i, uint64(m.GlobalStatus))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Message) > 0 {
		i -= len(m.Message)
		copy(dAtA[i:], m.Message)
		i = encodeVarintApi(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0x12
	}
	if m.ResultCode != 0 {
		i = encodeVarintApi(dAtA, i, uint64(m.ResultCode))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func encodeVarintApi(dAtA []byte, offset int, v uint64) int {
	offset -= sovApi(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *GlobalSession) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.XID)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	l = len(m.ApplicationID)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.TransactionID != 0 {
		n += 1 + sovApi(uint64(m.TransactionID))
	}
	l = len(m.TransactionName)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.Timeout != 0 {
		n += 1 + sovApi(uint64(m.Timeout))
	}
	if m.BeginTime != 0 {
		n += 1 + sovApi(uint64(m.BeginTime))
	}
	if m.Status != 0 {
		n += 1 + sovApi(uint64(m.Status))
	}
	return n
}

func (m *BranchSession) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.BranchID)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	l = len(m.ApplicationID)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.BranchSessionID != 0 {
		n += 1 + sovApi(uint64(m.BranchSessionID))
	}
	l = len(m.XID)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.TransactionID != 0 {
		n += 1 + sovApi(uint64(m.TransactionID))
	}
	l = len(m.ResourceID)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	l = len(m.LockKey)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovApi(uint64(m.Type))
	}
	if m.Status != 0 {
		n += 1 + sovApi(uint64(m.Status))
	}
	l = len(m.ApplicationData)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.BeginTime != 0 {
		n += 1 + sovApi(uint64(m.BeginTime))
	}
	return n
}

func (m *GlobalBeginRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ApplicationID)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.Timeout != 0 {
		n += 1 + sovApi(uint64(m.Timeout))
	}
	l = len(m.TransactionName)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	return n
}

func (m *GlobalBeginResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ResultCode != 0 {
		n += 1 + sovApi(uint64(m.ResultCode))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	l = len(m.XID)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	return n
}

func (m *BranchRegisterRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.XID)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	l = len(m.ResourceID)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	l = len(m.LockKey)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.BranchType != 0 {
		n += 1 + sovApi(uint64(m.BranchType))
	}
	l = len(m.ApplicationData)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	return n
}

func (m *BranchRegisterResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ResultCode != 0 {
		n += 1 + sovApi(uint64(m.ResultCode))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	l = len(m.BranchID)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.BranchSessionID != 0 {
		n += 1 + sovApi(uint64(m.BranchSessionID))
	}
	return n
}

func (m *BranchReportRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.BranchID)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.BranchStatus != 0 {
		n += 1 + sovApi(uint64(m.BranchStatus))
	}
	return n
}

func (m *BranchReportResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ResultCode != 0 {
		n += 1 + sovApi(uint64(m.ResultCode))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	return n
}

func (m *GlobalLockQueryRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ResourceID)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	l = len(m.LockKey)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	return n
}

func (m *GlobalLockQueryResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ResultCode != 0 {
		n += 1 + sovApi(uint64(m.ResultCode))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.Lockable {
		n += 2
	}
	return n
}

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

func (m *GlobalStatusResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ResultCode != 0 {
		n += 1 + sovApi(uint64(m.ResultCode))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.GlobalStatus != 0 {
		n += 1 + sovApi(uint64(m.GlobalStatus))
	}
	return n
}

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

func (m *GlobalCommitResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ResultCode != 0 {
		n += 1 + sovApi(uint64(m.ResultCode))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.GlobalStatus != 0 {
		n += 1 + sovApi(uint64(m.GlobalStatus))
	}
	return n
}

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

func (m *GlobalRollbackResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ResultCode != 0 {
		n += 1 + sovApi(uint64(m.ResultCode))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.GlobalStatus != 0 {
		n += 1 + sovApi(uint64(m.GlobalStatus))
	}
	return n
}

func (m *GlobalReportRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.XID)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.GlobalStatus != 0 {
		n += 1 + sovApi(uint64(m.GlobalStatus))
	}
	return n
}

func (m *GlobalReportResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ResultCode != 0 {
		n += 1 + sovApi(uint64(m.ResultCode))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.GlobalStatus != 0 {
		n += 1 + sovApi(uint64(m.GlobalStatus))
	}
	return n
}

func sovApi(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozApi(x uint64) (n int) {
	return sovApi(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *GlobalSession) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GlobalSession{`,
		`XID:` + fmt.Sprintf("%v", this.XID) + `,`,
		`ApplicationID:` + fmt.Sprintf("%v", this.ApplicationID) + `,`,
		`TransactionID:` + fmt.Sprintf("%v", this.TransactionID) + `,`,
		`TransactionName:` + fmt.Sprintf("%v", this.TransactionName) + `,`,
		`Timeout:` + fmt.Sprintf("%v", this.Timeout) + `,`,
		`BeginTime:` + fmt.Sprintf("%v", this.BeginTime) + `,`,
		`Status:` + fmt.Sprintf("%v", this.Status) + `,`,
		`}`,
	}, "")
	return s
}
func (this *BranchSession) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&BranchSession{`,
		`BranchID:` + fmt.Sprintf("%v", this.BranchID) + `,`,
		`ApplicationID:` + fmt.Sprintf("%v", this.ApplicationID) + `,`,
		`BranchSessionID:` + fmt.Sprintf("%v", this.BranchSessionID) + `,`,
		`XID:` + fmt.Sprintf("%v", this.XID) + `,`,
		`TransactionID:` + fmt.Sprintf("%v", this.TransactionID) + `,`,
		`ResourceID:` + fmt.Sprintf("%v", this.ResourceID) + `,`,
		`LockKey:` + fmt.Sprintf("%v", this.LockKey) + `,`,
		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
		`Status:` + fmt.Sprintf("%v", this.Status) + `,`,
		`ApplicationData:` + fmt.Sprintf("%v", this.ApplicationData) + `,`,
		`BeginTime:` + fmt.Sprintf("%v", this.BeginTime) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GlobalBeginRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GlobalBeginRequest{`,
		`ApplicationID:` + fmt.Sprintf("%v", this.ApplicationID) + `,`,
		`Timeout:` + fmt.Sprintf("%v", this.Timeout) + `,`,
		`TransactionName:` + fmt.Sprintf("%v", this.TransactionName) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GlobalBeginResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GlobalBeginResponse{`,
		`ResultCode:` + fmt.Sprintf("%v", this.ResultCode) + `,`,
		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
		`XID:` + fmt.Sprintf("%v", this.XID) + `,`,
		`}`,
	}, "")
	return s
}
func (this *BranchRegisterRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&BranchRegisterRequest{`,
		`XID:` + fmt.Sprintf("%v", this.XID) + `,`,
		`ResourceID:` + fmt.Sprintf("%v", this.ResourceID) + `,`,
		`LockKey:` + fmt.Sprintf("%v", this.LockKey) + `,`,
		`BranchType:` + fmt.Sprintf("%v", this.BranchType) + `,`,
		`ApplicationData:` + fmt.Sprintf("%v", this.ApplicationData) + `,`,
		`}`,
	}, "")
	return s
}
func (this *BranchRegisterResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&BranchRegisterResponse{`,
		`ResultCode:` + fmt.Sprintf("%v", this.ResultCode) + `,`,
		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
		`BranchID:` + fmt.Sprintf("%v", this.BranchID) + `,`,
		`BranchSessionID:` + fmt.Sprintf("%v", this.BranchSessionID) + `,`,
		`}`,
	}, "")
	return s
}
func (this *BranchReportRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&BranchReportRequest{`,
		`BranchID:` + fmt.Sprintf("%v", this.BranchID) + `,`,
		`BranchStatus:` + fmt.Sprintf("%v", this.BranchStatus) + `,`,
		`}`,
	}, "")
	return s
}
func (this *BranchReportResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&BranchReportResponse{`,
		`ResultCode:` + fmt.Sprintf("%v", this.ResultCode) + `,`,
		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GlobalLockQueryRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GlobalLockQueryRequest{`,
		`ResourceID:` + fmt.Sprintf("%v", this.ResourceID) + `,`,
		`LockKey:` + fmt.Sprintf("%v", this.LockKey) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GlobalLockQueryResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GlobalLockQueryResponse{`,
		`ResultCode:` + fmt.Sprintf("%v", this.ResultCode) + `,`,
		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
		`Lockable:` + fmt.Sprintf("%v", this.Lockable) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GlobalStatusRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GlobalStatusRequest{`,
		`XID:` + fmt.Sprintf("%v", this.XID) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GlobalStatusResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GlobalStatusResponse{`,
		`ResultCode:` + fmt.Sprintf("%v", this.ResultCode) + `,`,
		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
		`GlobalStatus:` + fmt.Sprintf("%v", this.GlobalStatus) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GlobalCommitRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GlobalCommitRequest{`,
		`XID:` + fmt.Sprintf("%v", this.XID) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GlobalCommitResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GlobalCommitResponse{`,
		`ResultCode:` + fmt.Sprintf("%v", this.ResultCode) + `,`,
		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
		`GlobalStatus:` + fmt.Sprintf("%v", this.GlobalStatus) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GlobalRollbackRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GlobalRollbackRequest{`,
		`XID:` + fmt.Sprintf("%v", this.XID) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GlobalRollbackResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GlobalRollbackResponse{`,
		`ResultCode:` + fmt.Sprintf("%v", this.ResultCode) + `,`,
		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
		`GlobalStatus:` + fmt.Sprintf("%v", this.GlobalStatus) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GlobalReportRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GlobalReportRequest{`,
		`XID:` + fmt.Sprintf("%v", this.XID) + `,`,
		`GlobalStatus:` + fmt.Sprintf("%v", this.GlobalStatus) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GlobalReportResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GlobalReportResponse{`,
		`ResultCode:` + fmt.Sprintf("%v", this.ResultCode) + `,`,
		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
		`GlobalStatus:` + fmt.Sprintf("%v", this.GlobalStatus) + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringApi(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *GlobalSession) 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 ErrIntOverflowApi
			}
			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: GlobalSession: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GlobalSession: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field XID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				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 ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.XID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ApplicationID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				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 ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ApplicationID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TransactionID", wireType)
			}
			m.TransactionID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TransactionID |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TransactionName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				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 ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TransactionName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timeout", wireType)
			}
			m.Timeout = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Timeout |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BeginTime", wireType)
			}
			m.BeginTime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BeginTime |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= GlobalSession_GlobalStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BranchSession) 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 ErrIntOverflowApi
			}
			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: BranchSession: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BranchSession: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BranchID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				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 ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BranchID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ApplicationID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				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 ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ApplicationID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BranchSessionID", wireType)
			}
			m.BranchSessionID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BranchSessionID |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field XID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				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 ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.XID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TransactionID", wireType)
			}
			m.TransactionID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TransactionID |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResourceID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				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 ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ResourceID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LockKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				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 ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LockKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= BranchSession_BranchType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= BranchSession_BranchStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ApplicationData", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthApi
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthApi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ApplicationData = append(m.ApplicationData[:0], dAtA[iNdEx:postIndex]...)
			if m.ApplicationData == nil {
				m.ApplicationData = []byte{}
			}
			iNdEx = postIndex
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BeginTime", wireType)
			}
			m.BeginTime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BeginTime |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GlobalBeginRequest) 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 ErrIntOverflowApi
			}
			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: GlobalBeginRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GlobalBeginRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ApplicationID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				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 ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ApplicationID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timeout", wireType)
			}
			m.Timeout = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Timeout |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TransactionName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				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 ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TransactionName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GlobalBeginResponse) 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 ErrIntOverflowApi
			}
			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: GlobalBeginResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GlobalBeginResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResultCode", wireType)
			}
			m.ResultCode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ResultCode |= ResultCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 ErrIntOverflowApi
				}
				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 ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field XID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				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 ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.XID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BranchRegisterRequest) 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 ErrIntOverflowApi
			}
			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: BranchRegisterRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BranchRegisterRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field XID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				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 ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.XID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResourceID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				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 ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ResourceID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LockKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				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 ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LockKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BranchType", wireType)
			}
			m.BranchType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BranchType |= BranchSession_BranchType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ApplicationData", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthApi
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthApi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ApplicationData = append(m.ApplicationData[:0], dAtA[iNdEx:postIndex]...)
			if m.ApplicationData == nil {
				m.ApplicationData = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BranchRegisterResponse) 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 ErrIntOverflowApi
			}
			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: BranchRegisterResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BranchRegisterResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResultCode", wireType)
			}
			m.ResultCode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ResultCode |= ResultCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 ErrIntOverflowApi
				}
				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 ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApi
			}
			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 BranchID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				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 ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BranchID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BranchSessionID", wireType)
			}
			m.BranchSessionID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BranchSessionID |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BranchReportRequest) 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 ErrIntOverflowApi
			}
			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: BranchReportRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BranchReportRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BranchID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				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 ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BranchID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BranchStatus", wireType)
			}
			m.BranchStatus = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BranchStatus |= BranchSession_BranchStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BranchReportResponse) 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 ErrIntOverflowApi
			}
			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: BranchReportResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BranchReportResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResultCode", wireType)
			}
			m.ResultCode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ResultCode |= ResultCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 ErrIntOverflowApi
				}
				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 ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GlobalLockQueryRequest) 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 ErrIntOverflowApi
			}
			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: GlobalLockQueryRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GlobalLockQueryRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResourceID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				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 ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ResourceID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LockKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				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 ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LockKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GlobalLockQueryResponse) 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 ErrIntOverflowApi
			}
			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: GlobalLockQueryResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GlobalLockQueryResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResultCode", wireType)
			}
			m.ResultCode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ResultCode |= ResultCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 ErrIntOverflowApi
				}
				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 ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Lockable", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Lockable = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GlobalStatusRequest) 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 ErrIntOverflowApi
			}
			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: GlobalStatusRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GlobalStatusRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field XID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				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 ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.XID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GlobalStatusResponse) 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 ErrIntOverflowApi
			}
			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: GlobalStatusResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GlobalStatusResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResultCode", wireType)
			}
			m.ResultCode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ResultCode |= ResultCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 ErrIntOverflowApi
				}
				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 ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GlobalStatus", wireType)
			}
			m.GlobalStatus = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GlobalStatus |= GlobalSession_GlobalStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GlobalCommitRequest) 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 ErrIntOverflowApi
			}
			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: GlobalCommitRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GlobalCommitRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field XID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				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 ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.XID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GlobalCommitResponse) 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 ErrIntOverflowApi
			}
			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: GlobalCommitResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GlobalCommitResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResultCode", wireType)
			}
			m.ResultCode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ResultCode |= ResultCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 ErrIntOverflowApi
				}
				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 ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GlobalStatus", wireType)
			}
			m.GlobalStatus = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GlobalStatus |= GlobalSession_GlobalStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GlobalRollbackRequest) 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 ErrIntOverflowApi
			}
			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: GlobalRollbackRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GlobalRollbackRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field XID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				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 ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.XID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GlobalRollbackResponse) 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 ErrIntOverflowApi
			}
			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: GlobalRollbackResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GlobalRollbackResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResultCode", wireType)
			}
			m.ResultCode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ResultCode |= ResultCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 ErrIntOverflowApi
				}
				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 ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GlobalStatus", wireType)
			}
			m.GlobalStatus = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GlobalStatus |= GlobalSession_GlobalStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GlobalReportRequest) 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 ErrIntOverflowApi
			}
			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: GlobalReportRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GlobalReportRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field XID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				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 ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.XID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GlobalStatus", wireType)
			}
			m.GlobalStatus = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GlobalStatus |= GlobalSession_GlobalStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GlobalReportResponse) 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 ErrIntOverflowApi
			}
			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: GlobalReportResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GlobalReportResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResultCode", wireType)
			}
			m.ResultCode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ResultCode |= ResultCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 ErrIntOverflowApi
				}
				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 ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GlobalStatus", wireType)
			}
			m.GlobalStatus = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GlobalStatus |= GlobalSession_GlobalStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipApi(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, ErrIntOverflowApi
			}
			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, ErrIntOverflowApi
				}
				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, ErrIntOverflowApi
				}
				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, ErrInvalidLengthApi
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupApi
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthApi
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthApi        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowApi          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupApi = fmt.Errorf("proto: unexpected end of group")
)
