// Autogenerated by Thrift Compiler (0.9.2)
// DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING

package crmservice

import (
	"bytes"
	"fmt"
	"github.com/apache/thrift/lib/go/thrift"
)

// (needed to ensure safety because of naive import list construction.)
var _ = thrift.ZERO
var _ = fmt.Printf
var _ = bytes.Equal

var GoUnusedProtection__ int

type PhotoList []string

func PhotoListPtr(v PhotoList) *PhotoList { return &v }

type CustomerList []*Customer

func CustomerListPtr(v CustomerList) *CustomerList { return &v }

type CSRInfoList []*CSRInfo

func CSRInfoListPtr(v CSRInfoList) *CSRInfoList { return &v }

type MessageList []*Message

func MessageListPtr(v MessageList) *MessageList { return &v }

type UsernameList []string

func UsernameListPtr(v UsernameList) *UsernameList { return &v }

type Customer struct {
	Id       string  `thrift:"id,1" json:"id"`
	Username string  `thrift:"username,2" json:"username"`
	Name     string  `thrift:"name,3" json:"name"`
	CsrId    *int32  `thrift:"csrId,4" json:"csrId"`
	Memo     string  `thrift:"memo,5" json:"memo"`
	Status   int32   `thrift:"status,6" json:"status"`
	Level    int32   `thrift:"level,7" json:"level"`
	Priority int32   `thrift:"priority,8" json:"priority"`
	Avatar   *string `thrift:"avatar,9" json:"avatar"`
	ServerId int32   `thrift:"serverId,10" json:"serverId"`
}

func NewCustomer() *Customer {
	return &Customer{}
}

func (p *Customer) GetId() string {
	return p.Id
}

func (p *Customer) GetUsername() string {
	return p.Username
}

func (p *Customer) GetName() string {
	return p.Name
}

var Customer_CsrId_DEFAULT int32

func (p *Customer) GetCsrId() int32 {
	if !p.IsSetCsrId() {
		return Customer_CsrId_DEFAULT
	}
	return *p.CsrId
}

func (p *Customer) GetMemo() string {
	return p.Memo
}

func (p *Customer) GetStatus() int32 {
	return p.Status
}

func (p *Customer) GetLevel() int32 {
	return p.Level
}

func (p *Customer) GetPriority() int32 {
	return p.Priority
}

var Customer_Avatar_DEFAULT string

func (p *Customer) GetAvatar() string {
	if !p.IsSetAvatar() {
		return Customer_Avatar_DEFAULT
	}
	return *p.Avatar
}

func (p *Customer) GetServerId() int32 {
	return p.ServerId
}
func (p *Customer) IsSetCsrId() bool {
	return p.CsrId != nil
}

func (p *Customer) IsSetAvatar() bool {
	return p.Avatar != nil
}

func (p *Customer) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		case 3:
			if err := p.ReadField3(iprot); err != nil {
				return err
			}
		case 4:
			if err := p.ReadField4(iprot); err != nil {
				return err
			}
		case 5:
			if err := p.ReadField5(iprot); err != nil {
				return err
			}
		case 6:
			if err := p.ReadField6(iprot); err != nil {
				return err
			}
		case 7:
			if err := p.ReadField7(iprot); err != nil {
				return err
			}
		case 8:
			if err := p.ReadField8(iprot); err != nil {
				return err
			}
		case 9:
			if err := p.ReadField9(iprot); err != nil {
				return err
			}
		case 10:
			if err := p.ReadField10(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *Customer) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 1: %s", err)
	} else {
		p.Id = v
	}
	return nil
}

func (p *Customer) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 2: %s", err)
	} else {
		p.Username = v
	}
	return nil
}

func (p *Customer) ReadField3(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 3: %s", err)
	} else {
		p.Name = v
	}
	return nil
}

func (p *Customer) ReadField4(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 4: %s", err)
	} else {
		p.CsrId = &v
	}
	return nil
}

func (p *Customer) ReadField5(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 5: %s", err)
	} else {
		p.Memo = v
	}
	return nil
}

func (p *Customer) ReadField6(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 6: %s", err)
	} else {
		p.Status = v
	}
	return nil
}

func (p *Customer) ReadField7(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 7: %s", err)
	} else {
		p.Level = v
	}
	return nil
}

func (p *Customer) ReadField8(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 8: %s", err)
	} else {
		p.Priority = v
	}
	return nil
}

func (p *Customer) ReadField9(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 9: %s", err)
	} else {
		p.Avatar = &v
	}
	return nil
}

func (p *Customer) ReadField10(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 10: %s", err)
	} else {
		p.ServerId = v
	}
	return nil
}

func (p *Customer) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("Customer"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := p.writeField3(oprot); err != nil {
		return err
	}
	if err := p.writeField4(oprot); err != nil {
		return err
	}
	if err := p.writeField5(oprot); err != nil {
		return err
	}
	if err := p.writeField6(oprot); err != nil {
		return err
	}
	if err := p.writeField7(oprot); err != nil {
		return err
	}
	if err := p.writeField8(oprot); err != nil {
		return err
	}
	if err := p.writeField9(oprot); err != nil {
		return err
	}
	if err := p.writeField10(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *Customer) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("id", thrift.STRING, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:id: %s", p, err)
	}
	if err := oprot.WriteString(string(p.Id)); err != nil {
		return fmt.Errorf("%T.id (1) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:id: %s", p, err)
	}
	return err
}

func (p *Customer) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("username", thrift.STRING, 2); err != nil {
		return fmt.Errorf("%T write field begin error 2:username: %s", p, err)
	}
	if err := oprot.WriteString(string(p.Username)); err != nil {
		return fmt.Errorf("%T.username (2) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 2:username: %s", p, err)
	}
	return err
}

func (p *Customer) writeField3(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("name", thrift.STRING, 3); err != nil {
		return fmt.Errorf("%T write field begin error 3:name: %s", p, err)
	}
	if err := oprot.WriteString(string(p.Name)); err != nil {
		return fmt.Errorf("%T.name (3) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 3:name: %s", p, err)
	}
	return err
}

func (p *Customer) writeField4(oprot thrift.TProtocol) (err error) {
	if p.IsSetCsrId() {
		if err := oprot.WriteFieldBegin("csrId", thrift.I32, 4); err != nil {
			return fmt.Errorf("%T write field begin error 4:csrId: %s", p, err)
		}
		if err := oprot.WriteI32(int32(*p.CsrId)); err != nil {
			return fmt.Errorf("%T.csrId (4) field write error: %s", p, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 4:csrId: %s", p, err)
		}
	}
	return err
}

func (p *Customer) writeField5(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("memo", thrift.STRING, 5); err != nil {
		return fmt.Errorf("%T write field begin error 5:memo: %s", p, err)
	}
	if err := oprot.WriteString(string(p.Memo)); err != nil {
		return fmt.Errorf("%T.memo (5) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 5:memo: %s", p, err)
	}
	return err
}

func (p *Customer) writeField6(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("status", thrift.I32, 6); err != nil {
		return fmt.Errorf("%T write field begin error 6:status: %s", p, err)
	}
	if err := oprot.WriteI32(int32(p.Status)); err != nil {
		return fmt.Errorf("%T.status (6) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 6:status: %s", p, err)
	}
	return err
}

func (p *Customer) writeField7(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("level", thrift.I32, 7); err != nil {
		return fmt.Errorf("%T write field begin error 7:level: %s", p, err)
	}
	if err := oprot.WriteI32(int32(p.Level)); err != nil {
		return fmt.Errorf("%T.level (7) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 7:level: %s", p, err)
	}
	return err
}

func (p *Customer) writeField8(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("priority", thrift.I32, 8); err != nil {
		return fmt.Errorf("%T write field begin error 8:priority: %s", p, err)
	}
	if err := oprot.WriteI32(int32(p.Priority)); err != nil {
		return fmt.Errorf("%T.priority (8) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 8:priority: %s", p, err)
	}
	return err
}

func (p *Customer) writeField9(oprot thrift.TProtocol) (err error) {
	if p.IsSetAvatar() {
		if err := oprot.WriteFieldBegin("avatar", thrift.STRING, 9); err != nil {
			return fmt.Errorf("%T write field begin error 9:avatar: %s", p, err)
		}
		if err := oprot.WriteString(string(*p.Avatar)); err != nil {
			return fmt.Errorf("%T.avatar (9) field write error: %s", p, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 9:avatar: %s", p, err)
		}
	}
	return err
}

func (p *Customer) writeField10(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("serverId", thrift.I32, 10); err != nil {
		return fmt.Errorf("%T write field begin error 10:serverId: %s", p, err)
	}
	if err := oprot.WriteI32(int32(p.ServerId)); err != nil {
		return fmt.Errorf("%T.serverId (10) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 10:serverId: %s", p, err)
	}
	return err
}

func (p *Customer) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("Customer(%+v)", *p)
}

type CSRInfo struct {
	Id          int32     `thrift:"id,1" json:"id"`
	JobNumber   string    `thrift:"jobNumber,2" json:"jobNumber"`
	Name        string    `thrift:"name,3" json:"name"`
	Memo        string    `thrift:"memo,4" json:"memo"`
	Maxim       string    `thrift:"maxim,5" json:"maxim"`
	Avatar      *string   `thrift:"avatar,6" json:"avatar"`
	PhotoList   PhotoList `thrift:"photoList,7" json:"photoList"`
	CrmStatus   int32     `thrift:"crm_status,8" json:"crm_status"`
	Role        int32     `thrift:"role,9" json:"role"`
	Department  string    `thrift:"department,10" json:"department"`
	Group       *string   `thrift:"group,11" json:"group"`
	Level       int32     `thrift:"level,12" json:"level"`
	IsRecommend bool      `thrift:"isRecommend,13" json:"isRecommend"`
}

func NewCSRInfo() *CSRInfo {
	return &CSRInfo{}
}

func (p *CSRInfo) GetId() int32 {
	return p.Id
}

func (p *CSRInfo) GetJobNumber() string {
	return p.JobNumber
}

func (p *CSRInfo) GetName() string {
	return p.Name
}

func (p *CSRInfo) GetMemo() string {
	return p.Memo
}

func (p *CSRInfo) GetMaxim() string {
	return p.Maxim
}

var CSRInfo_Avatar_DEFAULT string

func (p *CSRInfo) GetAvatar() string {
	if !p.IsSetAvatar() {
		return CSRInfo_Avatar_DEFAULT
	}
	return *p.Avatar
}

func (p *CSRInfo) GetPhotoList() PhotoList {
	return p.PhotoList
}

func (p *CSRInfo) GetCrmStatus() int32 {
	return p.CrmStatus
}

func (p *CSRInfo) GetRole() int32 {
	return p.Role
}

func (p *CSRInfo) GetDepartment() string {
	return p.Department
}

var CSRInfo_Group_DEFAULT string

func (p *CSRInfo) GetGroup() string {
	if !p.IsSetGroup() {
		return CSRInfo_Group_DEFAULT
	}
	return *p.Group
}

func (p *CSRInfo) GetLevel() int32 {
	return p.Level
}

func (p *CSRInfo) GetIsRecommend() bool {
	return p.IsRecommend
}
func (p *CSRInfo) IsSetAvatar() bool {
	return p.Avatar != nil
}

func (p *CSRInfo) IsSetGroup() bool {
	return p.Group != nil
}

func (p *CSRInfo) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		case 3:
			if err := p.ReadField3(iprot); err != nil {
				return err
			}
		case 4:
			if err := p.ReadField4(iprot); err != nil {
				return err
			}
		case 5:
			if err := p.ReadField5(iprot); err != nil {
				return err
			}
		case 6:
			if err := p.ReadField6(iprot); err != nil {
				return err
			}
		case 7:
			if err := p.ReadField7(iprot); err != nil {
				return err
			}
		case 8:
			if err := p.ReadField8(iprot); err != nil {
				return err
			}
		case 9:
			if err := p.ReadField9(iprot); err != nil {
				return err
			}
		case 10:
			if err := p.ReadField10(iprot); err != nil {
				return err
			}
		case 11:
			if err := p.ReadField11(iprot); err != nil {
				return err
			}
		case 12:
			if err := p.ReadField12(iprot); err != nil {
				return err
			}
		case 13:
			if err := p.ReadField13(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *CSRInfo) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 1: %s", err)
	} else {
		p.Id = v
	}
	return nil
}

func (p *CSRInfo) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 2: %s", err)
	} else {
		p.JobNumber = v
	}
	return nil
}

func (p *CSRInfo) ReadField3(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 3: %s", err)
	} else {
		p.Name = v
	}
	return nil
}

func (p *CSRInfo) ReadField4(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 4: %s", err)
	} else {
		p.Memo = v
	}
	return nil
}

func (p *CSRInfo) ReadField5(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 5: %s", err)
	} else {
		p.Maxim = v
	}
	return nil
}

func (p *CSRInfo) ReadField6(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 6: %s", err)
	} else {
		p.Avatar = &v
	}
	return nil
}

func (p *CSRInfo) ReadField7(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return fmt.Errorf("error reading list begin: %s", err)
	}
	tSlice := make(PhotoList, 0, size)
	p.PhotoList = tSlice
	for i := 0; i < size; i++ {
		var _elem0 string
		if v, err := iprot.ReadString(); err != nil {
			return fmt.Errorf("error reading field 0: %s", err)
		} else {
			_elem0 = v
		}
		p.PhotoList = append(p.PhotoList, _elem0)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return fmt.Errorf("error reading list end: %s", err)
	}
	return nil
}

func (p *CSRInfo) ReadField8(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 8: %s", err)
	} else {
		p.CrmStatus = v
	}
	return nil
}

func (p *CSRInfo) ReadField9(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 9: %s", err)
	} else {
		p.Role = v
	}
	return nil
}

func (p *CSRInfo) ReadField10(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 10: %s", err)
	} else {
		p.Department = v
	}
	return nil
}

func (p *CSRInfo) ReadField11(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 11: %s", err)
	} else {
		p.Group = &v
	}
	return nil
}

func (p *CSRInfo) ReadField12(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 12: %s", err)
	} else {
		p.Level = v
	}
	return nil
}

func (p *CSRInfo) ReadField13(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBool(); err != nil {
		return fmt.Errorf("error reading field 13: %s", err)
	} else {
		p.IsRecommend = v
	}
	return nil
}

func (p *CSRInfo) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("CSRInfo"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := p.writeField3(oprot); err != nil {
		return err
	}
	if err := p.writeField4(oprot); err != nil {
		return err
	}
	if err := p.writeField5(oprot); err != nil {
		return err
	}
	if err := p.writeField6(oprot); err != nil {
		return err
	}
	if err := p.writeField7(oprot); err != nil {
		return err
	}
	if err := p.writeField8(oprot); err != nil {
		return err
	}
	if err := p.writeField9(oprot); err != nil {
		return err
	}
	if err := p.writeField10(oprot); err != nil {
		return err
	}
	if err := p.writeField11(oprot); err != nil {
		return err
	}
	if err := p.writeField12(oprot); err != nil {
		return err
	}
	if err := p.writeField13(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *CSRInfo) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("id", thrift.I32, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:id: %s", p, err)
	}
	if err := oprot.WriteI32(int32(p.Id)); err != nil {
		return fmt.Errorf("%T.id (1) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:id: %s", p, err)
	}
	return err
}

func (p *CSRInfo) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("jobNumber", thrift.STRING, 2); err != nil {
		return fmt.Errorf("%T write field begin error 2:jobNumber: %s", p, err)
	}
	if err := oprot.WriteString(string(p.JobNumber)); err != nil {
		return fmt.Errorf("%T.jobNumber (2) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 2:jobNumber: %s", p, err)
	}
	return err
}

func (p *CSRInfo) writeField3(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("name", thrift.STRING, 3); err != nil {
		return fmt.Errorf("%T write field begin error 3:name: %s", p, err)
	}
	if err := oprot.WriteString(string(p.Name)); err != nil {
		return fmt.Errorf("%T.name (3) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 3:name: %s", p, err)
	}
	return err
}

func (p *CSRInfo) writeField4(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("memo", thrift.STRING, 4); err != nil {
		return fmt.Errorf("%T write field begin error 4:memo: %s", p, err)
	}
	if err := oprot.WriteString(string(p.Memo)); err != nil {
		return fmt.Errorf("%T.memo (4) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 4:memo: %s", p, err)
	}
	return err
}

func (p *CSRInfo) writeField5(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("maxim", thrift.STRING, 5); err != nil {
		return fmt.Errorf("%T write field begin error 5:maxim: %s", p, err)
	}
	if err := oprot.WriteString(string(p.Maxim)); err != nil {
		return fmt.Errorf("%T.maxim (5) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 5:maxim: %s", p, err)
	}
	return err
}

func (p *CSRInfo) writeField6(oprot thrift.TProtocol) (err error) {
	if p.IsSetAvatar() {
		if err := oprot.WriteFieldBegin("avatar", thrift.STRING, 6); err != nil {
			return fmt.Errorf("%T write field begin error 6:avatar: %s", p, err)
		}
		if err := oprot.WriteString(string(*p.Avatar)); err != nil {
			return fmt.Errorf("%T.avatar (6) field write error: %s", p, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 6:avatar: %s", p, err)
		}
	}
	return err
}

func (p *CSRInfo) writeField7(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("photoList", thrift.LIST, 7); err != nil {
		return fmt.Errorf("%T write field begin error 7:photoList: %s", p, err)
	}
	if err := oprot.WriteListBegin(thrift.STRING, len(p.PhotoList)); err != nil {
		return fmt.Errorf("error writing list begin: %s", err)
	}
	for _, v := range p.PhotoList {
		if err := oprot.WriteString(string(v)); err != nil {
			return fmt.Errorf("%T. (0) field write error: %s", p, err)
		}
	}
	if err := oprot.WriteListEnd(); err != nil {
		return fmt.Errorf("error writing list end: %s", err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 7:photoList: %s", p, err)
	}
	return err
}

func (p *CSRInfo) writeField8(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("crm_status", thrift.I32, 8); err != nil {
		return fmt.Errorf("%T write field begin error 8:crm_status: %s", p, err)
	}
	if err := oprot.WriteI32(int32(p.CrmStatus)); err != nil {
		return fmt.Errorf("%T.crm_status (8) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 8:crm_status: %s", p, err)
	}
	return err
}

func (p *CSRInfo) writeField9(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("role", thrift.I32, 9); err != nil {
		return fmt.Errorf("%T write field begin error 9:role: %s", p, err)
	}
	if err := oprot.WriteI32(int32(p.Role)); err != nil {
		return fmt.Errorf("%T.role (9) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 9:role: %s", p, err)
	}
	return err
}

func (p *CSRInfo) writeField10(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("department", thrift.STRING, 10); err != nil {
		return fmt.Errorf("%T write field begin error 10:department: %s", p, err)
	}
	if err := oprot.WriteString(string(p.Department)); err != nil {
		return fmt.Errorf("%T.department (10) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 10:department: %s", p, err)
	}
	return err
}

func (p *CSRInfo) writeField11(oprot thrift.TProtocol) (err error) {
	if p.IsSetGroup() {
		if err := oprot.WriteFieldBegin("group", thrift.STRING, 11); err != nil {
			return fmt.Errorf("%T write field begin error 11:group: %s", p, err)
		}
		if err := oprot.WriteString(string(*p.Group)); err != nil {
			return fmt.Errorf("%T.group (11) field write error: %s", p, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 11:group: %s", p, err)
		}
	}
	return err
}

func (p *CSRInfo) writeField12(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("level", thrift.I32, 12); err != nil {
		return fmt.Errorf("%T write field begin error 12:level: %s", p, err)
	}
	if err := oprot.WriteI32(int32(p.Level)); err != nil {
		return fmt.Errorf("%T.level (12) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 12:level: %s", p, err)
	}
	return err
}

func (p *CSRInfo) writeField13(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("isRecommend", thrift.BOOL, 13); err != nil {
		return fmt.Errorf("%T write field begin error 13:isRecommend: %s", p, err)
	}
	if err := oprot.WriteBool(bool(p.IsRecommend)); err != nil {
		return fmt.Errorf("%T.isRecommend (13) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 13:isRecommend: %s", p, err)
	}
	return err
}

func (p *CSRInfo) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("CSRInfo(%+v)", *p)
}

type CustomerDetail struct {
	Id     string `thrift:"id,1" json:"id"`
	Name   string `thrift:"name,2" json:"name"`
	Memo   string `thrift:"memo,3" json:"memo"`
	TypeA1 int32  `thrift:"type,4" json:"type"`
	Level  int32  `thrift:"level,5" json:"level"`
}

func NewCustomerDetail() *CustomerDetail {
	return &CustomerDetail{}
}

func (p *CustomerDetail) GetId() string {
	return p.Id
}

func (p *CustomerDetail) GetName() string {
	return p.Name
}

func (p *CustomerDetail) GetMemo() string {
	return p.Memo
}

func (p *CustomerDetail) GetTypeA1() int32 {
	return p.TypeA1
}

func (p *CustomerDetail) GetLevel() int32 {
	return p.Level
}
func (p *CustomerDetail) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		case 3:
			if err := p.ReadField3(iprot); err != nil {
				return err
			}
		case 4:
			if err := p.ReadField4(iprot); err != nil {
				return err
			}
		case 5:
			if err := p.ReadField5(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *CustomerDetail) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 1: %s", err)
	} else {
		p.Id = v
	}
	return nil
}

func (p *CustomerDetail) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 2: %s", err)
	} else {
		p.Name = v
	}
	return nil
}

func (p *CustomerDetail) ReadField3(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 3: %s", err)
	} else {
		p.Memo = v
	}
	return nil
}

func (p *CustomerDetail) ReadField4(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 4: %s", err)
	} else {
		p.TypeA1 = v
	}
	return nil
}

func (p *CustomerDetail) ReadField5(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 5: %s", err)
	} else {
		p.Level = v
	}
	return nil
}

func (p *CustomerDetail) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("CustomerDetail"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := p.writeField3(oprot); err != nil {
		return err
	}
	if err := p.writeField4(oprot); err != nil {
		return err
	}
	if err := p.writeField5(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *CustomerDetail) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("id", thrift.STRING, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:id: %s", p, err)
	}
	if err := oprot.WriteString(string(p.Id)); err != nil {
		return fmt.Errorf("%T.id (1) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:id: %s", p, err)
	}
	return err
}

func (p *CustomerDetail) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("name", thrift.STRING, 2); err != nil {
		return fmt.Errorf("%T write field begin error 2:name: %s", p, err)
	}
	if err := oprot.WriteString(string(p.Name)); err != nil {
		return fmt.Errorf("%T.name (2) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 2:name: %s", p, err)
	}
	return err
}

func (p *CustomerDetail) writeField3(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("memo", thrift.STRING, 3); err != nil {
		return fmt.Errorf("%T write field begin error 3:memo: %s", p, err)
	}
	if err := oprot.WriteString(string(p.Memo)); err != nil {
		return fmt.Errorf("%T.memo (3) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 3:memo: %s", p, err)
	}
	return err
}

func (p *CustomerDetail) writeField4(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("type", thrift.I32, 4); err != nil {
		return fmt.Errorf("%T write field begin error 4:type: %s", p, err)
	}
	if err := oprot.WriteI32(int32(p.TypeA1)); err != nil {
		return fmt.Errorf("%T.type (4) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 4:type: %s", p, err)
	}
	return err
}

func (p *CustomerDetail) writeField5(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("level", thrift.I32, 5); err != nil {
		return fmt.Errorf("%T write field begin error 5:level: %s", p, err)
	}
	if err := oprot.WriteI32(int32(p.Level)); err != nil {
		return fmt.Errorf("%T.level (5) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 5:level: %s", p, err)
	}
	return err
}

func (p *CustomerDetail) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("CustomerDetail(%+v)", *p)
}

type Message struct {
	Id       string `thrift:"id,1" json:"id"`
	TypeA1   int32  `thrift:"type,2" json:"type"`
	Datetime string `thrift:"datetime,3" json:"datetime"`
	Content  string `thrift:"content,4" json:"content"`
	FromId   string `thrift:"fromId,5" json:"fromId"`
	FromName string `thrift:"fromName,6" json:"fromName"`
	ToId     string `thrift:"toId,7" json:"toId"`
	ToName   string `thrift:"toName,8" json:"toName"`
	IsRead   bool   `thrift:"isRead,9" json:"isRead"`
}

func NewMessage() *Message {
	return &Message{}
}

func (p *Message) GetId() string {
	return p.Id
}

func (p *Message) GetTypeA1() int32 {
	return p.TypeA1
}

func (p *Message) GetDatetime() string {
	return p.Datetime
}

func (p *Message) GetContent() string {
	return p.Content
}

func (p *Message) GetFromId() string {
	return p.FromId
}

func (p *Message) GetFromName() string {
	return p.FromName
}

func (p *Message) GetToId() string {
	return p.ToId
}

func (p *Message) GetToName() string {
	return p.ToName
}

func (p *Message) GetIsRead() bool {
	return p.IsRead
}
func (p *Message) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		case 3:
			if err := p.ReadField3(iprot); err != nil {
				return err
			}
		case 4:
			if err := p.ReadField4(iprot); err != nil {
				return err
			}
		case 5:
			if err := p.ReadField5(iprot); err != nil {
				return err
			}
		case 6:
			if err := p.ReadField6(iprot); err != nil {
				return err
			}
		case 7:
			if err := p.ReadField7(iprot); err != nil {
				return err
			}
		case 8:
			if err := p.ReadField8(iprot); err != nil {
				return err
			}
		case 9:
			if err := p.ReadField9(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *Message) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 1: %s", err)
	} else {
		p.Id = v
	}
	return nil
}

func (p *Message) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 2: %s", err)
	} else {
		p.TypeA1 = v
	}
	return nil
}

func (p *Message) ReadField3(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 3: %s", err)
	} else {
		p.Datetime = v
	}
	return nil
}

func (p *Message) ReadField4(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 4: %s", err)
	} else {
		p.Content = v
	}
	return nil
}

func (p *Message) ReadField5(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 5: %s", err)
	} else {
		p.FromId = v
	}
	return nil
}

func (p *Message) ReadField6(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 6: %s", err)
	} else {
		p.FromName = v
	}
	return nil
}

func (p *Message) ReadField7(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 7: %s", err)
	} else {
		p.ToId = v
	}
	return nil
}

func (p *Message) ReadField8(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 8: %s", err)
	} else {
		p.ToName = v
	}
	return nil
}

func (p *Message) ReadField9(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBool(); err != nil {
		return fmt.Errorf("error reading field 9: %s", err)
	} else {
		p.IsRead = v
	}
	return nil
}

func (p *Message) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("Message"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := p.writeField3(oprot); err != nil {
		return err
	}
	if err := p.writeField4(oprot); err != nil {
		return err
	}
	if err := p.writeField5(oprot); err != nil {
		return err
	}
	if err := p.writeField6(oprot); err != nil {
		return err
	}
	if err := p.writeField7(oprot); err != nil {
		return err
	}
	if err := p.writeField8(oprot); err != nil {
		return err
	}
	if err := p.writeField9(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *Message) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("id", thrift.STRING, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:id: %s", p, err)
	}
	if err := oprot.WriteString(string(p.Id)); err != nil {
		return fmt.Errorf("%T.id (1) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:id: %s", p, err)
	}
	return err
}

func (p *Message) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("type", thrift.I32, 2); err != nil {
		return fmt.Errorf("%T write field begin error 2:type: %s", p, err)
	}
	if err := oprot.WriteI32(int32(p.TypeA1)); err != nil {
		return fmt.Errorf("%T.type (2) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 2:type: %s", p, err)
	}
	return err
}

func (p *Message) writeField3(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("datetime", thrift.STRING, 3); err != nil {
		return fmt.Errorf("%T write field begin error 3:datetime: %s", p, err)
	}
	if err := oprot.WriteString(string(p.Datetime)); err != nil {
		return fmt.Errorf("%T.datetime (3) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 3:datetime: %s", p, err)
	}
	return err
}

func (p *Message) writeField4(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("content", thrift.STRING, 4); err != nil {
		return fmt.Errorf("%T write field begin error 4:content: %s", p, err)
	}
	if err := oprot.WriteString(string(p.Content)); err != nil {
		return fmt.Errorf("%T.content (4) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 4:content: %s", p, err)
	}
	return err
}

func (p *Message) writeField5(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("fromId", thrift.STRING, 5); err != nil {
		return fmt.Errorf("%T write field begin error 5:fromId: %s", p, err)
	}
	if err := oprot.WriteString(string(p.FromId)); err != nil {
		return fmt.Errorf("%T.fromId (5) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 5:fromId: %s", p, err)
	}
	return err
}

func (p *Message) writeField6(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("fromName", thrift.STRING, 6); err != nil {
		return fmt.Errorf("%T write field begin error 6:fromName: %s", p, err)
	}
	if err := oprot.WriteString(string(p.FromName)); err != nil {
		return fmt.Errorf("%T.fromName (6) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 6:fromName: %s", p, err)
	}
	return err
}

func (p *Message) writeField7(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("toId", thrift.STRING, 7); err != nil {
		return fmt.Errorf("%T write field begin error 7:toId: %s", p, err)
	}
	if err := oprot.WriteString(string(p.ToId)); err != nil {
		return fmt.Errorf("%T.toId (7) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 7:toId: %s", p, err)
	}
	return err
}

func (p *Message) writeField8(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("toName", thrift.STRING, 8); err != nil {
		return fmt.Errorf("%T write field begin error 8:toName: %s", p, err)
	}
	if err := oprot.WriteString(string(p.ToName)); err != nil {
		return fmt.Errorf("%T.toName (8) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 8:toName: %s", p, err)
	}
	return err
}

func (p *Message) writeField9(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("isRead", thrift.BOOL, 9); err != nil {
		return fmt.Errorf("%T write field begin error 9:isRead: %s", p, err)
	}
	if err := oprot.WriteBool(bool(p.IsRead)); err != nil {
		return fmt.Errorf("%T.isRead (9) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 9:isRead: %s", p, err)
	}
	return err
}

func (p *Message) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("Message(%+v)", *p)
}

type CsrError struct {
	TypeA1  int32  `thrift:"type,1" json:"type"`
	Message string `thrift:"message,2" json:"message"`
}

func NewCsrError() *CsrError {
	return &CsrError{}
}

func (p *CsrError) GetTypeA1() int32 {
	return p.TypeA1
}

func (p *CsrError) GetMessage() string {
	return p.Message
}
func (p *CsrError) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *CsrError) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 1: %s", err)
	} else {
		p.TypeA1 = v
	}
	return nil
}

func (p *CsrError) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 2: %s", err)
	} else {
		p.Message = v
	}
	return nil
}

func (p *CsrError) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("csr_error"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *CsrError) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("type", thrift.I32, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:type: %s", p, err)
	}
	if err := oprot.WriteI32(int32(p.TypeA1)); err != nil {
		return fmt.Errorf("%T.type (1) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:type: %s", p, err)
	}
	return err
}

func (p *CsrError) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("message", thrift.STRING, 2); err != nil {
		return fmt.Errorf("%T write field begin error 2:message: %s", p, err)
	}
	if err := oprot.WriteString(string(p.Message)); err != nil {
		return fmt.Errorf("%T.message (2) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 2:message: %s", p, err)
	}
	return err
}

func (p *CsrError) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("CsrError(%+v)", *p)
}

func (p *CsrError) Error() string {
	return p.String()
}

type BindError struct {
	TypeA1  int32  `thrift:"type,1" json:"type"`
	Message string `thrift:"message,2" json:"message"`
}

func NewBindError() *BindError {
	return &BindError{}
}

func (p *BindError) GetTypeA1() int32 {
	return p.TypeA1
}

func (p *BindError) GetMessage() string {
	return p.Message
}
func (p *BindError) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *BindError) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 1: %s", err)
	} else {
		p.TypeA1 = v
	}
	return nil
}

func (p *BindError) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 2: %s", err)
	} else {
		p.Message = v
	}
	return nil
}

func (p *BindError) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("bind_error"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *BindError) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("type", thrift.I32, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:type: %s", p, err)
	}
	if err := oprot.WriteI32(int32(p.TypeA1)); err != nil {
		return fmt.Errorf("%T.type (1) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:type: %s", p, err)
	}
	return err
}

func (p *BindError) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("message", thrift.STRING, 2); err != nil {
		return fmt.Errorf("%T write field begin error 2:message: %s", p, err)
	}
	if err := oprot.WriteString(string(p.Message)); err != nil {
		return fmt.Errorf("%T.message (2) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 2:message: %s", p, err)
	}
	return err
}

func (p *BindError) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("BindError(%+v)", *p)
}

func (p *BindError) Error() string {
	return p.String()
}

type CRMMsgError struct {
	TypeA1  int32  `thrift:"type,1" json:"type"`
	Message string `thrift:"message,2" json:"message"`
}

func NewCRMMsgError() *CRMMsgError {
	return &CRMMsgError{}
}

func (p *CRMMsgError) GetTypeA1() int32 {
	return p.TypeA1
}

func (p *CRMMsgError) GetMessage() string {
	return p.Message
}
func (p *CRMMsgError) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *CRMMsgError) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 1: %s", err)
	} else {
		p.TypeA1 = v
	}
	return nil
}

func (p *CRMMsgError) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 2: %s", err)
	} else {
		p.Message = v
	}
	return nil
}

func (p *CRMMsgError) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("CRMMsgError"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *CRMMsgError) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("type", thrift.I32, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:type: %s", p, err)
	}
	if err := oprot.WriteI32(int32(p.TypeA1)); err != nil {
		return fmt.Errorf("%T.type (1) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:type: %s", p, err)
	}
	return err
}

func (p *CRMMsgError) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("message", thrift.STRING, 2); err != nil {
		return fmt.Errorf("%T write field begin error 2:message: %s", p, err)
	}
	if err := oprot.WriteString(string(p.Message)); err != nil {
		return fmt.Errorf("%T.message (2) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 2:message: %s", p, err)
	}
	return err
}

func (p *CRMMsgError) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("CRMMsgError(%+v)", *p)
}

func (p *CRMMsgError) Error() string {
	return p.String()
}