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

package admin

import (
	"bytes"
	"context"
	"database/sql/driver"
	"errors"
	"fmt"
	"github.com/apache/incubator-pegasus/go-client/idl/base"
	"github.com/apache/incubator-pegasus/go-client/idl/replication"
	"github.com/apache/incubator-pegasus/go-client/idl/utils"
	"github.com/apache/thrift/lib/go/thrift"
	"reflect"
)

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

var _ = base.GoUnusedProtection__
var _ = replication.GoUnusedProtection__
var _ = utils.GoUnusedProtection__

type ConfigType int64

const (
	ConfigType_CT_INVALID                     ConfigType = 0
	ConfigType_CT_ASSIGN_PRIMARY              ConfigType = 1
	ConfigType_CT_UPGRADE_TO_PRIMARY          ConfigType = 2
	ConfigType_CT_ADD_SECONDARY               ConfigType = 3
	ConfigType_CT_UPGRADE_TO_SECONDARY        ConfigType = 4
	ConfigType_CT_DOWNGRADE_TO_SECONDARY      ConfigType = 5
	ConfigType_CT_DOWNGRADE_TO_INACTIVE       ConfigType = 6
	ConfigType_CT_REMOVE                      ConfigType = 7
	ConfigType_CT_ADD_SECONDARY_FOR_LB        ConfigType = 8
	ConfigType_CT_PRIMARY_FORCE_UPDATE_BALLOT ConfigType = 9
	ConfigType_CT_DROP_PARTITION              ConfigType = 10
	ConfigType_CT_REGISTER_CHILD              ConfigType = 11
)

func (p ConfigType) String() string {
	switch p {
	case ConfigType_CT_INVALID:
		return "CT_INVALID"
	case ConfigType_CT_ASSIGN_PRIMARY:
		return "CT_ASSIGN_PRIMARY"
	case ConfigType_CT_UPGRADE_TO_PRIMARY:
		return "CT_UPGRADE_TO_PRIMARY"
	case ConfigType_CT_ADD_SECONDARY:
		return "CT_ADD_SECONDARY"
	case ConfigType_CT_UPGRADE_TO_SECONDARY:
		return "CT_UPGRADE_TO_SECONDARY"
	case ConfigType_CT_DOWNGRADE_TO_SECONDARY:
		return "CT_DOWNGRADE_TO_SECONDARY"
	case ConfigType_CT_DOWNGRADE_TO_INACTIVE:
		return "CT_DOWNGRADE_TO_INACTIVE"
	case ConfigType_CT_REMOVE:
		return "CT_REMOVE"
	case ConfigType_CT_ADD_SECONDARY_FOR_LB:
		return "CT_ADD_SECONDARY_FOR_LB"
	case ConfigType_CT_PRIMARY_FORCE_UPDATE_BALLOT:
		return "CT_PRIMARY_FORCE_UPDATE_BALLOT"
	case ConfigType_CT_DROP_PARTITION:
		return "CT_DROP_PARTITION"
	case ConfigType_CT_REGISTER_CHILD:
		return "CT_REGISTER_CHILD"
	}
	return "<UNSET>"
}

func ConfigTypeFromString(s string) (ConfigType, error) {
	switch s {
	case "CT_INVALID":
		return ConfigType_CT_INVALID, nil
	case "CT_ASSIGN_PRIMARY":
		return ConfigType_CT_ASSIGN_PRIMARY, nil
	case "CT_UPGRADE_TO_PRIMARY":
		return ConfigType_CT_UPGRADE_TO_PRIMARY, nil
	case "CT_ADD_SECONDARY":
		return ConfigType_CT_ADD_SECONDARY, nil
	case "CT_UPGRADE_TO_SECONDARY":
		return ConfigType_CT_UPGRADE_TO_SECONDARY, nil
	case "CT_DOWNGRADE_TO_SECONDARY":
		return ConfigType_CT_DOWNGRADE_TO_SECONDARY, nil
	case "CT_DOWNGRADE_TO_INACTIVE":
		return ConfigType_CT_DOWNGRADE_TO_INACTIVE, nil
	case "CT_REMOVE":
		return ConfigType_CT_REMOVE, nil
	case "CT_ADD_SECONDARY_FOR_LB":
		return ConfigType_CT_ADD_SECONDARY_FOR_LB, nil
	case "CT_PRIMARY_FORCE_UPDATE_BALLOT":
		return ConfigType_CT_PRIMARY_FORCE_UPDATE_BALLOT, nil
	case "CT_DROP_PARTITION":
		return ConfigType_CT_DROP_PARTITION, nil
	case "CT_REGISTER_CHILD":
		return ConfigType_CT_REGISTER_CHILD, nil
	}
	return ConfigType(0), fmt.Errorf("not a valid ConfigType string")
}

func ConfigTypePtr(v ConfigType) *ConfigType { return &v }

func (p ConfigType) MarshalText() ([]byte, error) {
	return []byte(p.String()), nil
}

func (p *ConfigType) UnmarshalText(text []byte) error {
	q, err := ConfigTypeFromString(string(text))
	if err != nil {
		return err
	}
	*p = q
	return nil
}

func (p *ConfigType) Scan(value interface{}) error {
	v, ok := value.(int64)
	if !ok {
		return errors.New("Scan value is not int64")
	}
	*p = ConfigType(v)
	return nil
}

func (p *ConfigType) Value() (driver.Value, error) {
	if p == nil {
		return nil, nil
	}
	return int64(*p), nil
}

type NodeStatus int64

const (
	NodeStatus_NS_INVALID NodeStatus = 0
	NodeStatus_NS_ALIVE   NodeStatus = 1
	NodeStatus_NS_UNALIVE NodeStatus = 2
)

func (p NodeStatus) String() string {
	switch p {
	case NodeStatus_NS_INVALID:
		return "NS_INVALID"
	case NodeStatus_NS_ALIVE:
		return "NS_ALIVE"
	case NodeStatus_NS_UNALIVE:
		return "NS_UNALIVE"
	}
	return "<UNSET>"
}

func NodeStatusFromString(s string) (NodeStatus, error) {
	switch s {
	case "NS_INVALID":
		return NodeStatus_NS_INVALID, nil
	case "NS_ALIVE":
		return NodeStatus_NS_ALIVE, nil
	case "NS_UNALIVE":
		return NodeStatus_NS_UNALIVE, nil
	}
	return NodeStatus(0), fmt.Errorf("not a valid NodeStatus string")
}

func NodeStatusPtr(v NodeStatus) *NodeStatus { return &v }

func (p NodeStatus) MarshalText() ([]byte, error) {
	return []byte(p.String()), nil
}

func (p *NodeStatus) UnmarshalText(text []byte) error {
	q, err := NodeStatusFromString(string(text))
	if err != nil {
		return err
	}
	*p = q
	return nil
}

func (p *NodeStatus) Scan(value interface{}) error {
	v, ok := value.(int64)
	if !ok {
		return errors.New("Scan value is not int64")
	}
	*p = NodeStatus(v)
	return nil
}

func (p *NodeStatus) Value() (driver.Value, error) {
	if p == nil {
		return nil, nil
	}
	return int64(*p), nil
}

type AppEnvOperation int64

const (
	AppEnvOperation_APP_ENV_OP_INVALID AppEnvOperation = 0
	AppEnvOperation_APP_ENV_OP_SET     AppEnvOperation = 1
	AppEnvOperation_APP_ENV_OP_DEL     AppEnvOperation = 2
	AppEnvOperation_APP_ENV_OP_CLEAR   AppEnvOperation = 3
)

func (p AppEnvOperation) String() string {
	switch p {
	case AppEnvOperation_APP_ENV_OP_INVALID:
		return "APP_ENV_OP_INVALID"
	case AppEnvOperation_APP_ENV_OP_SET:
		return "APP_ENV_OP_SET"
	case AppEnvOperation_APP_ENV_OP_DEL:
		return "APP_ENV_OP_DEL"
	case AppEnvOperation_APP_ENV_OP_CLEAR:
		return "APP_ENV_OP_CLEAR"
	}
	return "<UNSET>"
}

func AppEnvOperationFromString(s string) (AppEnvOperation, error) {
	switch s {
	case "APP_ENV_OP_INVALID":
		return AppEnvOperation_APP_ENV_OP_INVALID, nil
	case "APP_ENV_OP_SET":
		return AppEnvOperation_APP_ENV_OP_SET, nil
	case "APP_ENV_OP_DEL":
		return AppEnvOperation_APP_ENV_OP_DEL, nil
	case "APP_ENV_OP_CLEAR":
		return AppEnvOperation_APP_ENV_OP_CLEAR, nil
	}
	return AppEnvOperation(0), fmt.Errorf("not a valid AppEnvOperation string")
}

func AppEnvOperationPtr(v AppEnvOperation) *AppEnvOperation { return &v }

func (p AppEnvOperation) MarshalText() ([]byte, error) {
	return []byte(p.String()), nil
}

func (p *AppEnvOperation) UnmarshalText(text []byte) error {
	q, err := AppEnvOperationFromString(string(text))
	if err != nil {
		return err
	}
	*p = q
	return nil
}

func (p *AppEnvOperation) Scan(value interface{}) error {
	v, ok := value.(int64)
	if !ok {
		return errors.New("Scan value is not int64")
	}
	*p = AppEnvOperation(v)
	return nil
}

func (p *AppEnvOperation) Value() (driver.Value, error) {
	if p == nil {
		return nil, nil
	}
	return int64(*p), nil
}

type MetaFunctionLevel int64

const (
	MetaFunctionLevel_fl_stopped MetaFunctionLevel = 100
	MetaFunctionLevel_fl_blind   MetaFunctionLevel = 200
	MetaFunctionLevel_fl_freezed MetaFunctionLevel = 300
	MetaFunctionLevel_fl_steady  MetaFunctionLevel = 400
	MetaFunctionLevel_fl_lively  MetaFunctionLevel = 500
	MetaFunctionLevel_fl_invalid MetaFunctionLevel = 10000
)

func (p MetaFunctionLevel) String() string {
	switch p {
	case MetaFunctionLevel_fl_stopped:
		return "fl_stopped"
	case MetaFunctionLevel_fl_blind:
		return "fl_blind"
	case MetaFunctionLevel_fl_freezed:
		return "fl_freezed"
	case MetaFunctionLevel_fl_steady:
		return "fl_steady"
	case MetaFunctionLevel_fl_lively:
		return "fl_lively"
	case MetaFunctionLevel_fl_invalid:
		return "fl_invalid"
	}
	return "<UNSET>"
}

func MetaFunctionLevelFromString(s string) (MetaFunctionLevel, error) {
	switch s {
	case "fl_stopped":
		return MetaFunctionLevel_fl_stopped, nil
	case "fl_blind":
		return MetaFunctionLevel_fl_blind, nil
	case "fl_freezed":
		return MetaFunctionLevel_fl_freezed, nil
	case "fl_steady":
		return MetaFunctionLevel_fl_steady, nil
	case "fl_lively":
		return MetaFunctionLevel_fl_lively, nil
	case "fl_invalid":
		return MetaFunctionLevel_fl_invalid, nil
	}
	return MetaFunctionLevel(0), fmt.Errorf("not a valid MetaFunctionLevel string")
}

func MetaFunctionLevelPtr(v MetaFunctionLevel) *MetaFunctionLevel { return &v }

func (p MetaFunctionLevel) MarshalText() ([]byte, error) {
	return []byte(p.String()), nil
}

func (p *MetaFunctionLevel) UnmarshalText(text []byte) error {
	q, err := MetaFunctionLevelFromString(string(text))
	if err != nil {
		return err
	}
	*p = q
	return nil
}

func (p *MetaFunctionLevel) Scan(value interface{}) error {
	v, ok := value.(int64)
	if !ok {
		return errors.New("Scan value is not int64")
	}
	*p = MetaFunctionLevel(v)
	return nil
}

func (p *MetaFunctionLevel) Value() (driver.Value, error) {
	if p == nil {
		return nil, nil
	}
	return int64(*p), nil
}

type BalancerRequestType int64

const (
	BalancerRequestType_move_primary   BalancerRequestType = 0
	BalancerRequestType_copy_primary   BalancerRequestType = 1
	BalancerRequestType_copy_secondary BalancerRequestType = 2
)

func (p BalancerRequestType) String() string {
	switch p {
	case BalancerRequestType_move_primary:
		return "move_primary"
	case BalancerRequestType_copy_primary:
		return "copy_primary"
	case BalancerRequestType_copy_secondary:
		return "copy_secondary"
	}
	return "<UNSET>"
}

func BalancerRequestTypeFromString(s string) (BalancerRequestType, error) {
	switch s {
	case "move_primary":
		return BalancerRequestType_move_primary, nil
	case "copy_primary":
		return BalancerRequestType_copy_primary, nil
	case "copy_secondary":
		return BalancerRequestType_copy_secondary, nil
	}
	return BalancerRequestType(0), fmt.Errorf("not a valid BalancerRequestType string")
}

func BalancerRequestTypePtr(v BalancerRequestType) *BalancerRequestType { return &v }

func (p BalancerRequestType) MarshalText() ([]byte, error) {
	return []byte(p.String()), nil
}

func (p *BalancerRequestType) UnmarshalText(text []byte) error {
	q, err := BalancerRequestTypeFromString(string(text))
	if err != nil {
		return err
	}
	*p = q
	return nil
}

func (p *BalancerRequestType) Scan(value interface{}) error {
	v, ok := value.(int64)
	if !ok {
		return errors.New("Scan value is not int64")
	}
	*p = BalancerRequestType(v)
	return nil
}

func (p *BalancerRequestType) Value() (driver.Value, error) {
	if p == nil {
		return nil, nil
	}
	return int64(*p), nil
}

// Attributes:
//  - Info
//  - Config
//  - Type
//  - Node
//  - HostNode
//  - MetaSplitStatus
//  - HpNode
type ConfigurationUpdateRequest struct {
	Info            *replication.AppInfo                `thrift:"info,1" db:"info" json:"info"`
	Config          *replication.PartitionConfiguration `thrift:"config,2" db:"config" json:"config"`
	Type            ConfigType                          `thrift:"type,3" db:"type" json:"type"`
	Node            *base.RPCAddress                    `thrift:"node,4" db:"node" json:"node"`
	HostNode        *base.RPCAddress                    `thrift:"host_node,5" db:"host_node" json:"host_node"`
	MetaSplitStatus *SplitStatus                        `thrift:"meta_split_status,6" db:"meta_split_status" json:"meta_split_status,omitempty"`
	HpNode          *base.HostPort                      `thrift:"hp_node,7" db:"hp_node" json:"hp_node,omitempty"`
}

func NewConfigurationUpdateRequest() *ConfigurationUpdateRequest {
	return &ConfigurationUpdateRequest{
		Type: 0,
	}
}

var ConfigurationUpdateRequest_Info_DEFAULT *replication.AppInfo

func (p *ConfigurationUpdateRequest) GetInfo() *replication.AppInfo {
	if !p.IsSetInfo() {
		return ConfigurationUpdateRequest_Info_DEFAULT
	}
	return p.Info
}

var ConfigurationUpdateRequest_Config_DEFAULT *replication.PartitionConfiguration

func (p *ConfigurationUpdateRequest) GetConfig() *replication.PartitionConfiguration {
	if !p.IsSetConfig() {
		return ConfigurationUpdateRequest_Config_DEFAULT
	}
	return p.Config
}

func (p *ConfigurationUpdateRequest) GetType() ConfigType {
	return p.Type
}

var ConfigurationUpdateRequest_Node_DEFAULT *base.RPCAddress

func (p *ConfigurationUpdateRequest) GetNode() *base.RPCAddress {
	if !p.IsSetNode() {
		return ConfigurationUpdateRequest_Node_DEFAULT
	}
	return p.Node
}

var ConfigurationUpdateRequest_HostNode_DEFAULT *base.RPCAddress

func (p *ConfigurationUpdateRequest) GetHostNode() *base.RPCAddress {
	if !p.IsSetHostNode() {
		return ConfigurationUpdateRequest_HostNode_DEFAULT
	}
	return p.HostNode
}

var ConfigurationUpdateRequest_MetaSplitStatus_DEFAULT SplitStatus

func (p *ConfigurationUpdateRequest) GetMetaSplitStatus() SplitStatus {
	if !p.IsSetMetaSplitStatus() {
		return ConfigurationUpdateRequest_MetaSplitStatus_DEFAULT
	}
	return *p.MetaSplitStatus
}

var ConfigurationUpdateRequest_HpNode_DEFAULT *base.HostPort

func (p *ConfigurationUpdateRequest) GetHpNode() *base.HostPort {
	if !p.IsSetHpNode() {
		return ConfigurationUpdateRequest_HpNode_DEFAULT
	}
	return p.HpNode
}
func (p *ConfigurationUpdateRequest) IsSetInfo() bool {
	return p.Info != nil
}

func (p *ConfigurationUpdateRequest) IsSetConfig() bool {
	return p.Config != nil
}

func (p *ConfigurationUpdateRequest) IsSetNode() bool {
	return p.Node != nil
}

func (p *ConfigurationUpdateRequest) IsSetHostNode() bool {
	return p.HostNode != nil
}

func (p *ConfigurationUpdateRequest) IsSetMetaSplitStatus() bool {
	return p.MetaSplitStatus != nil
}

func (p *ConfigurationUpdateRequest) IsSetHpNode() bool {
	return p.HpNode != nil
}

func (p *ConfigurationUpdateRequest) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField2(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 3:
			if fieldTypeId == thrift.I32 {
				if err := p.ReadField3(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 4:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField4(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 5:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField5(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 6:
			if fieldTypeId == thrift.I32 {
				if err := p.ReadField6(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 7:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField7(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ConfigurationUpdateRequest) ReadField1(iprot thrift.TProtocol) error {
	p.Info = &replication.AppInfo{
		Status: 0,

		InitPartitionCount: -1,
	}
	if err := p.Info.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Info), err)
	}
	return nil
}

func (p *ConfigurationUpdateRequest) ReadField2(iprot thrift.TProtocol) error {
	p.Config = &replication.PartitionConfiguration{}
	if err := p.Config.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Config), err)
	}
	return nil
}

func (p *ConfigurationUpdateRequest) ReadField3(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return thrift.PrependError("error reading field 3: ", err)
	} else {
		temp := ConfigType(v)
		p.Type = temp
	}
	return nil
}

func (p *ConfigurationUpdateRequest) ReadField4(iprot thrift.TProtocol) error {
	p.Node = &base.RPCAddress{}
	if err := p.Node.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Node), err)
	}
	return nil
}

func (p *ConfigurationUpdateRequest) ReadField5(iprot thrift.TProtocol) error {
	p.HostNode = &base.RPCAddress{}
	if err := p.HostNode.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.HostNode), err)
	}
	return nil
}

func (p *ConfigurationUpdateRequest) ReadField6(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return thrift.PrependError("error reading field 6: ", err)
	} else {
		temp := SplitStatus(v)
		p.MetaSplitStatus = &temp
	}
	return nil
}

func (p *ConfigurationUpdateRequest) ReadField7(iprot thrift.TProtocol) error {
	p.HpNode = &base.HostPort{}
	if err := p.HpNode.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.HpNode), err)
	}
	return nil
}

func (p *ConfigurationUpdateRequest) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("configuration_update_request"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		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 := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ConfigurationUpdateRequest) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("info", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:info: ", p), err)
	}
	if err := p.Info.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Info), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:info: ", p), err)
	}
	return err
}

func (p *ConfigurationUpdateRequest) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("config", thrift.STRUCT, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:config: ", p), err)
	}
	if err := p.Config.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Config), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:config: ", p), err)
	}
	return err
}

func (p *ConfigurationUpdateRequest) writeField3(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("type", thrift.I32, 3); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:type: ", p), err)
	}
	if err := oprot.WriteI32(int32(p.Type)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.type (3) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:type: ", p), err)
	}
	return err
}

func (p *ConfigurationUpdateRequest) writeField4(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("node", thrift.STRUCT, 4); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:node: ", p), err)
	}
	if err := p.Node.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Node), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 4:node: ", p), err)
	}
	return err
}

func (p *ConfigurationUpdateRequest) writeField5(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("host_node", thrift.STRUCT, 5); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 5:host_node: ", p), err)
	}
	if err := p.HostNode.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.HostNode), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 5:host_node: ", p), err)
	}
	return err
}

func (p *ConfigurationUpdateRequest) writeField6(oprot thrift.TProtocol) (err error) {
	if p.IsSetMetaSplitStatus() {
		if err := oprot.WriteFieldBegin("meta_split_status", thrift.I32, 6); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 6:meta_split_status: ", p), err)
		}
		if err := oprot.WriteI32(int32(*p.MetaSplitStatus)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.meta_split_status (6) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 6:meta_split_status: ", p), err)
		}
	}
	return err
}

func (p *ConfigurationUpdateRequest) writeField7(oprot thrift.TProtocol) (err error) {
	if p.IsSetHpNode() {
		if err := oprot.WriteFieldBegin("hp_node", thrift.STRUCT, 7); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 7:hp_node: ", p), err)
		}
		if err := p.HpNode.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.HpNode), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 7:hp_node: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - Err
//  - Config
type ConfigurationUpdateResponse struct {
	Err    *base.ErrorCode                     `thrift:"err,1" db:"err" json:"err"`
	Config *replication.PartitionConfiguration `thrift:"config,2" db:"config" json:"config"`
}

func NewConfigurationUpdateResponse() *ConfigurationUpdateResponse {
	return &ConfigurationUpdateResponse{}
}

var ConfigurationUpdateResponse_Err_DEFAULT *base.ErrorCode

func (p *ConfigurationUpdateResponse) GetErr() *base.ErrorCode {
	if !p.IsSetErr() {
		return ConfigurationUpdateResponse_Err_DEFAULT
	}
	return p.Err
}

var ConfigurationUpdateResponse_Config_DEFAULT *replication.PartitionConfiguration

func (p *ConfigurationUpdateResponse) GetConfig() *replication.PartitionConfiguration {
	if !p.IsSetConfig() {
		return ConfigurationUpdateResponse_Config_DEFAULT
	}
	return p.Config
}
func (p *ConfigurationUpdateResponse) IsSetErr() bool {
	return p.Err != nil
}

func (p *ConfigurationUpdateResponse) IsSetConfig() bool {
	return p.Config != nil
}

func (p *ConfigurationUpdateResponse) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField2(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ConfigurationUpdateResponse) ReadField1(iprot thrift.TProtocol) error {
	p.Err = &base.ErrorCode{}
	if err := p.Err.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Err), err)
	}
	return nil
}

func (p *ConfigurationUpdateResponse) ReadField2(iprot thrift.TProtocol) error {
	p.Config = &replication.PartitionConfiguration{}
	if err := p.Config.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Config), err)
	}
	return nil
}

func (p *ConfigurationUpdateResponse) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("configuration_update_response"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		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 thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ConfigurationUpdateResponse) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("err", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:err: ", p), err)
	}
	if err := p.Err.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Err), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:err: ", p), err)
	}
	return err
}

func (p *ConfigurationUpdateResponse) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("config", thrift.STRUCT, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:config: ", p), err)
	}
	if err := p.Config.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Config), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:config: ", p), err)
	}
	return err
}

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

// Attributes:
//  - GeoTags
//  - TotalCapacityMb
type ReplicaServerInfo struct {
	GeoTags         map[string]string `thrift:"geo_tags,1" db:"geo_tags" json:"geo_tags"`
	TotalCapacityMb int64             `thrift:"total_capacity_mb,2" db:"total_capacity_mb" json:"total_capacity_mb"`
}

func NewReplicaServerInfo() *ReplicaServerInfo {
	return &ReplicaServerInfo{}
}

func (p *ReplicaServerInfo) GetGeoTags() map[string]string {
	return p.GeoTags
}

func (p *ReplicaServerInfo) GetTotalCapacityMb() int64 {
	return p.TotalCapacityMb
}
func (p *ReplicaServerInfo) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.MAP {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.I64 {
				if err := p.ReadField2(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ReplicaServerInfo) ReadField1(iprot thrift.TProtocol) error {
	_, _, size, err := iprot.ReadMapBegin()
	if err != nil {
		return thrift.PrependError("error reading map begin: ", err)
	}
	tMap := make(map[string]string, size)
	p.GeoTags = tMap
	for i := 0; i < size; i++ {
		var _key0 string
		if v, err := iprot.ReadString(); err != nil {
			return thrift.PrependError("error reading field 0: ", err)
		} else {
			_key0 = v
		}
		var _val1 string
		if v, err := iprot.ReadString(); err != nil {
			return thrift.PrependError("error reading field 0: ", err)
		} else {
			_val1 = v
		}
		p.GeoTags[_key0] = _val1
	}
	if err := iprot.ReadMapEnd(); err != nil {
		return thrift.PrependError("error reading map end: ", err)
	}
	return nil
}

func (p *ReplicaServerInfo) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI64(); err != nil {
		return thrift.PrependError("error reading field 2: ", err)
	} else {
		p.TotalCapacityMb = v
	}
	return nil
}

func (p *ReplicaServerInfo) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("replica_server_info"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		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 thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ReplicaServerInfo) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("geo_tags", thrift.MAP, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:geo_tags: ", p), err)
	}
	if err := oprot.WriteMapBegin(thrift.STRING, thrift.STRING, len(p.GeoTags)); err != nil {
		return thrift.PrependError("error writing map begin: ", err)
	}
	for k, v := range p.GeoTags {
		if err := oprot.WriteString(string(k)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
		}
		if err := oprot.WriteString(string(v)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
		}
	}
	if err := oprot.WriteMapEnd(); err != nil {
		return thrift.PrependError("error writing map end: ", err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:geo_tags: ", p), err)
	}
	return err
}

func (p *ReplicaServerInfo) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("total_capacity_mb", thrift.I64, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:total_capacity_mb: ", p), err)
	}
	if err := oprot.WriteI64(int64(p.TotalCapacityMb)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.total_capacity_mb (2) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:total_capacity_mb: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Node
//  - StoredReplicas
//  - Info
//  - HpNode
type ConfigurationQueryByNodeRequest struct {
	Node           *base.RPCAddress   `thrift:"node,1" db:"node" json:"node"`
	StoredReplicas []*ReplicaInfo     `thrift:"stored_replicas,2" db:"stored_replicas" json:"stored_replicas,omitempty"`
	Info           *ReplicaServerInfo `thrift:"info,3" db:"info" json:"info,omitempty"`
	HpNode         *base.HostPort     `thrift:"hp_node,4" db:"hp_node" json:"hp_node,omitempty"`
}

func NewConfigurationQueryByNodeRequest() *ConfigurationQueryByNodeRequest {
	return &ConfigurationQueryByNodeRequest{}
}

var ConfigurationQueryByNodeRequest_Node_DEFAULT *base.RPCAddress

func (p *ConfigurationQueryByNodeRequest) GetNode() *base.RPCAddress {
	if !p.IsSetNode() {
		return ConfigurationQueryByNodeRequest_Node_DEFAULT
	}
	return p.Node
}

var ConfigurationQueryByNodeRequest_StoredReplicas_DEFAULT []*ReplicaInfo

func (p *ConfigurationQueryByNodeRequest) GetStoredReplicas() []*ReplicaInfo {
	return p.StoredReplicas
}

var ConfigurationQueryByNodeRequest_Info_DEFAULT *ReplicaServerInfo

func (p *ConfigurationQueryByNodeRequest) GetInfo() *ReplicaServerInfo {
	if !p.IsSetInfo() {
		return ConfigurationQueryByNodeRequest_Info_DEFAULT
	}
	return p.Info
}

var ConfigurationQueryByNodeRequest_HpNode_DEFAULT *base.HostPort

func (p *ConfigurationQueryByNodeRequest) GetHpNode() *base.HostPort {
	if !p.IsSetHpNode() {
		return ConfigurationQueryByNodeRequest_HpNode_DEFAULT
	}
	return p.HpNode
}
func (p *ConfigurationQueryByNodeRequest) IsSetNode() bool {
	return p.Node != nil
}

func (p *ConfigurationQueryByNodeRequest) IsSetStoredReplicas() bool {
	return p.StoredReplicas != nil
}

func (p *ConfigurationQueryByNodeRequest) IsSetInfo() bool {
	return p.Info != nil
}

func (p *ConfigurationQueryByNodeRequest) IsSetHpNode() bool {
	return p.HpNode != nil
}

func (p *ConfigurationQueryByNodeRequest) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.LIST {
				if err := p.ReadField2(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 3:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField3(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 4:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField4(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ConfigurationQueryByNodeRequest) ReadField1(iprot thrift.TProtocol) error {
	p.Node = &base.RPCAddress{}
	if err := p.Node.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Node), err)
	}
	return nil
}

func (p *ConfigurationQueryByNodeRequest) ReadField2(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return thrift.PrependError("error reading list begin: ", err)
	}
	tSlice := make([]*ReplicaInfo, 0, size)
	p.StoredReplicas = tSlice
	for i := 0; i < size; i++ {
		_elem2 := &ReplicaInfo{}
		if err := _elem2.Read(iprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem2), err)
		}
		p.StoredReplicas = append(p.StoredReplicas, _elem2)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return thrift.PrependError("error reading list end: ", err)
	}
	return nil
}

func (p *ConfigurationQueryByNodeRequest) ReadField3(iprot thrift.TProtocol) error {
	p.Info = &ReplicaServerInfo{}
	if err := p.Info.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Info), err)
	}
	return nil
}

func (p *ConfigurationQueryByNodeRequest) ReadField4(iprot thrift.TProtocol) error {
	p.HpNode = &base.HostPort{}
	if err := p.HpNode.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.HpNode), err)
	}
	return nil
}

func (p *ConfigurationQueryByNodeRequest) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("configuration_query_by_node_request"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		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 := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ConfigurationQueryByNodeRequest) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("node", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:node: ", p), err)
	}
	if err := p.Node.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Node), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:node: ", p), err)
	}
	return err
}

func (p *ConfigurationQueryByNodeRequest) writeField2(oprot thrift.TProtocol) (err error) {
	if p.IsSetStoredReplicas() {
		if err := oprot.WriteFieldBegin("stored_replicas", thrift.LIST, 2); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:stored_replicas: ", p), err)
		}
		if err := oprot.WriteListBegin(thrift.STRUCT, len(p.StoredReplicas)); err != nil {
			return thrift.PrependError("error writing list begin: ", err)
		}
		for _, v := range p.StoredReplicas {
			if err := v.Write(oprot); err != nil {
				return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", v), err)
			}
		}
		if err := oprot.WriteListEnd(); err != nil {
			return thrift.PrependError("error writing list end: ", err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 2:stored_replicas: ", p), err)
		}
	}
	return err
}

func (p *ConfigurationQueryByNodeRequest) writeField3(oprot thrift.TProtocol) (err error) {
	if p.IsSetInfo() {
		if err := oprot.WriteFieldBegin("info", thrift.STRUCT, 3); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:info: ", p), err)
		}
		if err := p.Info.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Info), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 3:info: ", p), err)
		}
	}
	return err
}

func (p *ConfigurationQueryByNodeRequest) writeField4(oprot thrift.TProtocol) (err error) {
	if p.IsSetHpNode() {
		if err := oprot.WriteFieldBegin("hp_node", thrift.STRUCT, 4); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:hp_node: ", p), err)
		}
		if err := p.HpNode.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.HpNode), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 4:hp_node: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - Err
//  - Partitions
//  - GcReplicas
type ConfigurationQueryByNodeResponse struct {
	Err        *base.ErrorCode               `thrift:"err,1" db:"err" json:"err"`
	Partitions []*ConfigurationUpdateRequest `thrift:"partitions,2" db:"partitions" json:"partitions"`
	GcReplicas []*ReplicaInfo                `thrift:"gc_replicas,3" db:"gc_replicas" json:"gc_replicas,omitempty"`
}

func NewConfigurationQueryByNodeResponse() *ConfigurationQueryByNodeResponse {
	return &ConfigurationQueryByNodeResponse{}
}

var ConfigurationQueryByNodeResponse_Err_DEFAULT *base.ErrorCode

func (p *ConfigurationQueryByNodeResponse) GetErr() *base.ErrorCode {
	if !p.IsSetErr() {
		return ConfigurationQueryByNodeResponse_Err_DEFAULT
	}
	return p.Err
}

func (p *ConfigurationQueryByNodeResponse) GetPartitions() []*ConfigurationUpdateRequest {
	return p.Partitions
}

var ConfigurationQueryByNodeResponse_GcReplicas_DEFAULT []*ReplicaInfo

func (p *ConfigurationQueryByNodeResponse) GetGcReplicas() []*ReplicaInfo {
	return p.GcReplicas
}
func (p *ConfigurationQueryByNodeResponse) IsSetErr() bool {
	return p.Err != nil
}

func (p *ConfigurationQueryByNodeResponse) IsSetGcReplicas() bool {
	return p.GcReplicas != nil
}

func (p *ConfigurationQueryByNodeResponse) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.LIST {
				if err := p.ReadField2(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 3:
			if fieldTypeId == thrift.LIST {
				if err := p.ReadField3(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ConfigurationQueryByNodeResponse) ReadField1(iprot thrift.TProtocol) error {
	p.Err = &base.ErrorCode{}
	if err := p.Err.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Err), err)
	}
	return nil
}

func (p *ConfigurationQueryByNodeResponse) ReadField2(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return thrift.PrependError("error reading list begin: ", err)
	}
	tSlice := make([]*ConfigurationUpdateRequest, 0, size)
	p.Partitions = tSlice
	for i := 0; i < size; i++ {
		_elem3 := &ConfigurationUpdateRequest{
			Type: 0,
		}
		if err := _elem3.Read(iprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem3), err)
		}
		p.Partitions = append(p.Partitions, _elem3)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return thrift.PrependError("error reading list end: ", err)
	}
	return nil
}

func (p *ConfigurationQueryByNodeResponse) ReadField3(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return thrift.PrependError("error reading list begin: ", err)
	}
	tSlice := make([]*ReplicaInfo, 0, size)
	p.GcReplicas = tSlice
	for i := 0; i < size; i++ {
		_elem4 := &ReplicaInfo{}
		if err := _elem4.Read(iprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem4), err)
		}
		p.GcReplicas = append(p.GcReplicas, _elem4)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return thrift.PrependError("error reading list end: ", err)
	}
	return nil
}

func (p *ConfigurationQueryByNodeResponse) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("configuration_query_by_node_response"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		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 := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ConfigurationQueryByNodeResponse) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("err", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:err: ", p), err)
	}
	if err := p.Err.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Err), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:err: ", p), err)
	}
	return err
}

func (p *ConfigurationQueryByNodeResponse) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("partitions", thrift.LIST, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:partitions: ", p), err)
	}
	if err := oprot.WriteListBegin(thrift.STRUCT, len(p.Partitions)); err != nil {
		return thrift.PrependError("error writing list begin: ", err)
	}
	for _, v := range p.Partitions {
		if err := v.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", v), err)
		}
	}
	if err := oprot.WriteListEnd(); err != nil {
		return thrift.PrependError("error writing list end: ", err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:partitions: ", p), err)
	}
	return err
}

func (p *ConfigurationQueryByNodeResponse) writeField3(oprot thrift.TProtocol) (err error) {
	if p.IsSetGcReplicas() {
		if err := oprot.WriteFieldBegin("gc_replicas", thrift.LIST, 3); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:gc_replicas: ", p), err)
		}
		if err := oprot.WriteListBegin(thrift.STRUCT, len(p.GcReplicas)); err != nil {
			return thrift.PrependError("error writing list begin: ", err)
		}
		for _, v := range p.GcReplicas {
			if err := v.Write(oprot); err != nil {
				return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", v), err)
			}
		}
		if err := oprot.WriteListEnd(); err != nil {
			return thrift.PrependError("error writing list end: ", err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 3:gc_replicas: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - RecoveryNodes
//  - SkipBadNodes
//  - SkipLostPartitions
//  - HpRecoveryNodes
type ConfigurationRecoveryRequest struct {
	RecoveryNodes      []*base.RPCAddress `thrift:"recovery_nodes,1" db:"recovery_nodes" json:"recovery_nodes"`
	SkipBadNodes       bool               `thrift:"skip_bad_nodes,2" db:"skip_bad_nodes" json:"skip_bad_nodes"`
	SkipLostPartitions bool               `thrift:"skip_lost_partitions,3" db:"skip_lost_partitions" json:"skip_lost_partitions"`
	HpRecoveryNodes    []*base.HostPort   `thrift:"hp_recovery_nodes,4" db:"hp_recovery_nodes" json:"hp_recovery_nodes,omitempty"`
}

func NewConfigurationRecoveryRequest() *ConfigurationRecoveryRequest {
	return &ConfigurationRecoveryRequest{}
}

func (p *ConfigurationRecoveryRequest) GetRecoveryNodes() []*base.RPCAddress {
	return p.RecoveryNodes
}

func (p *ConfigurationRecoveryRequest) GetSkipBadNodes() bool {
	return p.SkipBadNodes
}

func (p *ConfigurationRecoveryRequest) GetSkipLostPartitions() bool {
	return p.SkipLostPartitions
}

var ConfigurationRecoveryRequest_HpRecoveryNodes_DEFAULT []*base.HostPort

func (p *ConfigurationRecoveryRequest) GetHpRecoveryNodes() []*base.HostPort {
	return p.HpRecoveryNodes
}
func (p *ConfigurationRecoveryRequest) IsSetHpRecoveryNodes() bool {
	return p.HpRecoveryNodes != nil
}

func (p *ConfigurationRecoveryRequest) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.LIST {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.BOOL {
				if err := p.ReadField2(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 3:
			if fieldTypeId == thrift.BOOL {
				if err := p.ReadField3(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 4:
			if fieldTypeId == thrift.LIST {
				if err := p.ReadField4(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ConfigurationRecoveryRequest) ReadField1(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return thrift.PrependError("error reading list begin: ", err)
	}
	tSlice := make([]*base.RPCAddress, 0, size)
	p.RecoveryNodes = tSlice
	for i := 0; i < size; i++ {
		_elem5 := &base.RPCAddress{}
		if err := _elem5.Read(iprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem5), err)
		}
		p.RecoveryNodes = append(p.RecoveryNodes, _elem5)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return thrift.PrependError("error reading list end: ", err)
	}
	return nil
}

func (p *ConfigurationRecoveryRequest) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBool(); err != nil {
		return thrift.PrependError("error reading field 2: ", err)
	} else {
		p.SkipBadNodes = v
	}
	return nil
}

func (p *ConfigurationRecoveryRequest) ReadField3(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBool(); err != nil {
		return thrift.PrependError("error reading field 3: ", err)
	} else {
		p.SkipLostPartitions = v
	}
	return nil
}

func (p *ConfigurationRecoveryRequest) ReadField4(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return thrift.PrependError("error reading list begin: ", err)
	}
	tSlice := make([]*base.HostPort, 0, size)
	p.HpRecoveryNodes = tSlice
	for i := 0; i < size; i++ {
		_elem6 := &base.HostPort{}
		if err := _elem6.Read(iprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem6), err)
		}
		p.HpRecoveryNodes = append(p.HpRecoveryNodes, _elem6)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return thrift.PrependError("error reading list end: ", err)
	}
	return nil
}

func (p *ConfigurationRecoveryRequest) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("configuration_recovery_request"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		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 := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ConfigurationRecoveryRequest) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("recovery_nodes", thrift.LIST, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:recovery_nodes: ", p), err)
	}
	if err := oprot.WriteListBegin(thrift.STRUCT, len(p.RecoveryNodes)); err != nil {
		return thrift.PrependError("error writing list begin: ", err)
	}
	for _, v := range p.RecoveryNodes {
		if err := v.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", v), err)
		}
	}
	if err := oprot.WriteListEnd(); err != nil {
		return thrift.PrependError("error writing list end: ", err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:recovery_nodes: ", p), err)
	}
	return err
}

func (p *ConfigurationRecoveryRequest) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("skip_bad_nodes", thrift.BOOL, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:skip_bad_nodes: ", p), err)
	}
	if err := oprot.WriteBool(bool(p.SkipBadNodes)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.skip_bad_nodes (2) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:skip_bad_nodes: ", p), err)
	}
	return err
}

func (p *ConfigurationRecoveryRequest) writeField3(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("skip_lost_partitions", thrift.BOOL, 3); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:skip_lost_partitions: ", p), err)
	}
	if err := oprot.WriteBool(bool(p.SkipLostPartitions)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.skip_lost_partitions (3) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:skip_lost_partitions: ", p), err)
	}
	return err
}

func (p *ConfigurationRecoveryRequest) writeField4(oprot thrift.TProtocol) (err error) {
	if p.IsSetHpRecoveryNodes() {
		if err := oprot.WriteFieldBegin("hp_recovery_nodes", thrift.LIST, 4); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:hp_recovery_nodes: ", p), err)
		}
		if err := oprot.WriteListBegin(thrift.STRUCT, len(p.HpRecoveryNodes)); err != nil {
			return thrift.PrependError("error writing list begin: ", err)
		}
		for _, v := range p.HpRecoveryNodes {
			if err := v.Write(oprot); err != nil {
				return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", v), err)
			}
		}
		if err := oprot.WriteListEnd(); err != nil {
			return thrift.PrependError("error writing list end: ", err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 4:hp_recovery_nodes: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - Err
//  - HintMessage
type ConfigurationRecoveryResponse struct {
	Err         *base.ErrorCode `thrift:"err,1" db:"err" json:"err"`
	HintMessage string          `thrift:"hint_message,2" db:"hint_message" json:"hint_message"`
}

func NewConfigurationRecoveryResponse() *ConfigurationRecoveryResponse {
	return &ConfigurationRecoveryResponse{}
}

var ConfigurationRecoveryResponse_Err_DEFAULT *base.ErrorCode

func (p *ConfigurationRecoveryResponse) GetErr() *base.ErrorCode {
	if !p.IsSetErr() {
		return ConfigurationRecoveryResponse_Err_DEFAULT
	}
	return p.Err
}

func (p *ConfigurationRecoveryResponse) GetHintMessage() string {
	return p.HintMessage
}
func (p *ConfigurationRecoveryResponse) IsSetErr() bool {
	return p.Err != nil
}

func (p *ConfigurationRecoveryResponse) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.STRING {
				if err := p.ReadField2(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ConfigurationRecoveryResponse) ReadField1(iprot thrift.TProtocol) error {
	p.Err = &base.ErrorCode{}
	if err := p.Err.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Err), err)
	}
	return nil
}

func (p *ConfigurationRecoveryResponse) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return thrift.PrependError("error reading field 2: ", err)
	} else {
		p.HintMessage = v
	}
	return nil
}

func (p *ConfigurationRecoveryResponse) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("configuration_recovery_response"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		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 thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ConfigurationRecoveryResponse) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("err", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:err: ", p), err)
	}
	if err := p.Err.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Err), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:err: ", p), err)
	}
	return err
}

func (p *ConfigurationRecoveryResponse) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("hint_message", thrift.STRING, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:hint_message: ", p), err)
	}
	if err := oprot.WriteString(string(p.HintMessage)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.hint_message (2) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:hint_message: ", p), err)
	}
	return err
}

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

// Attributes:
//  - PartitionCount
//  - ReplicaCount
//  - SuccessIfExist
//  - AppType
//  - IsStateful
//  - Envs
//  - AtomicIdempotent
type CreateAppOptions struct {
	PartitionCount   int32             `thrift:"partition_count,1" db:"partition_count" json:"partition_count"`
	ReplicaCount     int32             `thrift:"replica_count,2" db:"replica_count" json:"replica_count"`
	SuccessIfExist   bool              `thrift:"success_if_exist,3" db:"success_if_exist" json:"success_if_exist"`
	AppType          string            `thrift:"app_type,4" db:"app_type" json:"app_type"`
	IsStateful       bool              `thrift:"is_stateful,5" db:"is_stateful" json:"is_stateful"`
	Envs             map[string]string `thrift:"envs,6" db:"envs" json:"envs"`
	AtomicIdempotent bool              `thrift:"atomic_idempotent,7" db:"atomic_idempotent" json:"atomic_idempotent"`
}

func NewCreateAppOptions() *CreateAppOptions {
	return &CreateAppOptions{}
}

func (p *CreateAppOptions) GetPartitionCount() int32 {
	return p.PartitionCount
}

func (p *CreateAppOptions) GetReplicaCount() int32 {
	return p.ReplicaCount
}

func (p *CreateAppOptions) GetSuccessIfExist() bool {
	return p.SuccessIfExist
}

func (p *CreateAppOptions) GetAppType() string {
	return p.AppType
}

func (p *CreateAppOptions) GetIsStateful() bool {
	return p.IsStateful
}

func (p *CreateAppOptions) GetEnvs() map[string]string {
	return p.Envs
}

var CreateAppOptions_AtomicIdempotent_DEFAULT bool = false

func (p *CreateAppOptions) GetAtomicIdempotent() bool {
	return p.AtomicIdempotent
}
func (p *CreateAppOptions) IsSetAtomicIdempotent() bool {
	return p.AtomicIdempotent != CreateAppOptions_AtomicIdempotent_DEFAULT
}

func (p *CreateAppOptions) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.I32 {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.I32 {
				if err := p.ReadField2(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 3:
			if fieldTypeId == thrift.BOOL {
				if err := p.ReadField3(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 4:
			if fieldTypeId == thrift.STRING {
				if err := p.ReadField4(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 5:
			if fieldTypeId == thrift.BOOL {
				if err := p.ReadField5(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 6:
			if fieldTypeId == thrift.MAP {
				if err := p.ReadField6(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 7:
			if fieldTypeId == thrift.BOOL {
				if err := p.ReadField7(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *CreateAppOptions) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return thrift.PrependError("error reading field 1: ", err)
	} else {
		p.PartitionCount = v
	}
	return nil
}

func (p *CreateAppOptions) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return thrift.PrependError("error reading field 2: ", err)
	} else {
		p.ReplicaCount = v
	}
	return nil
}

func (p *CreateAppOptions) ReadField3(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBool(); err != nil {
		return thrift.PrependError("error reading field 3: ", err)
	} else {
		p.SuccessIfExist = v
	}
	return nil
}

func (p *CreateAppOptions) ReadField4(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return thrift.PrependError("error reading field 4: ", err)
	} else {
		p.AppType = v
	}
	return nil
}

func (p *CreateAppOptions) ReadField5(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBool(); err != nil {
		return thrift.PrependError("error reading field 5: ", err)
	} else {
		p.IsStateful = v
	}
	return nil
}

func (p *CreateAppOptions) ReadField6(iprot thrift.TProtocol) error {
	_, _, size, err := iprot.ReadMapBegin()
	if err != nil {
		return thrift.PrependError("error reading map begin: ", err)
	}
	tMap := make(map[string]string, size)
	p.Envs = tMap
	for i := 0; i < size; i++ {
		var _key7 string
		if v, err := iprot.ReadString(); err != nil {
			return thrift.PrependError("error reading field 0: ", err)
		} else {
			_key7 = v
		}
		var _val8 string
		if v, err := iprot.ReadString(); err != nil {
			return thrift.PrependError("error reading field 0: ", err)
		} else {
			_val8 = v
		}
		p.Envs[_key7] = _val8
	}
	if err := iprot.ReadMapEnd(); err != nil {
		return thrift.PrependError("error reading map end: ", err)
	}
	return nil
}

func (p *CreateAppOptions) ReadField7(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBool(); err != nil {
		return thrift.PrependError("error reading field 7: ", err)
	} else {
		p.AtomicIdempotent = v
	}
	return nil
}

func (p *CreateAppOptions) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("create_app_options"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		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 := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *CreateAppOptions) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("partition_count", thrift.I32, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:partition_count: ", p), err)
	}
	if err := oprot.WriteI32(int32(p.PartitionCount)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.partition_count (1) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:partition_count: ", p), err)
	}
	return err
}

func (p *CreateAppOptions) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("replica_count", thrift.I32, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:replica_count: ", p), err)
	}
	if err := oprot.WriteI32(int32(p.ReplicaCount)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.replica_count (2) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:replica_count: ", p), err)
	}
	return err
}

func (p *CreateAppOptions) writeField3(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("success_if_exist", thrift.BOOL, 3); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:success_if_exist: ", p), err)
	}
	if err := oprot.WriteBool(bool(p.SuccessIfExist)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.success_if_exist (3) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:success_if_exist: ", p), err)
	}
	return err
}

func (p *CreateAppOptions) writeField4(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("app_type", thrift.STRING, 4); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:app_type: ", p), err)
	}
	if err := oprot.WriteString(string(p.AppType)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.app_type (4) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 4:app_type: ", p), err)
	}
	return err
}

func (p *CreateAppOptions) writeField5(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("is_stateful", thrift.BOOL, 5); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 5:is_stateful: ", p), err)
	}
	if err := oprot.WriteBool(bool(p.IsStateful)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.is_stateful (5) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 5:is_stateful: ", p), err)
	}
	return err
}

func (p *CreateAppOptions) writeField6(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("envs", thrift.MAP, 6); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 6:envs: ", p), err)
	}
	if err := oprot.WriteMapBegin(thrift.STRING, thrift.STRING, len(p.Envs)); err != nil {
		return thrift.PrependError("error writing map begin: ", err)
	}
	for k, v := range p.Envs {
		if err := oprot.WriteString(string(k)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
		}
		if err := oprot.WriteString(string(v)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
		}
	}
	if err := oprot.WriteMapEnd(); err != nil {
		return thrift.PrependError("error writing map end: ", err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 6:envs: ", p), err)
	}
	return err
}

func (p *CreateAppOptions) writeField7(oprot thrift.TProtocol) (err error) {
	if p.IsSetAtomicIdempotent() {
		if err := oprot.WriteFieldBegin("atomic_idempotent", thrift.BOOL, 7); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 7:atomic_idempotent: ", p), err)
		}
		if err := oprot.WriteBool(bool(p.AtomicIdempotent)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.atomic_idempotent (7) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 7:atomic_idempotent: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - AppName
//  - Options
type ConfigurationCreateAppRequest struct {
	AppName string            `thrift:"app_name,1" db:"app_name" json:"app_name"`
	Options *CreateAppOptions `thrift:"options,2" db:"options" json:"options"`
}

func NewConfigurationCreateAppRequest() *ConfigurationCreateAppRequest {
	return &ConfigurationCreateAppRequest{}
}

func (p *ConfigurationCreateAppRequest) GetAppName() string {
	return p.AppName
}

var ConfigurationCreateAppRequest_Options_DEFAULT *CreateAppOptions

func (p *ConfigurationCreateAppRequest) GetOptions() *CreateAppOptions {
	if !p.IsSetOptions() {
		return ConfigurationCreateAppRequest_Options_DEFAULT
	}
	return p.Options
}
func (p *ConfigurationCreateAppRequest) IsSetOptions() bool {
	return p.Options != nil
}

func (p *ConfigurationCreateAppRequest) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRING {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField2(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ConfigurationCreateAppRequest) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return thrift.PrependError("error reading field 1: ", err)
	} else {
		p.AppName = v
	}
	return nil
}

func (p *ConfigurationCreateAppRequest) ReadField2(iprot thrift.TProtocol) error {
	p.Options = &CreateAppOptions{}
	if err := p.Options.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Options), err)
	}
	return nil
}

func (p *ConfigurationCreateAppRequest) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("configuration_create_app_request"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		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 thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ConfigurationCreateAppRequest) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("app_name", thrift.STRING, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:app_name: ", p), err)
	}
	if err := oprot.WriteString(string(p.AppName)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.app_name (1) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:app_name: ", p), err)
	}
	return err
}

func (p *ConfigurationCreateAppRequest) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("options", thrift.STRUCT, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:options: ", p), err)
	}
	if err := p.Options.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Options), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:options: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Err
//  - Appid
type ConfigurationCreateAppResponse struct {
	Err   *base.ErrorCode `thrift:"err,1" db:"err" json:"err"`
	Appid int32           `thrift:"appid,2" db:"appid" json:"appid"`
}

func NewConfigurationCreateAppResponse() *ConfigurationCreateAppResponse {
	return &ConfigurationCreateAppResponse{}
}

var ConfigurationCreateAppResponse_Err_DEFAULT *base.ErrorCode

func (p *ConfigurationCreateAppResponse) GetErr() *base.ErrorCode {
	if !p.IsSetErr() {
		return ConfigurationCreateAppResponse_Err_DEFAULT
	}
	return p.Err
}

func (p *ConfigurationCreateAppResponse) GetAppid() int32 {
	return p.Appid
}
func (p *ConfigurationCreateAppResponse) IsSetErr() bool {
	return p.Err != nil
}

func (p *ConfigurationCreateAppResponse) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.I32 {
				if err := p.ReadField2(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ConfigurationCreateAppResponse) ReadField1(iprot thrift.TProtocol) error {
	p.Err = &base.ErrorCode{}
	if err := p.Err.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Err), err)
	}
	return nil
}

func (p *ConfigurationCreateAppResponse) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return thrift.PrependError("error reading field 2: ", err)
	} else {
		p.Appid = v
	}
	return nil
}

func (p *ConfigurationCreateAppResponse) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("configuration_create_app_response"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		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 thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ConfigurationCreateAppResponse) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("err", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:err: ", p), err)
	}
	if err := p.Err.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Err), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:err: ", p), err)
	}
	return err
}

func (p *ConfigurationCreateAppResponse) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("appid", thrift.I32, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:appid: ", p), err)
	}
	if err := oprot.WriteI32(int32(p.Appid)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.appid (2) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:appid: ", p), err)
	}
	return err
}

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

// Attributes:
//  - SuccessIfNotExist
//  - ReserveSeconds
type DropAppOptions struct {
	SuccessIfNotExist bool   `thrift:"success_if_not_exist,1" db:"success_if_not_exist" json:"success_if_not_exist"`
	ReserveSeconds    *int64 `thrift:"reserve_seconds,2" db:"reserve_seconds" json:"reserve_seconds,omitempty"`
}

func NewDropAppOptions() *DropAppOptions {
	return &DropAppOptions{}
}

func (p *DropAppOptions) GetSuccessIfNotExist() bool {
	return p.SuccessIfNotExist
}

var DropAppOptions_ReserveSeconds_DEFAULT int64

func (p *DropAppOptions) GetReserveSeconds() int64 {
	if !p.IsSetReserveSeconds() {
		return DropAppOptions_ReserveSeconds_DEFAULT
	}
	return *p.ReserveSeconds
}
func (p *DropAppOptions) IsSetReserveSeconds() bool {
	return p.ReserveSeconds != nil
}

func (p *DropAppOptions) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.BOOL {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.I64 {
				if err := p.ReadField2(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *DropAppOptions) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBool(); err != nil {
		return thrift.PrependError("error reading field 1: ", err)
	} else {
		p.SuccessIfNotExist = v
	}
	return nil
}

func (p *DropAppOptions) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI64(); err != nil {
		return thrift.PrependError("error reading field 2: ", err)
	} else {
		p.ReserveSeconds = &v
	}
	return nil
}

func (p *DropAppOptions) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("drop_app_options"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		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 thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *DropAppOptions) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("success_if_not_exist", thrift.BOOL, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:success_if_not_exist: ", p), err)
	}
	if err := oprot.WriteBool(bool(p.SuccessIfNotExist)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.success_if_not_exist (1) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:success_if_not_exist: ", p), err)
	}
	return err
}

func (p *DropAppOptions) writeField2(oprot thrift.TProtocol) (err error) {
	if p.IsSetReserveSeconds() {
		if err := oprot.WriteFieldBegin("reserve_seconds", thrift.I64, 2); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:reserve_seconds: ", p), err)
		}
		if err := oprot.WriteI64(int64(*p.ReserveSeconds)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.reserve_seconds (2) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 2:reserve_seconds: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - AppName
//  - Options
type ConfigurationDropAppRequest struct {
	AppName string          `thrift:"app_name,1" db:"app_name" json:"app_name"`
	Options *DropAppOptions `thrift:"options,2" db:"options" json:"options"`
}

func NewConfigurationDropAppRequest() *ConfigurationDropAppRequest {
	return &ConfigurationDropAppRequest{}
}

func (p *ConfigurationDropAppRequest) GetAppName() string {
	return p.AppName
}

var ConfigurationDropAppRequest_Options_DEFAULT *DropAppOptions

func (p *ConfigurationDropAppRequest) GetOptions() *DropAppOptions {
	if !p.IsSetOptions() {
		return ConfigurationDropAppRequest_Options_DEFAULT
	}
	return p.Options
}
func (p *ConfigurationDropAppRequest) IsSetOptions() bool {
	return p.Options != nil
}

func (p *ConfigurationDropAppRequest) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRING {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField2(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ConfigurationDropAppRequest) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return thrift.PrependError("error reading field 1: ", err)
	} else {
		p.AppName = v
	}
	return nil
}

func (p *ConfigurationDropAppRequest) ReadField2(iprot thrift.TProtocol) error {
	p.Options = &DropAppOptions{}
	if err := p.Options.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Options), err)
	}
	return nil
}

func (p *ConfigurationDropAppRequest) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("configuration_drop_app_request"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		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 thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ConfigurationDropAppRequest) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("app_name", thrift.STRING, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:app_name: ", p), err)
	}
	if err := oprot.WriteString(string(p.AppName)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.app_name (1) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:app_name: ", p), err)
	}
	return err
}

func (p *ConfigurationDropAppRequest) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("options", thrift.STRUCT, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:options: ", p), err)
	}
	if err := p.Options.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Options), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:options: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Err
type ConfigurationDropAppResponse struct {
	Err *base.ErrorCode `thrift:"err,1" db:"err" json:"err"`
}

func NewConfigurationDropAppResponse() *ConfigurationDropAppResponse {
	return &ConfigurationDropAppResponse{}
}

var ConfigurationDropAppResponse_Err_DEFAULT *base.ErrorCode

func (p *ConfigurationDropAppResponse) GetErr() *base.ErrorCode {
	if !p.IsSetErr() {
		return ConfigurationDropAppResponse_Err_DEFAULT
	}
	return p.Err
}
func (p *ConfigurationDropAppResponse) IsSetErr() bool {
	return p.Err != nil
}

func (p *ConfigurationDropAppResponse) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ConfigurationDropAppResponse) ReadField1(iprot thrift.TProtocol) error {
	p.Err = &base.ErrorCode{}
	if err := p.Err.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Err), err)
	}
	return nil
}

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

func (p *ConfigurationDropAppResponse) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("err", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:err: ", p), err)
	}
	if err := p.Err.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Err), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:err: ", p), err)
	}
	return err
}

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

// Attributes:
//  - OldAppName
//  - NewAppName_
type ConfigurationRenameAppRequest struct {
	OldAppName  string `thrift:"old_app_name,1" db:"old_app_name" json:"old_app_name"`
	NewAppName_ string `thrift:"new_app_name,2" db:"new_app_name" json:"new_app_name"`
}

func NewConfigurationRenameAppRequest() *ConfigurationRenameAppRequest {
	return &ConfigurationRenameAppRequest{}
}

func (p *ConfigurationRenameAppRequest) GetOldAppName() string {
	return p.OldAppName
}

func (p *ConfigurationRenameAppRequest) GetNewAppName_() string {
	return p.NewAppName_
}
func (p *ConfigurationRenameAppRequest) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRING {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.STRING {
				if err := p.ReadField2(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ConfigurationRenameAppRequest) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return thrift.PrependError("error reading field 1: ", err)
	} else {
		p.OldAppName = v
	}
	return nil
}

func (p *ConfigurationRenameAppRequest) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return thrift.PrependError("error reading field 2: ", err)
	} else {
		p.NewAppName_ = v
	}
	return nil
}

func (p *ConfigurationRenameAppRequest) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("configuration_rename_app_request"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		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 thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ConfigurationRenameAppRequest) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("old_app_name", thrift.STRING, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:old_app_name: ", p), err)
	}
	if err := oprot.WriteString(string(p.OldAppName)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.old_app_name (1) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:old_app_name: ", p), err)
	}
	return err
}

func (p *ConfigurationRenameAppRequest) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("new_app_name", thrift.STRING, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:new_app_name: ", p), err)
	}
	if err := oprot.WriteString(string(p.NewAppName_)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.new_app_name (2) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:new_app_name: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Err
//  - HintMessage
type ConfigurationRenameAppResponse struct {
	Err         *base.ErrorCode `thrift:"err,1" db:"err" json:"err"`
	HintMessage string          `thrift:"hint_message,2" db:"hint_message" json:"hint_message"`
}

func NewConfigurationRenameAppResponse() *ConfigurationRenameAppResponse {
	return &ConfigurationRenameAppResponse{}
}

var ConfigurationRenameAppResponse_Err_DEFAULT *base.ErrorCode

func (p *ConfigurationRenameAppResponse) GetErr() *base.ErrorCode {
	if !p.IsSetErr() {
		return ConfigurationRenameAppResponse_Err_DEFAULT
	}
	return p.Err
}

func (p *ConfigurationRenameAppResponse) GetHintMessage() string {
	return p.HintMessage
}
func (p *ConfigurationRenameAppResponse) IsSetErr() bool {
	return p.Err != nil
}

func (p *ConfigurationRenameAppResponse) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.STRING {
				if err := p.ReadField2(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ConfigurationRenameAppResponse) ReadField1(iprot thrift.TProtocol) error {
	p.Err = &base.ErrorCode{}
	if err := p.Err.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Err), err)
	}
	return nil
}

func (p *ConfigurationRenameAppResponse) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return thrift.PrependError("error reading field 2: ", err)
	} else {
		p.HintMessage = v
	}
	return nil
}

func (p *ConfigurationRenameAppResponse) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("configuration_rename_app_response"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		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 thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ConfigurationRenameAppResponse) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("err", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:err: ", p), err)
	}
	if err := p.Err.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Err), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:err: ", p), err)
	}
	return err
}

func (p *ConfigurationRenameAppResponse) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("hint_message", thrift.STRING, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:hint_message: ", p), err)
	}
	if err := oprot.WriteString(string(p.HintMessage)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.hint_message (2) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:hint_message: ", p), err)
	}
	return err
}

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

// Attributes:
//  - AppID
//  - NewAppName_
type ConfigurationRecallAppRequest struct {
	AppID       int32  `thrift:"app_id,1" db:"app_id" json:"app_id"`
	NewAppName_ string `thrift:"new_app_name,2" db:"new_app_name" json:"new_app_name"`
}

func NewConfigurationRecallAppRequest() *ConfigurationRecallAppRequest {
	return &ConfigurationRecallAppRequest{}
}

func (p *ConfigurationRecallAppRequest) GetAppID() int32 {
	return p.AppID
}

func (p *ConfigurationRecallAppRequest) GetNewAppName_() string {
	return p.NewAppName_
}
func (p *ConfigurationRecallAppRequest) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.I32 {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.STRING {
				if err := p.ReadField2(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ConfigurationRecallAppRequest) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return thrift.PrependError("error reading field 1: ", err)
	} else {
		p.AppID = v
	}
	return nil
}

func (p *ConfigurationRecallAppRequest) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return thrift.PrependError("error reading field 2: ", err)
	} else {
		p.NewAppName_ = v
	}
	return nil
}

func (p *ConfigurationRecallAppRequest) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("configuration_recall_app_request"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		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 thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ConfigurationRecallAppRequest) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("app_id", thrift.I32, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:app_id: ", p), err)
	}
	if err := oprot.WriteI32(int32(p.AppID)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.app_id (1) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:app_id: ", p), err)
	}
	return err
}

func (p *ConfigurationRecallAppRequest) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("new_app_name", thrift.STRING, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:new_app_name: ", p), err)
	}
	if err := oprot.WriteString(string(p.NewAppName_)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.new_app_name (2) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:new_app_name: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Err
//  - Info
type ConfigurationRecallAppResponse struct {
	Err  *base.ErrorCode      `thrift:"err,1" db:"err" json:"err"`
	Info *replication.AppInfo `thrift:"info,2" db:"info" json:"info"`
}

func NewConfigurationRecallAppResponse() *ConfigurationRecallAppResponse {
	return &ConfigurationRecallAppResponse{}
}

var ConfigurationRecallAppResponse_Err_DEFAULT *base.ErrorCode

func (p *ConfigurationRecallAppResponse) GetErr() *base.ErrorCode {
	if !p.IsSetErr() {
		return ConfigurationRecallAppResponse_Err_DEFAULT
	}
	return p.Err
}

var ConfigurationRecallAppResponse_Info_DEFAULT *replication.AppInfo

func (p *ConfigurationRecallAppResponse) GetInfo() *replication.AppInfo {
	if !p.IsSetInfo() {
		return ConfigurationRecallAppResponse_Info_DEFAULT
	}
	return p.Info
}
func (p *ConfigurationRecallAppResponse) IsSetErr() bool {
	return p.Err != nil
}

func (p *ConfigurationRecallAppResponse) IsSetInfo() bool {
	return p.Info != nil
}

func (p *ConfigurationRecallAppResponse) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField2(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ConfigurationRecallAppResponse) ReadField1(iprot thrift.TProtocol) error {
	p.Err = &base.ErrorCode{}
	if err := p.Err.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Err), err)
	}
	return nil
}

func (p *ConfigurationRecallAppResponse) ReadField2(iprot thrift.TProtocol) error {
	p.Info = &replication.AppInfo{
		Status: 0,

		InitPartitionCount: -1,
	}
	if err := p.Info.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Info), err)
	}
	return nil
}

func (p *ConfigurationRecallAppResponse) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("configuration_recall_app_response"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		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 thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ConfigurationRecallAppResponse) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("err", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:err: ", p), err)
	}
	if err := p.Err.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Err), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:err: ", p), err)
	}
	return err
}

func (p *ConfigurationRecallAppResponse) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("info", thrift.STRUCT, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:info: ", p), err)
	}
	if err := p.Info.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Info), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:info: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Status
//  - AppNamePattern
//  - MatchType
type ConfigurationListAppsRequest struct {
	Status         replication.AppStatus   `thrift:"status,1" db:"status" json:"status"`
	AppNamePattern *string                 `thrift:"app_name_pattern,2" db:"app_name_pattern" json:"app_name_pattern,omitempty"`
	MatchType      *utils.PatternMatchType `thrift:"match_type,3" db:"match_type" json:"match_type,omitempty"`
}

func NewConfigurationListAppsRequest() *ConfigurationListAppsRequest {
	return &ConfigurationListAppsRequest{
		Status: 0,
	}
}

func (p *ConfigurationListAppsRequest) GetStatus() replication.AppStatus {
	return p.Status
}

var ConfigurationListAppsRequest_AppNamePattern_DEFAULT string

func (p *ConfigurationListAppsRequest) GetAppNamePattern() string {
	if !p.IsSetAppNamePattern() {
		return ConfigurationListAppsRequest_AppNamePattern_DEFAULT
	}
	return *p.AppNamePattern
}

var ConfigurationListAppsRequest_MatchType_DEFAULT utils.PatternMatchType

func (p *ConfigurationListAppsRequest) GetMatchType() utils.PatternMatchType {
	if !p.IsSetMatchType() {
		return ConfigurationListAppsRequest_MatchType_DEFAULT
	}
	return *p.MatchType
}
func (p *ConfigurationListAppsRequest) IsSetAppNamePattern() bool {
	return p.AppNamePattern != nil
}

func (p *ConfigurationListAppsRequest) IsSetMatchType() bool {
	return p.MatchType != nil
}

func (p *ConfigurationListAppsRequest) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.I32 {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.STRING {
				if err := p.ReadField2(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 3:
			if fieldTypeId == thrift.I32 {
				if err := p.ReadField3(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ConfigurationListAppsRequest) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return thrift.PrependError("error reading field 1: ", err)
	} else {
		temp := replication.AppStatus(v)
		p.Status = temp
	}
	return nil
}

func (p *ConfigurationListAppsRequest) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return thrift.PrependError("error reading field 2: ", err)
	} else {
		p.AppNamePattern = &v
	}
	return nil
}

func (p *ConfigurationListAppsRequest) ReadField3(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return thrift.PrependError("error reading field 3: ", err)
	} else {
		temp := utils.PatternMatchType(v)
		p.MatchType = &temp
	}
	return nil
}

func (p *ConfigurationListAppsRequest) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("configuration_list_apps_request"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		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 := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ConfigurationListAppsRequest) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("status", thrift.I32, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:status: ", p), err)
	}
	if err := oprot.WriteI32(int32(p.Status)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.status (1) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:status: ", p), err)
	}
	return err
}

func (p *ConfigurationListAppsRequest) writeField2(oprot thrift.TProtocol) (err error) {
	if p.IsSetAppNamePattern() {
		if err := oprot.WriteFieldBegin("app_name_pattern", thrift.STRING, 2); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:app_name_pattern: ", p), err)
		}
		if err := oprot.WriteString(string(*p.AppNamePattern)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.app_name_pattern (2) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 2:app_name_pattern: ", p), err)
		}
	}
	return err
}

func (p *ConfigurationListAppsRequest) writeField3(oprot thrift.TProtocol) (err error) {
	if p.IsSetMatchType() {
		if err := oprot.WriteFieldBegin("match_type", thrift.I32, 3); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:match_type: ", p), err)
		}
		if err := oprot.WriteI32(int32(*p.MatchType)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.match_type (3) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 3:match_type: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - Err
//  - Infos
//  - HintMessage
type ConfigurationListAppsResponse struct {
	Err         *base.ErrorCode        `thrift:"err,1" db:"err" json:"err"`
	Infos       []*replication.AppInfo `thrift:"infos,2" db:"infos" json:"infos"`
	HintMessage *string                `thrift:"hint_message,3" db:"hint_message" json:"hint_message,omitempty"`
}

func NewConfigurationListAppsResponse() *ConfigurationListAppsResponse {
	return &ConfigurationListAppsResponse{}
}

var ConfigurationListAppsResponse_Err_DEFAULT *base.ErrorCode

func (p *ConfigurationListAppsResponse) GetErr() *base.ErrorCode {
	if !p.IsSetErr() {
		return ConfigurationListAppsResponse_Err_DEFAULT
	}
	return p.Err
}

func (p *ConfigurationListAppsResponse) GetInfos() []*replication.AppInfo {
	return p.Infos
}

var ConfigurationListAppsResponse_HintMessage_DEFAULT string

func (p *ConfigurationListAppsResponse) GetHintMessage() string {
	if !p.IsSetHintMessage() {
		return ConfigurationListAppsResponse_HintMessage_DEFAULT
	}
	return *p.HintMessage
}
func (p *ConfigurationListAppsResponse) IsSetErr() bool {
	return p.Err != nil
}

func (p *ConfigurationListAppsResponse) IsSetHintMessage() bool {
	return p.HintMessage != nil
}

func (p *ConfigurationListAppsResponse) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.LIST {
				if err := p.ReadField2(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 3:
			if fieldTypeId == thrift.STRING {
				if err := p.ReadField3(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ConfigurationListAppsResponse) ReadField1(iprot thrift.TProtocol) error {
	p.Err = &base.ErrorCode{}
	if err := p.Err.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Err), err)
	}
	return nil
}

func (p *ConfigurationListAppsResponse) ReadField2(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return thrift.PrependError("error reading list begin: ", err)
	}
	tSlice := make([]*replication.AppInfo, 0, size)
	p.Infos = tSlice
	for i := 0; i < size; i++ {
		_elem9 := &replication.AppInfo{
			Status: 0,

			InitPartitionCount: -1,
		}
		if err := _elem9.Read(iprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem9), err)
		}
		p.Infos = append(p.Infos, _elem9)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return thrift.PrependError("error reading list end: ", err)
	}
	return nil
}

func (p *ConfigurationListAppsResponse) ReadField3(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return thrift.PrependError("error reading field 3: ", err)
	} else {
		p.HintMessage = &v
	}
	return nil
}

func (p *ConfigurationListAppsResponse) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("configuration_list_apps_response"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		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 := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ConfigurationListAppsResponse) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("err", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:err: ", p), err)
	}
	if err := p.Err.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Err), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:err: ", p), err)
	}
	return err
}

func (p *ConfigurationListAppsResponse) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("infos", thrift.LIST, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:infos: ", p), err)
	}
	if err := oprot.WriteListBegin(thrift.STRUCT, len(p.Infos)); err != nil {
		return thrift.PrependError("error writing list begin: ", err)
	}
	for _, v := range p.Infos {
		if err := v.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", v), err)
		}
	}
	if err := oprot.WriteListEnd(); err != nil {
		return thrift.PrependError("error writing list end: ", err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:infos: ", p), err)
	}
	return err
}

func (p *ConfigurationListAppsResponse) writeField3(oprot thrift.TProtocol) (err error) {
	if p.IsSetHintMessage() {
		if err := oprot.WriteFieldBegin("hint_message", thrift.STRING, 3); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:hint_message: ", p), err)
		}
		if err := oprot.WriteString(string(*p.HintMessage)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.hint_message (3) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 3:hint_message: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - MetaServer
//  - HpMetaServer
type QueryAppInfoRequest struct {
	MetaServer   *base.RPCAddress `thrift:"meta_server,1" db:"meta_server" json:"meta_server"`
	HpMetaServer *base.HostPort   `thrift:"hp_meta_server,2" db:"hp_meta_server" json:"hp_meta_server,omitempty"`
}

func NewQueryAppInfoRequest() *QueryAppInfoRequest {
	return &QueryAppInfoRequest{}
}

var QueryAppInfoRequest_MetaServer_DEFAULT *base.RPCAddress

func (p *QueryAppInfoRequest) GetMetaServer() *base.RPCAddress {
	if !p.IsSetMetaServer() {
		return QueryAppInfoRequest_MetaServer_DEFAULT
	}
	return p.MetaServer
}

var QueryAppInfoRequest_HpMetaServer_DEFAULT *base.HostPort

func (p *QueryAppInfoRequest) GetHpMetaServer() *base.HostPort {
	if !p.IsSetHpMetaServer() {
		return QueryAppInfoRequest_HpMetaServer_DEFAULT
	}
	return p.HpMetaServer
}
func (p *QueryAppInfoRequest) IsSetMetaServer() bool {
	return p.MetaServer != nil
}

func (p *QueryAppInfoRequest) IsSetHpMetaServer() bool {
	return p.HpMetaServer != nil
}

func (p *QueryAppInfoRequest) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField2(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *QueryAppInfoRequest) ReadField1(iprot thrift.TProtocol) error {
	p.MetaServer = &base.RPCAddress{}
	if err := p.MetaServer.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.MetaServer), err)
	}
	return nil
}

func (p *QueryAppInfoRequest) ReadField2(iprot thrift.TProtocol) error {
	p.HpMetaServer = &base.HostPort{}
	if err := p.HpMetaServer.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.HpMetaServer), err)
	}
	return nil
}

func (p *QueryAppInfoRequest) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("query_app_info_request"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		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 thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *QueryAppInfoRequest) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("meta_server", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:meta_server: ", p), err)
	}
	if err := p.MetaServer.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.MetaServer), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:meta_server: ", p), err)
	}
	return err
}

func (p *QueryAppInfoRequest) writeField2(oprot thrift.TProtocol) (err error) {
	if p.IsSetHpMetaServer() {
		if err := oprot.WriteFieldBegin("hp_meta_server", thrift.STRUCT, 2); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:hp_meta_server: ", p), err)
		}
		if err := p.HpMetaServer.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.HpMetaServer), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 2:hp_meta_server: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - Err
//  - Apps
type QueryAppInfoResponse struct {
	Err  *base.ErrorCode        `thrift:"err,1" db:"err" json:"err"`
	Apps []*replication.AppInfo `thrift:"apps,2" db:"apps" json:"apps"`
}

func NewQueryAppInfoResponse() *QueryAppInfoResponse {
	return &QueryAppInfoResponse{}
}

var QueryAppInfoResponse_Err_DEFAULT *base.ErrorCode

func (p *QueryAppInfoResponse) GetErr() *base.ErrorCode {
	if !p.IsSetErr() {
		return QueryAppInfoResponse_Err_DEFAULT
	}
	return p.Err
}

func (p *QueryAppInfoResponse) GetApps() []*replication.AppInfo {
	return p.Apps
}
func (p *QueryAppInfoResponse) IsSetErr() bool {
	return p.Err != nil
}

func (p *QueryAppInfoResponse) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.LIST {
				if err := p.ReadField2(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *QueryAppInfoResponse) ReadField1(iprot thrift.TProtocol) error {
	p.Err = &base.ErrorCode{}
	if err := p.Err.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Err), err)
	}
	return nil
}

func (p *QueryAppInfoResponse) ReadField2(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return thrift.PrependError("error reading list begin: ", err)
	}
	tSlice := make([]*replication.AppInfo, 0, size)
	p.Apps = tSlice
	for i := 0; i < size; i++ {
		_elem10 := &replication.AppInfo{
			Status: 0,

			InitPartitionCount: -1,
		}
		if err := _elem10.Read(iprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem10), err)
		}
		p.Apps = append(p.Apps, _elem10)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return thrift.PrependError("error reading list end: ", err)
	}
	return nil
}

func (p *QueryAppInfoResponse) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("query_app_info_response"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		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 thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *QueryAppInfoResponse) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("err", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:err: ", p), err)
	}
	if err := p.Err.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Err), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:err: ", p), err)
	}
	return err
}

func (p *QueryAppInfoResponse) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("apps", thrift.LIST, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:apps: ", p), err)
	}
	if err := oprot.WriteListBegin(thrift.STRUCT, len(p.Apps)); err != nil {
		return thrift.PrependError("error writing list begin: ", err)
	}
	for _, v := range p.Apps {
		if err := v.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", v), err)
		}
	}
	if err := oprot.WriteListEnd(); err != nil {
		return thrift.PrependError("error writing list end: ", err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:apps: ", p), err)
	}
	return err
}

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

// Attributes:
//  - AppName
//  - Op
//  - Keys
//  - Values
//  - ClearPrefix
type ConfigurationUpdateAppEnvRequest struct {
	AppName     string          `thrift:"app_name,1" db:"app_name" json:"app_name"`
	Op          AppEnvOperation `thrift:"op,2" db:"op" json:"op"`
	Keys        []string        `thrift:"keys,3" db:"keys" json:"keys,omitempty"`
	Values      []string        `thrift:"values,4" db:"values" json:"values,omitempty"`
	ClearPrefix *string         `thrift:"clear_prefix,5" db:"clear_prefix" json:"clear_prefix,omitempty"`
}

func NewConfigurationUpdateAppEnvRequest() *ConfigurationUpdateAppEnvRequest {
	return &ConfigurationUpdateAppEnvRequest{
		Op: 0,
	}
}

func (p *ConfigurationUpdateAppEnvRequest) GetAppName() string {
	return p.AppName
}

func (p *ConfigurationUpdateAppEnvRequest) GetOp() AppEnvOperation {
	return p.Op
}

var ConfigurationUpdateAppEnvRequest_Keys_DEFAULT []string

func (p *ConfigurationUpdateAppEnvRequest) GetKeys() []string {
	return p.Keys
}

var ConfigurationUpdateAppEnvRequest_Values_DEFAULT []string

func (p *ConfigurationUpdateAppEnvRequest) GetValues() []string {
	return p.Values
}

var ConfigurationUpdateAppEnvRequest_ClearPrefix_DEFAULT string

func (p *ConfigurationUpdateAppEnvRequest) GetClearPrefix() string {
	if !p.IsSetClearPrefix() {
		return ConfigurationUpdateAppEnvRequest_ClearPrefix_DEFAULT
	}
	return *p.ClearPrefix
}
func (p *ConfigurationUpdateAppEnvRequest) IsSetKeys() bool {
	return p.Keys != nil
}

func (p *ConfigurationUpdateAppEnvRequest) IsSetValues() bool {
	return p.Values != nil
}

func (p *ConfigurationUpdateAppEnvRequest) IsSetClearPrefix() bool {
	return p.ClearPrefix != nil
}

func (p *ConfigurationUpdateAppEnvRequest) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRING {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.I32 {
				if err := p.ReadField2(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 3:
			if fieldTypeId == thrift.LIST {
				if err := p.ReadField3(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 4:
			if fieldTypeId == thrift.LIST {
				if err := p.ReadField4(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 5:
			if fieldTypeId == thrift.STRING {
				if err := p.ReadField5(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ConfigurationUpdateAppEnvRequest) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return thrift.PrependError("error reading field 1: ", err)
	} else {
		p.AppName = v
	}
	return nil
}

func (p *ConfigurationUpdateAppEnvRequest) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return thrift.PrependError("error reading field 2: ", err)
	} else {
		temp := AppEnvOperation(v)
		p.Op = temp
	}
	return nil
}

func (p *ConfigurationUpdateAppEnvRequest) ReadField3(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return thrift.PrependError("error reading list begin: ", err)
	}
	tSlice := make([]string, 0, size)
	p.Keys = tSlice
	for i := 0; i < size; i++ {
		var _elem11 string
		if v, err := iprot.ReadString(); err != nil {
			return thrift.PrependError("error reading field 0: ", err)
		} else {
			_elem11 = v
		}
		p.Keys = append(p.Keys, _elem11)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return thrift.PrependError("error reading list end: ", err)
	}
	return nil
}

func (p *ConfigurationUpdateAppEnvRequest) ReadField4(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return thrift.PrependError("error reading list begin: ", err)
	}
	tSlice := make([]string, 0, size)
	p.Values = tSlice
	for i := 0; i < size; i++ {
		var _elem12 string
		if v, err := iprot.ReadString(); err != nil {
			return thrift.PrependError("error reading field 0: ", err)
		} else {
			_elem12 = v
		}
		p.Values = append(p.Values, _elem12)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return thrift.PrependError("error reading list end: ", err)
	}
	return nil
}

func (p *ConfigurationUpdateAppEnvRequest) ReadField5(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return thrift.PrependError("error reading field 5: ", err)
	} else {
		p.ClearPrefix = &v
	}
	return nil
}

func (p *ConfigurationUpdateAppEnvRequest) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("configuration_update_app_env_request"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		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 thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ConfigurationUpdateAppEnvRequest) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("app_name", thrift.STRING, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:app_name: ", p), err)
	}
	if err := oprot.WriteString(string(p.AppName)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.app_name (1) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:app_name: ", p), err)
	}
	return err
}

func (p *ConfigurationUpdateAppEnvRequest) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("op", thrift.I32, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:op: ", p), err)
	}
	if err := oprot.WriteI32(int32(p.Op)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.op (2) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:op: ", p), err)
	}
	return err
}

func (p *ConfigurationUpdateAppEnvRequest) writeField3(oprot thrift.TProtocol) (err error) {
	if p.IsSetKeys() {
		if err := oprot.WriteFieldBegin("keys", thrift.LIST, 3); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:keys: ", p), err)
		}
		if err := oprot.WriteListBegin(thrift.STRING, len(p.Keys)); err != nil {
			return thrift.PrependError("error writing list begin: ", err)
		}
		for _, v := range p.Keys {
			if err := oprot.WriteString(string(v)); err != nil {
				return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
			}
		}
		if err := oprot.WriteListEnd(); err != nil {
			return thrift.PrependError("error writing list end: ", err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 3:keys: ", p), err)
		}
	}
	return err
}

func (p *ConfigurationUpdateAppEnvRequest) writeField4(oprot thrift.TProtocol) (err error) {
	if p.IsSetValues() {
		if err := oprot.WriteFieldBegin("values", thrift.LIST, 4); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:values: ", p), err)
		}
		if err := oprot.WriteListBegin(thrift.STRING, len(p.Values)); err != nil {
			return thrift.PrependError("error writing list begin: ", err)
		}
		for _, v := range p.Values {
			if err := oprot.WriteString(string(v)); err != nil {
				return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
			}
		}
		if err := oprot.WriteListEnd(); err != nil {
			return thrift.PrependError("error writing list end: ", err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 4:values: ", p), err)
		}
	}
	return err
}

func (p *ConfigurationUpdateAppEnvRequest) writeField5(oprot thrift.TProtocol) (err error) {
	if p.IsSetClearPrefix() {
		if err := oprot.WriteFieldBegin("clear_prefix", thrift.STRING, 5); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 5:clear_prefix: ", p), err)
		}
		if err := oprot.WriteString(string(*p.ClearPrefix)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.clear_prefix (5) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 5:clear_prefix: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - Err
//  - HintMessage
type ConfigurationUpdateAppEnvResponse struct {
	Err         *base.ErrorCode `thrift:"err,1" db:"err" json:"err"`
	HintMessage string          `thrift:"hint_message,2" db:"hint_message" json:"hint_message"`
}

func NewConfigurationUpdateAppEnvResponse() *ConfigurationUpdateAppEnvResponse {
	return &ConfigurationUpdateAppEnvResponse{}
}

var ConfigurationUpdateAppEnvResponse_Err_DEFAULT *base.ErrorCode

func (p *ConfigurationUpdateAppEnvResponse) GetErr() *base.ErrorCode {
	if !p.IsSetErr() {
		return ConfigurationUpdateAppEnvResponse_Err_DEFAULT
	}
	return p.Err
}

func (p *ConfigurationUpdateAppEnvResponse) GetHintMessage() string {
	return p.HintMessage
}
func (p *ConfigurationUpdateAppEnvResponse) IsSetErr() bool {
	return p.Err != nil
}

func (p *ConfigurationUpdateAppEnvResponse) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.STRING {
				if err := p.ReadField2(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ConfigurationUpdateAppEnvResponse) ReadField1(iprot thrift.TProtocol) error {
	p.Err = &base.ErrorCode{}
	if err := p.Err.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Err), err)
	}
	return nil
}

func (p *ConfigurationUpdateAppEnvResponse) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return thrift.PrependError("error reading field 2: ", err)
	} else {
		p.HintMessage = v
	}
	return nil
}

func (p *ConfigurationUpdateAppEnvResponse) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("configuration_update_app_env_response"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		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 thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ConfigurationUpdateAppEnvResponse) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("err", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:err: ", p), err)
	}
	if err := p.Err.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Err), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:err: ", p), err)
	}
	return err
}

func (p *ConfigurationUpdateAppEnvResponse) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("hint_message", thrift.STRING, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:hint_message: ", p), err)
	}
	if err := oprot.WriteString(string(p.HintMessage)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.hint_message (2) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:hint_message: ", p), err)
	}
	return err
}

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

// Attributes:
//  - AppName
//  - TriggerTime
//  - TargetLevel
//  - Bottommost
//  - MaxRunningCount
type StartAppManualCompactRequest struct {
	AppName         string `thrift:"app_name,1" db:"app_name" json:"app_name"`
	TriggerTime     *int64 `thrift:"trigger_time,2" db:"trigger_time" json:"trigger_time,omitempty"`
	TargetLevel     *int32 `thrift:"target_level,3" db:"target_level" json:"target_level,omitempty"`
	Bottommost      *bool  `thrift:"bottommost,4" db:"bottommost" json:"bottommost,omitempty"`
	MaxRunningCount *int32 `thrift:"max_running_count,5" db:"max_running_count" json:"max_running_count,omitempty"`
}

func NewStartAppManualCompactRequest() *StartAppManualCompactRequest {
	return &StartAppManualCompactRequest{}
}

func (p *StartAppManualCompactRequest) GetAppName() string {
	return p.AppName
}

var StartAppManualCompactRequest_TriggerTime_DEFAULT int64

func (p *StartAppManualCompactRequest) GetTriggerTime() int64 {
	if !p.IsSetTriggerTime() {
		return StartAppManualCompactRequest_TriggerTime_DEFAULT
	}
	return *p.TriggerTime
}

var StartAppManualCompactRequest_TargetLevel_DEFAULT int32

func (p *StartAppManualCompactRequest) GetTargetLevel() int32 {
	if !p.IsSetTargetLevel() {
		return StartAppManualCompactRequest_TargetLevel_DEFAULT
	}
	return *p.TargetLevel
}

var StartAppManualCompactRequest_Bottommost_DEFAULT bool

func (p *StartAppManualCompactRequest) GetBottommost() bool {
	if !p.IsSetBottommost() {
		return StartAppManualCompactRequest_Bottommost_DEFAULT
	}
	return *p.Bottommost
}

var StartAppManualCompactRequest_MaxRunningCount_DEFAULT int32

func (p *StartAppManualCompactRequest) GetMaxRunningCount() int32 {
	if !p.IsSetMaxRunningCount() {
		return StartAppManualCompactRequest_MaxRunningCount_DEFAULT
	}
	return *p.MaxRunningCount
}
func (p *StartAppManualCompactRequest) IsSetTriggerTime() bool {
	return p.TriggerTime != nil
}

func (p *StartAppManualCompactRequest) IsSetTargetLevel() bool {
	return p.TargetLevel != nil
}

func (p *StartAppManualCompactRequest) IsSetBottommost() bool {
	return p.Bottommost != nil
}

func (p *StartAppManualCompactRequest) IsSetMaxRunningCount() bool {
	return p.MaxRunningCount != nil
}

func (p *StartAppManualCompactRequest) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRING {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.I64 {
				if err := p.ReadField2(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 3:
			if fieldTypeId == thrift.I32 {
				if err := p.ReadField3(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 4:
			if fieldTypeId == thrift.BOOL {
				if err := p.ReadField4(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 5:
			if fieldTypeId == thrift.I32 {
				if err := p.ReadField5(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *StartAppManualCompactRequest) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return thrift.PrependError("error reading field 1: ", err)
	} else {
		p.AppName = v
	}
	return nil
}

func (p *StartAppManualCompactRequest) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI64(); err != nil {
		return thrift.PrependError("error reading field 2: ", err)
	} else {
		p.TriggerTime = &v
	}
	return nil
}

func (p *StartAppManualCompactRequest) ReadField3(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return thrift.PrependError("error reading field 3: ", err)
	} else {
		p.TargetLevel = &v
	}
	return nil
}

func (p *StartAppManualCompactRequest) ReadField4(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBool(); err != nil {
		return thrift.PrependError("error reading field 4: ", err)
	} else {
		p.Bottommost = &v
	}
	return nil
}

func (p *StartAppManualCompactRequest) ReadField5(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return thrift.PrependError("error reading field 5: ", err)
	} else {
		p.MaxRunningCount = &v
	}
	return nil
}

func (p *StartAppManualCompactRequest) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("start_app_manual_compact_request"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		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 thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *StartAppManualCompactRequest) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("app_name", thrift.STRING, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:app_name: ", p), err)
	}
	if err := oprot.WriteString(string(p.AppName)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.app_name (1) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:app_name: ", p), err)
	}
	return err
}

func (p *StartAppManualCompactRequest) writeField2(oprot thrift.TProtocol) (err error) {
	if p.IsSetTriggerTime() {
		if err := oprot.WriteFieldBegin("trigger_time", thrift.I64, 2); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:trigger_time: ", p), err)
		}
		if err := oprot.WriteI64(int64(*p.TriggerTime)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.trigger_time (2) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 2:trigger_time: ", p), err)
		}
	}
	return err
}

func (p *StartAppManualCompactRequest) writeField3(oprot thrift.TProtocol) (err error) {
	if p.IsSetTargetLevel() {
		if err := oprot.WriteFieldBegin("target_level", thrift.I32, 3); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:target_level: ", p), err)
		}
		if err := oprot.WriteI32(int32(*p.TargetLevel)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.target_level (3) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 3:target_level: ", p), err)
		}
	}
	return err
}

func (p *StartAppManualCompactRequest) writeField4(oprot thrift.TProtocol) (err error) {
	if p.IsSetBottommost() {
		if err := oprot.WriteFieldBegin("bottommost", thrift.BOOL, 4); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:bottommost: ", p), err)
		}
		if err := oprot.WriteBool(bool(*p.Bottommost)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.bottommost (4) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 4:bottommost: ", p), err)
		}
	}
	return err
}

func (p *StartAppManualCompactRequest) writeField5(oprot thrift.TProtocol) (err error) {
	if p.IsSetMaxRunningCount() {
		if err := oprot.WriteFieldBegin("max_running_count", thrift.I32, 5); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 5:max_running_count: ", p), err)
		}
		if err := oprot.WriteI32(int32(*p.MaxRunningCount)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.max_running_count (5) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 5:max_running_count: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - Err
//  - HintMsg
type StartAppManualCompactResponse struct {
	Err     *base.ErrorCode `thrift:"err,1" db:"err" json:"err"`
	HintMsg string          `thrift:"hint_msg,2" db:"hint_msg" json:"hint_msg"`
}

func NewStartAppManualCompactResponse() *StartAppManualCompactResponse {
	return &StartAppManualCompactResponse{}
}

var StartAppManualCompactResponse_Err_DEFAULT *base.ErrorCode

func (p *StartAppManualCompactResponse) GetErr() *base.ErrorCode {
	if !p.IsSetErr() {
		return StartAppManualCompactResponse_Err_DEFAULT
	}
	return p.Err
}

func (p *StartAppManualCompactResponse) GetHintMsg() string {
	return p.HintMsg
}
func (p *StartAppManualCompactResponse) IsSetErr() bool {
	return p.Err != nil
}

func (p *StartAppManualCompactResponse) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.STRING {
				if err := p.ReadField2(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *StartAppManualCompactResponse) ReadField1(iprot thrift.TProtocol) error {
	p.Err = &base.ErrorCode{}
	if err := p.Err.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Err), err)
	}
	return nil
}

func (p *StartAppManualCompactResponse) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return thrift.PrependError("error reading field 2: ", err)
	} else {
		p.HintMsg = v
	}
	return nil
}

func (p *StartAppManualCompactResponse) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("start_app_manual_compact_response"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		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 thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *StartAppManualCompactResponse) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("err", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:err: ", p), err)
	}
	if err := p.Err.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Err), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:err: ", p), err)
	}
	return err
}

func (p *StartAppManualCompactResponse) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("hint_msg", thrift.STRING, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:hint_msg: ", p), err)
	}
	if err := oprot.WriteString(string(p.HintMsg)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.hint_msg (2) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:hint_msg: ", p), err)
	}
	return err
}

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

// Attributes:
//  - AppName
type QueryAppManualCompactRequest struct {
	AppName string `thrift:"app_name,1" db:"app_name" json:"app_name"`
}

func NewQueryAppManualCompactRequest() *QueryAppManualCompactRequest {
	return &QueryAppManualCompactRequest{}
}

func (p *QueryAppManualCompactRequest) GetAppName() string {
	return p.AppName
}
func (p *QueryAppManualCompactRequest) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRING {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *QueryAppManualCompactRequest) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return thrift.PrependError("error reading field 1: ", err)
	} else {
		p.AppName = v
	}
	return nil
}

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

func (p *QueryAppManualCompactRequest) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("app_name", thrift.STRING, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:app_name: ", p), err)
	}
	if err := oprot.WriteString(string(p.AppName)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.app_name (1) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:app_name: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Err
//  - HintMsg
//  - Progress
type QueryAppManualCompactResponse struct {
	Err      *base.ErrorCode `thrift:"err,1" db:"err" json:"err"`
	HintMsg  string          `thrift:"hint_msg,2" db:"hint_msg" json:"hint_msg"`
	Progress *int32          `thrift:"progress,3" db:"progress" json:"progress,omitempty"`
}

func NewQueryAppManualCompactResponse() *QueryAppManualCompactResponse {
	return &QueryAppManualCompactResponse{}
}

var QueryAppManualCompactResponse_Err_DEFAULT *base.ErrorCode

func (p *QueryAppManualCompactResponse) GetErr() *base.ErrorCode {
	if !p.IsSetErr() {
		return QueryAppManualCompactResponse_Err_DEFAULT
	}
	return p.Err
}

func (p *QueryAppManualCompactResponse) GetHintMsg() string {
	return p.HintMsg
}

var QueryAppManualCompactResponse_Progress_DEFAULT int32

func (p *QueryAppManualCompactResponse) GetProgress() int32 {
	if !p.IsSetProgress() {
		return QueryAppManualCompactResponse_Progress_DEFAULT
	}
	return *p.Progress
}
func (p *QueryAppManualCompactResponse) IsSetErr() bool {
	return p.Err != nil
}

func (p *QueryAppManualCompactResponse) IsSetProgress() bool {
	return p.Progress != nil
}

func (p *QueryAppManualCompactResponse) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.STRING {
				if err := p.ReadField2(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 3:
			if fieldTypeId == thrift.I32 {
				if err := p.ReadField3(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *QueryAppManualCompactResponse) ReadField1(iprot thrift.TProtocol) error {
	p.Err = &base.ErrorCode{}
	if err := p.Err.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Err), err)
	}
	return nil
}

func (p *QueryAppManualCompactResponse) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return thrift.PrependError("error reading field 2: ", err)
	} else {
		p.HintMsg = v
	}
	return nil
}

func (p *QueryAppManualCompactResponse) ReadField3(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return thrift.PrependError("error reading field 3: ", err)
	} else {
		p.Progress = &v
	}
	return nil
}

func (p *QueryAppManualCompactResponse) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("query_app_manual_compact_response"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		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 := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *QueryAppManualCompactResponse) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("err", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:err: ", p), err)
	}
	if err := p.Err.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Err), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:err: ", p), err)
	}
	return err
}

func (p *QueryAppManualCompactResponse) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("hint_msg", thrift.STRING, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:hint_msg: ", p), err)
	}
	if err := oprot.WriteString(string(p.HintMsg)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.hint_msg (2) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:hint_msg: ", p), err)
	}
	return err
}

func (p *QueryAppManualCompactResponse) writeField3(oprot thrift.TProtocol) (err error) {
	if p.IsSetProgress() {
		if err := oprot.WriteFieldBegin("progress", thrift.I32, 3); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:progress: ", p), err)
		}
		if err := oprot.WriteI32(int32(*p.Progress)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.progress (3) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 3:progress: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - Status
//  - Node
//  - HpNode
type NodeInfo struct {
	Status NodeStatus       `thrift:"status,1" db:"status" json:"status"`
	Node   *base.RPCAddress `thrift:"node,2" db:"node" json:"node"`
	HpNode *base.HostPort   `thrift:"hp_node,3" db:"hp_node" json:"hp_node,omitempty"`
}

func NewNodeInfo() *NodeInfo {
	return &NodeInfo{
		Status: 0,
	}
}

func (p *NodeInfo) GetStatus() NodeStatus {
	return p.Status
}

var NodeInfo_Node_DEFAULT *base.RPCAddress

func (p *NodeInfo) GetNode() *base.RPCAddress {
	if !p.IsSetNode() {
		return NodeInfo_Node_DEFAULT
	}
	return p.Node
}

var NodeInfo_HpNode_DEFAULT *base.HostPort

func (p *NodeInfo) GetHpNode() *base.HostPort {
	if !p.IsSetHpNode() {
		return NodeInfo_HpNode_DEFAULT
	}
	return p.HpNode
}
func (p *NodeInfo) IsSetNode() bool {
	return p.Node != nil
}

func (p *NodeInfo) IsSetHpNode() bool {
	return p.HpNode != nil
}

func (p *NodeInfo) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.I32 {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField2(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 3:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField3(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *NodeInfo) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return thrift.PrependError("error reading field 1: ", err)
	} else {
		temp := NodeStatus(v)
		p.Status = temp
	}
	return nil
}

func (p *NodeInfo) ReadField2(iprot thrift.TProtocol) error {
	p.Node = &base.RPCAddress{}
	if err := p.Node.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Node), err)
	}
	return nil
}

func (p *NodeInfo) ReadField3(iprot thrift.TProtocol) error {
	p.HpNode = &base.HostPort{}
	if err := p.HpNode.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.HpNode), err)
	}
	return nil
}

func (p *NodeInfo) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("node_info"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		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 := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *NodeInfo) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("status", thrift.I32, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:status: ", p), err)
	}
	if err := oprot.WriteI32(int32(p.Status)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.status (1) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:status: ", p), err)
	}
	return err
}

func (p *NodeInfo) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("node", thrift.STRUCT, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:node: ", p), err)
	}
	if err := p.Node.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Node), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:node: ", p), err)
	}
	return err
}

func (p *NodeInfo) writeField3(oprot thrift.TProtocol) (err error) {
	if p.IsSetHpNode() {
		if err := oprot.WriteFieldBegin("hp_node", thrift.STRUCT, 3); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:hp_node: ", p), err)
		}
		if err := p.HpNode.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.HpNode), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 3:hp_node: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - Status
type ConfigurationListNodesRequest struct {
	Status NodeStatus `thrift:"status,1" db:"status" json:"status"`
}

func NewConfigurationListNodesRequest() *ConfigurationListNodesRequest {
	return &ConfigurationListNodesRequest{
		Status: 0,
	}
}

func (p *ConfigurationListNodesRequest) GetStatus() NodeStatus {
	return p.Status
}
func (p *ConfigurationListNodesRequest) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.I32 {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ConfigurationListNodesRequest) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return thrift.PrependError("error reading field 1: ", err)
	} else {
		temp := NodeStatus(v)
		p.Status = temp
	}
	return nil
}

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

func (p *ConfigurationListNodesRequest) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("status", thrift.I32, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:status: ", p), err)
	}
	if err := oprot.WriteI32(int32(p.Status)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.status (1) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:status: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Err
//  - Infos
type ConfigurationListNodesResponse struct {
	Err   *base.ErrorCode `thrift:"err,1" db:"err" json:"err"`
	Infos []*NodeInfo     `thrift:"infos,2" db:"infos" json:"infos"`
}

func NewConfigurationListNodesResponse() *ConfigurationListNodesResponse {
	return &ConfigurationListNodesResponse{}
}

var ConfigurationListNodesResponse_Err_DEFAULT *base.ErrorCode

func (p *ConfigurationListNodesResponse) GetErr() *base.ErrorCode {
	if !p.IsSetErr() {
		return ConfigurationListNodesResponse_Err_DEFAULT
	}
	return p.Err
}

func (p *ConfigurationListNodesResponse) GetInfos() []*NodeInfo {
	return p.Infos
}
func (p *ConfigurationListNodesResponse) IsSetErr() bool {
	return p.Err != nil
}

func (p *ConfigurationListNodesResponse) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.LIST {
				if err := p.ReadField2(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ConfigurationListNodesResponse) ReadField1(iprot thrift.TProtocol) error {
	p.Err = &base.ErrorCode{}
	if err := p.Err.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Err), err)
	}
	return nil
}

func (p *ConfigurationListNodesResponse) ReadField2(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return thrift.PrependError("error reading list begin: ", err)
	}
	tSlice := make([]*NodeInfo, 0, size)
	p.Infos = tSlice
	for i := 0; i < size; i++ {
		_elem13 := &NodeInfo{
			Status: 0,
		}
		if err := _elem13.Read(iprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem13), err)
		}
		p.Infos = append(p.Infos, _elem13)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return thrift.PrependError("error reading list end: ", err)
	}
	return nil
}

func (p *ConfigurationListNodesResponse) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("configuration_list_nodes_response"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		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 thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ConfigurationListNodesResponse) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("err", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:err: ", p), err)
	}
	if err := p.Err.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Err), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:err: ", p), err)
	}
	return err
}

func (p *ConfigurationListNodesResponse) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("infos", thrift.LIST, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:infos: ", p), err)
	}
	if err := oprot.WriteListBegin(thrift.STRUCT, len(p.Infos)); err != nil {
		return thrift.PrependError("error writing list begin: ", err)
	}
	for _, v := range p.Infos {
		if err := v.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", v), err)
		}
	}
	if err := oprot.WriteListEnd(); err != nil {
		return thrift.PrependError("error writing list end: ", err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:infos: ", p), err)
	}
	return err
}

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

type ConfigurationClusterInfoRequest struct {
}

func NewConfigurationClusterInfoRequest() *ConfigurationClusterInfoRequest {
	return &ConfigurationClusterInfoRequest{}
}

func (p *ConfigurationClusterInfoRequest) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		if err := iprot.Skip(fieldTypeId); err != nil {
			return err
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ConfigurationClusterInfoRequest) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("configuration_cluster_info_request"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

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

// Attributes:
//  - Err
//  - Keys
//  - Values
type ConfigurationClusterInfoResponse struct {
	Err    *base.ErrorCode `thrift:"err,1" db:"err" json:"err"`
	Keys   []string        `thrift:"keys,2" db:"keys" json:"keys"`
	Values []string        `thrift:"values,3" db:"values" json:"values"`
}

func NewConfigurationClusterInfoResponse() *ConfigurationClusterInfoResponse {
	return &ConfigurationClusterInfoResponse{}
}

var ConfigurationClusterInfoResponse_Err_DEFAULT *base.ErrorCode

func (p *ConfigurationClusterInfoResponse) GetErr() *base.ErrorCode {
	if !p.IsSetErr() {
		return ConfigurationClusterInfoResponse_Err_DEFAULT
	}
	return p.Err
}

func (p *ConfigurationClusterInfoResponse) GetKeys() []string {
	return p.Keys
}

func (p *ConfigurationClusterInfoResponse) GetValues() []string {
	return p.Values
}
func (p *ConfigurationClusterInfoResponse) IsSetErr() bool {
	return p.Err != nil
}

func (p *ConfigurationClusterInfoResponse) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.LIST {
				if err := p.ReadField2(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 3:
			if fieldTypeId == thrift.LIST {
				if err := p.ReadField3(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ConfigurationClusterInfoResponse) ReadField1(iprot thrift.TProtocol) error {
	p.Err = &base.ErrorCode{}
	if err := p.Err.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Err), err)
	}
	return nil
}

func (p *ConfigurationClusterInfoResponse) ReadField2(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return thrift.PrependError("error reading list begin: ", err)
	}
	tSlice := make([]string, 0, size)
	p.Keys = tSlice
	for i := 0; i < size; i++ {
		var _elem14 string
		if v, err := iprot.ReadString(); err != nil {
			return thrift.PrependError("error reading field 0: ", err)
		} else {
			_elem14 = v
		}
		p.Keys = append(p.Keys, _elem14)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return thrift.PrependError("error reading list end: ", err)
	}
	return nil
}

func (p *ConfigurationClusterInfoResponse) ReadField3(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return thrift.PrependError("error reading list begin: ", err)
	}
	tSlice := make([]string, 0, size)
	p.Values = tSlice
	for i := 0; i < size; i++ {
		var _elem15 string
		if v, err := iprot.ReadString(); err != nil {
			return thrift.PrependError("error reading field 0: ", err)
		} else {
			_elem15 = v
		}
		p.Values = append(p.Values, _elem15)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return thrift.PrependError("error reading list end: ", err)
	}
	return nil
}

func (p *ConfigurationClusterInfoResponse) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("configuration_cluster_info_response"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		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 := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ConfigurationClusterInfoResponse) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("err", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:err: ", p), err)
	}
	if err := p.Err.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Err), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:err: ", p), err)
	}
	return err
}

func (p *ConfigurationClusterInfoResponse) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("keys", thrift.LIST, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:keys: ", p), err)
	}
	if err := oprot.WriteListBegin(thrift.STRING, len(p.Keys)); err != nil {
		return thrift.PrependError("error writing list begin: ", err)
	}
	for _, v := range p.Keys {
		if err := oprot.WriteString(string(v)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
		}
	}
	if err := oprot.WriteListEnd(); err != nil {
		return thrift.PrependError("error writing list end: ", err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:keys: ", p), err)
	}
	return err
}

func (p *ConfigurationClusterInfoResponse) writeField3(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("values", thrift.LIST, 3); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:values: ", p), err)
	}
	if err := oprot.WriteListBegin(thrift.STRING, len(p.Values)); err != nil {
		return thrift.PrependError("error writing list begin: ", err)
	}
	for _, v := range p.Values {
		if err := oprot.WriteString(string(v)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
		}
	}
	if err := oprot.WriteListEnd(); err != nil {
		return thrift.PrependError("error writing list end: ", err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:values: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Level
type ConfigurationMetaControlRequest struct {
	Level MetaFunctionLevel `thrift:"level,1" db:"level" json:"level"`
}

func NewConfigurationMetaControlRequest() *ConfigurationMetaControlRequest {
	return &ConfigurationMetaControlRequest{}
}

func (p *ConfigurationMetaControlRequest) GetLevel() MetaFunctionLevel {
	return p.Level
}
func (p *ConfigurationMetaControlRequest) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.I32 {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ConfigurationMetaControlRequest) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return thrift.PrependError("error reading field 1: ", err)
	} else {
		temp := MetaFunctionLevel(v)
		p.Level = temp
	}
	return nil
}

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

func (p *ConfigurationMetaControlRequest) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("level", thrift.I32, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:level: ", p), err)
	}
	if err := oprot.WriteI32(int32(p.Level)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.level (1) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:level: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Err
//  - OldLevel
type ConfigurationMetaControlResponse struct {
	Err      *base.ErrorCode   `thrift:"err,1" db:"err" json:"err"`
	OldLevel MetaFunctionLevel `thrift:"old_level,2" db:"old_level" json:"old_level"`
}

func NewConfigurationMetaControlResponse() *ConfigurationMetaControlResponse {
	return &ConfigurationMetaControlResponse{}
}

var ConfigurationMetaControlResponse_Err_DEFAULT *base.ErrorCode

func (p *ConfigurationMetaControlResponse) GetErr() *base.ErrorCode {
	if !p.IsSetErr() {
		return ConfigurationMetaControlResponse_Err_DEFAULT
	}
	return p.Err
}

func (p *ConfigurationMetaControlResponse) GetOldLevel() MetaFunctionLevel {
	return p.OldLevel
}
func (p *ConfigurationMetaControlResponse) IsSetErr() bool {
	return p.Err != nil
}

func (p *ConfigurationMetaControlResponse) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.I32 {
				if err := p.ReadField2(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ConfigurationMetaControlResponse) ReadField1(iprot thrift.TProtocol) error {
	p.Err = &base.ErrorCode{}
	if err := p.Err.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Err), err)
	}
	return nil
}

func (p *ConfigurationMetaControlResponse) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return thrift.PrependError("error reading field 2: ", err)
	} else {
		temp := MetaFunctionLevel(v)
		p.OldLevel = temp
	}
	return nil
}

func (p *ConfigurationMetaControlResponse) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("configuration_meta_control_response"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		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 thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ConfigurationMetaControlResponse) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("err", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:err: ", p), err)
	}
	if err := p.Err.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Err), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:err: ", p), err)
	}
	return err
}

func (p *ConfigurationMetaControlResponse) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("old_level", thrift.I32, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:old_level: ", p), err)
	}
	if err := oprot.WriteI32(int32(p.OldLevel)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.old_level (2) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:old_level: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Target
//  - Node
//  - Type
//  - HpTarget
//  - HpNode
type ConfigurationProposalAction struct {
	Target *base.RPCAddress `thrift:"target,1" db:"target" json:"target"`
	Node   *base.RPCAddress `thrift:"node,2" db:"node" json:"node"`
	Type   ConfigType       `thrift:"type,3" db:"type" json:"type"`
	// unused field # 4
	HpTarget *base.HostPort `thrift:"hp_target,5" db:"hp_target" json:"hp_target,omitempty"`
	HpNode   *base.HostPort `thrift:"hp_node,6" db:"hp_node" json:"hp_node,omitempty"`
}

func NewConfigurationProposalAction() *ConfigurationProposalAction {
	return &ConfigurationProposalAction{}
}

var ConfigurationProposalAction_Target_DEFAULT *base.RPCAddress

func (p *ConfigurationProposalAction) GetTarget() *base.RPCAddress {
	if !p.IsSetTarget() {
		return ConfigurationProposalAction_Target_DEFAULT
	}
	return p.Target
}

var ConfigurationProposalAction_Node_DEFAULT *base.RPCAddress

func (p *ConfigurationProposalAction) GetNode() *base.RPCAddress {
	if !p.IsSetNode() {
		return ConfigurationProposalAction_Node_DEFAULT
	}
	return p.Node
}

func (p *ConfigurationProposalAction) GetType() ConfigType {
	return p.Type
}

var ConfigurationProposalAction_HpTarget_DEFAULT *base.HostPort

func (p *ConfigurationProposalAction) GetHpTarget() *base.HostPort {
	if !p.IsSetHpTarget() {
		return ConfigurationProposalAction_HpTarget_DEFAULT
	}
	return p.HpTarget
}

var ConfigurationProposalAction_HpNode_DEFAULT *base.HostPort

func (p *ConfigurationProposalAction) GetHpNode() *base.HostPort {
	if !p.IsSetHpNode() {
		return ConfigurationProposalAction_HpNode_DEFAULT
	}
	return p.HpNode
}
func (p *ConfigurationProposalAction) IsSetTarget() bool {
	return p.Target != nil
}

func (p *ConfigurationProposalAction) IsSetNode() bool {
	return p.Node != nil
}

func (p *ConfigurationProposalAction) IsSetHpTarget() bool {
	return p.HpTarget != nil
}

func (p *ConfigurationProposalAction) IsSetHpNode() bool {
	return p.HpNode != nil
}

func (p *ConfigurationProposalAction) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField2(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 3:
			if fieldTypeId == thrift.I32 {
				if err := p.ReadField3(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 5:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField5(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 6:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField6(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ConfigurationProposalAction) ReadField1(iprot thrift.TProtocol) error {
	p.Target = &base.RPCAddress{}
	if err := p.Target.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Target), err)
	}
	return nil
}

func (p *ConfigurationProposalAction) ReadField2(iprot thrift.TProtocol) error {
	p.Node = &base.RPCAddress{}
	if err := p.Node.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Node), err)
	}
	return nil
}

func (p *ConfigurationProposalAction) ReadField3(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return thrift.PrependError("error reading field 3: ", err)
	} else {
		temp := ConfigType(v)
		p.Type = temp
	}
	return nil
}

func (p *ConfigurationProposalAction) ReadField5(iprot thrift.TProtocol) error {
	p.HpTarget = &base.HostPort{}
	if err := p.HpTarget.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.HpTarget), err)
	}
	return nil
}

func (p *ConfigurationProposalAction) ReadField6(iprot thrift.TProtocol) error {
	p.HpNode = &base.HostPort{}
	if err := p.HpNode.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.HpNode), err)
	}
	return nil
}

func (p *ConfigurationProposalAction) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("configuration_proposal_action"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		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.writeField5(oprot); err != nil {
			return err
		}
		if err := p.writeField6(oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ConfigurationProposalAction) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("target", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:target: ", p), err)
	}
	if err := p.Target.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Target), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:target: ", p), err)
	}
	return err
}

func (p *ConfigurationProposalAction) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("node", thrift.STRUCT, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:node: ", p), err)
	}
	if err := p.Node.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Node), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:node: ", p), err)
	}
	return err
}

func (p *ConfigurationProposalAction) writeField3(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("type", thrift.I32, 3); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:type: ", p), err)
	}
	if err := oprot.WriteI32(int32(p.Type)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.type (3) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:type: ", p), err)
	}
	return err
}

func (p *ConfigurationProposalAction) writeField5(oprot thrift.TProtocol) (err error) {
	if p.IsSetHpTarget() {
		if err := oprot.WriteFieldBegin("hp_target", thrift.STRUCT, 5); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 5:hp_target: ", p), err)
		}
		if err := p.HpTarget.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.HpTarget), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 5:hp_target: ", p), err)
		}
	}
	return err
}

func (p *ConfigurationProposalAction) writeField6(oprot thrift.TProtocol) (err error) {
	if p.IsSetHpNode() {
		if err := oprot.WriteFieldBegin("hp_node", thrift.STRUCT, 6); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 6:hp_node: ", p), err)
		}
		if err := p.HpNode.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.HpNode), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 6:hp_node: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - Gpid
//  - ActionList
//  - Force
//  - BalanceType
type ConfigurationBalancerRequest struct {
	Gpid        *base.Gpid                     `thrift:"gpid,1" db:"gpid" json:"gpid"`
	ActionList  []*ConfigurationProposalAction `thrift:"action_list,2" db:"action_list" json:"action_list"`
	Force       bool                           `thrift:"force,3" db:"force" json:"force"`
	BalanceType *BalancerRequestType           `thrift:"balance_type,4" db:"balance_type" json:"balance_type,omitempty"`
}

func NewConfigurationBalancerRequest() *ConfigurationBalancerRequest {
	return &ConfigurationBalancerRequest{}
}

var ConfigurationBalancerRequest_Gpid_DEFAULT *base.Gpid

func (p *ConfigurationBalancerRequest) GetGpid() *base.Gpid {
	if !p.IsSetGpid() {
		return ConfigurationBalancerRequest_Gpid_DEFAULT
	}
	return p.Gpid
}

func (p *ConfigurationBalancerRequest) GetActionList() []*ConfigurationProposalAction {
	return p.ActionList
}

var ConfigurationBalancerRequest_Force_DEFAULT bool = false

func (p *ConfigurationBalancerRequest) GetForce() bool {
	return p.Force
}

var ConfigurationBalancerRequest_BalanceType_DEFAULT BalancerRequestType

func (p *ConfigurationBalancerRequest) GetBalanceType() BalancerRequestType {
	if !p.IsSetBalanceType() {
		return ConfigurationBalancerRequest_BalanceType_DEFAULT
	}
	return *p.BalanceType
}
func (p *ConfigurationBalancerRequest) IsSetGpid() bool {
	return p.Gpid != nil
}

func (p *ConfigurationBalancerRequest) IsSetForce() bool {
	return p.Force != ConfigurationBalancerRequest_Force_DEFAULT
}

func (p *ConfigurationBalancerRequest) IsSetBalanceType() bool {
	return p.BalanceType != nil
}

func (p *ConfigurationBalancerRequest) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.LIST {
				if err := p.ReadField2(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 3:
			if fieldTypeId == thrift.BOOL {
				if err := p.ReadField3(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 4:
			if fieldTypeId == thrift.I32 {
				if err := p.ReadField4(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ConfigurationBalancerRequest) ReadField1(iprot thrift.TProtocol) error {
	p.Gpid = &base.Gpid{}
	if err := p.Gpid.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Gpid), err)
	}
	return nil
}

func (p *ConfigurationBalancerRequest) ReadField2(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return thrift.PrependError("error reading list begin: ", err)
	}
	tSlice := make([]*ConfigurationProposalAction, 0, size)
	p.ActionList = tSlice
	for i := 0; i < size; i++ {
		_elem16 := &ConfigurationProposalAction{}
		if err := _elem16.Read(iprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem16), err)
		}
		p.ActionList = append(p.ActionList, _elem16)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return thrift.PrependError("error reading list end: ", err)
	}
	return nil
}

func (p *ConfigurationBalancerRequest) ReadField3(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBool(); err != nil {
		return thrift.PrependError("error reading field 3: ", err)
	} else {
		p.Force = v
	}
	return nil
}

func (p *ConfigurationBalancerRequest) ReadField4(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return thrift.PrependError("error reading field 4: ", err)
	} else {
		temp := BalancerRequestType(v)
		p.BalanceType = &temp
	}
	return nil
}

func (p *ConfigurationBalancerRequest) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("configuration_balancer_request"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		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 := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ConfigurationBalancerRequest) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("gpid", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:gpid: ", p), err)
	}
	if err := p.Gpid.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Gpid), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:gpid: ", p), err)
	}
	return err
}

func (p *ConfigurationBalancerRequest) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("action_list", thrift.LIST, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:action_list: ", p), err)
	}
	if err := oprot.WriteListBegin(thrift.STRUCT, len(p.ActionList)); err != nil {
		return thrift.PrependError("error writing list begin: ", err)
	}
	for _, v := range p.ActionList {
		if err := v.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", v), err)
		}
	}
	if err := oprot.WriteListEnd(); err != nil {
		return thrift.PrependError("error writing list end: ", err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:action_list: ", p), err)
	}
	return err
}

func (p *ConfigurationBalancerRequest) writeField3(oprot thrift.TProtocol) (err error) {
	if p.IsSetForce() {
		if err := oprot.WriteFieldBegin("force", thrift.BOOL, 3); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:force: ", p), err)
		}
		if err := oprot.WriteBool(bool(p.Force)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.force (3) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 3:force: ", p), err)
		}
	}
	return err
}

func (p *ConfigurationBalancerRequest) writeField4(oprot thrift.TProtocol) (err error) {
	if p.IsSetBalanceType() {
		if err := oprot.WriteFieldBegin("balance_type", thrift.I32, 4); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:balance_type: ", p), err)
		}
		if err := oprot.WriteI32(int32(*p.BalanceType)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.balance_type (4) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 4:balance_type: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - Err
type ConfigurationBalancerResponse struct {
	Err *base.ErrorCode `thrift:"err,1" db:"err" json:"err"`
}

func NewConfigurationBalancerResponse() *ConfigurationBalancerResponse {
	return &ConfigurationBalancerResponse{}
}

var ConfigurationBalancerResponse_Err_DEFAULT *base.ErrorCode

func (p *ConfigurationBalancerResponse) GetErr() *base.ErrorCode {
	if !p.IsSetErr() {
		return ConfigurationBalancerResponse_Err_DEFAULT
	}
	return p.Err
}
func (p *ConfigurationBalancerResponse) IsSetErr() bool {
	return p.Err != nil
}

func (p *ConfigurationBalancerResponse) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ConfigurationBalancerResponse) ReadField1(iprot thrift.TProtocol) error {
	p.Err = &base.ErrorCode{}
	if err := p.Err.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Err), err)
	}
	return nil
}

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

func (p *ConfigurationBalancerResponse) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("err", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:err: ", p), err)
	}
	if err := p.Err.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Err), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:err: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Pid
type DddDiagnoseRequest struct {
	Pid *base.Gpid `thrift:"pid,1" db:"pid" json:"pid"`
}

func NewDddDiagnoseRequest() *DddDiagnoseRequest {
	return &DddDiagnoseRequest{}
}

var DddDiagnoseRequest_Pid_DEFAULT *base.Gpid

func (p *DddDiagnoseRequest) GetPid() *base.Gpid {
	if !p.IsSetPid() {
		return DddDiagnoseRequest_Pid_DEFAULT
	}
	return p.Pid
}
func (p *DddDiagnoseRequest) IsSetPid() bool {
	return p.Pid != nil
}

func (p *DddDiagnoseRequest) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *DddDiagnoseRequest) ReadField1(iprot thrift.TProtocol) error {
	p.Pid = &base.Gpid{}
	if err := p.Pid.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Pid), err)
	}
	return nil
}

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

func (p *DddDiagnoseRequest) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("pid", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:pid: ", p), err)
	}
	if err := p.Pid.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Pid), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:pid: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Node
//  - DropTimeMs
//  - IsAlive
//  - IsCollected
//  - Ballot
//  - LastCommittedDecree
//  - LastPreparedDecree
//  - HpNode
type DddNodeInfo struct {
	Node                *base.RPCAddress `thrift:"node,1" db:"node" json:"node"`
	DropTimeMs          int64            `thrift:"drop_time_ms,2" db:"drop_time_ms" json:"drop_time_ms"`
	IsAlive             bool             `thrift:"is_alive,3" db:"is_alive" json:"is_alive"`
	IsCollected         bool             `thrift:"is_collected,4" db:"is_collected" json:"is_collected"`
	Ballot              int64            `thrift:"ballot,5" db:"ballot" json:"ballot"`
	LastCommittedDecree int64            `thrift:"last_committed_decree,6" db:"last_committed_decree" json:"last_committed_decree"`
	LastPreparedDecree  int64            `thrift:"last_prepared_decree,7" db:"last_prepared_decree" json:"last_prepared_decree"`
	HpNode              *base.HostPort   `thrift:"hp_node,8" db:"hp_node" json:"hp_node,omitempty"`
}

func NewDddNodeInfo() *DddNodeInfo {
	return &DddNodeInfo{}
}

var DddNodeInfo_Node_DEFAULT *base.RPCAddress

func (p *DddNodeInfo) GetNode() *base.RPCAddress {
	if !p.IsSetNode() {
		return DddNodeInfo_Node_DEFAULT
	}
	return p.Node
}

func (p *DddNodeInfo) GetDropTimeMs() int64 {
	return p.DropTimeMs
}

func (p *DddNodeInfo) GetIsAlive() bool {
	return p.IsAlive
}

func (p *DddNodeInfo) GetIsCollected() bool {
	return p.IsCollected
}

func (p *DddNodeInfo) GetBallot() int64 {
	return p.Ballot
}

func (p *DddNodeInfo) GetLastCommittedDecree() int64 {
	return p.LastCommittedDecree
}

func (p *DddNodeInfo) GetLastPreparedDecree() int64 {
	return p.LastPreparedDecree
}

var DddNodeInfo_HpNode_DEFAULT *base.HostPort

func (p *DddNodeInfo) GetHpNode() *base.HostPort {
	if !p.IsSetHpNode() {
		return DddNodeInfo_HpNode_DEFAULT
	}
	return p.HpNode
}
func (p *DddNodeInfo) IsSetNode() bool {
	return p.Node != nil
}

func (p *DddNodeInfo) IsSetHpNode() bool {
	return p.HpNode != nil
}

func (p *DddNodeInfo) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.I64 {
				if err := p.ReadField2(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 3:
			if fieldTypeId == thrift.BOOL {
				if err := p.ReadField3(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 4:
			if fieldTypeId == thrift.BOOL {
				if err := p.ReadField4(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 5:
			if fieldTypeId == thrift.I64 {
				if err := p.ReadField5(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 6:
			if fieldTypeId == thrift.I64 {
				if err := p.ReadField6(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 7:
			if fieldTypeId == thrift.I64 {
				if err := p.ReadField7(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 8:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField8(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *DddNodeInfo) ReadField1(iprot thrift.TProtocol) error {
	p.Node = &base.RPCAddress{}
	if err := p.Node.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Node), err)
	}
	return nil
}

func (p *DddNodeInfo) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI64(); err != nil {
		return thrift.PrependError("error reading field 2: ", err)
	} else {
		p.DropTimeMs = v
	}
	return nil
}

func (p *DddNodeInfo) ReadField3(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBool(); err != nil {
		return thrift.PrependError("error reading field 3: ", err)
	} else {
		p.IsAlive = v
	}
	return nil
}

func (p *DddNodeInfo) ReadField4(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBool(); err != nil {
		return thrift.PrependError("error reading field 4: ", err)
	} else {
		p.IsCollected = v
	}
	return nil
}

func (p *DddNodeInfo) ReadField5(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI64(); err != nil {
		return thrift.PrependError("error reading field 5: ", err)
	} else {
		p.Ballot = v
	}
	return nil
}

func (p *DddNodeInfo) ReadField6(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI64(); err != nil {
		return thrift.PrependError("error reading field 6: ", err)
	} else {
		p.LastCommittedDecree = v
	}
	return nil
}

func (p *DddNodeInfo) ReadField7(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI64(); err != nil {
		return thrift.PrependError("error reading field 7: ", err)
	} else {
		p.LastPreparedDecree = v
	}
	return nil
}

func (p *DddNodeInfo) ReadField8(iprot thrift.TProtocol) error {
	p.HpNode = &base.HostPort{}
	if err := p.HpNode.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.HpNode), err)
	}
	return nil
}

func (p *DddNodeInfo) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("ddd_node_info"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		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 := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *DddNodeInfo) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("node", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:node: ", p), err)
	}
	if err := p.Node.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Node), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:node: ", p), err)
	}
	return err
}

func (p *DddNodeInfo) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("drop_time_ms", thrift.I64, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:drop_time_ms: ", p), err)
	}
	if err := oprot.WriteI64(int64(p.DropTimeMs)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.drop_time_ms (2) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:drop_time_ms: ", p), err)
	}
	return err
}

func (p *DddNodeInfo) writeField3(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("is_alive", thrift.BOOL, 3); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:is_alive: ", p), err)
	}
	if err := oprot.WriteBool(bool(p.IsAlive)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.is_alive (3) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:is_alive: ", p), err)
	}
	return err
}

func (p *DddNodeInfo) writeField4(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("is_collected", thrift.BOOL, 4); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:is_collected: ", p), err)
	}
	if err := oprot.WriteBool(bool(p.IsCollected)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.is_collected (4) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 4:is_collected: ", p), err)
	}
	return err
}

func (p *DddNodeInfo) writeField5(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("ballot", thrift.I64, 5); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 5:ballot: ", p), err)
	}
	if err := oprot.WriteI64(int64(p.Ballot)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.ballot (5) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 5:ballot: ", p), err)
	}
	return err
}

func (p *DddNodeInfo) writeField6(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("last_committed_decree", thrift.I64, 6); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 6:last_committed_decree: ", p), err)
	}
	if err := oprot.WriteI64(int64(p.LastCommittedDecree)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.last_committed_decree (6) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 6:last_committed_decree: ", p), err)
	}
	return err
}

func (p *DddNodeInfo) writeField7(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("last_prepared_decree", thrift.I64, 7); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 7:last_prepared_decree: ", p), err)
	}
	if err := oprot.WriteI64(int64(p.LastPreparedDecree)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.last_prepared_decree (7) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 7:last_prepared_decree: ", p), err)
	}
	return err
}

func (p *DddNodeInfo) writeField8(oprot thrift.TProtocol) (err error) {
	if p.IsSetHpNode() {
		if err := oprot.WriteFieldBegin("hp_node", thrift.STRUCT, 8); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 8:hp_node: ", p), err)
		}
		if err := p.HpNode.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.HpNode), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 8:hp_node: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - Config
//  - Dropped
//  - Reason
type DddPartitionInfo struct {
	Config  *replication.PartitionConfiguration `thrift:"config,1" db:"config" json:"config"`
	Dropped []*DddNodeInfo                      `thrift:"dropped,2" db:"dropped" json:"dropped"`
	Reason  string                              `thrift:"reason,3" db:"reason" json:"reason"`
}

func NewDddPartitionInfo() *DddPartitionInfo {
	return &DddPartitionInfo{}
}

var DddPartitionInfo_Config_DEFAULT *replication.PartitionConfiguration

func (p *DddPartitionInfo) GetConfig() *replication.PartitionConfiguration {
	if !p.IsSetConfig() {
		return DddPartitionInfo_Config_DEFAULT
	}
	return p.Config
}

func (p *DddPartitionInfo) GetDropped() []*DddNodeInfo {
	return p.Dropped
}

func (p *DddPartitionInfo) GetReason() string {
	return p.Reason
}
func (p *DddPartitionInfo) IsSetConfig() bool {
	return p.Config != nil
}

func (p *DddPartitionInfo) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.LIST {
				if err := p.ReadField2(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 3:
			if fieldTypeId == thrift.STRING {
				if err := p.ReadField3(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *DddPartitionInfo) ReadField1(iprot thrift.TProtocol) error {
	p.Config = &replication.PartitionConfiguration{}
	if err := p.Config.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Config), err)
	}
	return nil
}

func (p *DddPartitionInfo) ReadField2(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return thrift.PrependError("error reading list begin: ", err)
	}
	tSlice := make([]*DddNodeInfo, 0, size)
	p.Dropped = tSlice
	for i := 0; i < size; i++ {
		_elem17 := &DddNodeInfo{}
		if err := _elem17.Read(iprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem17), err)
		}
		p.Dropped = append(p.Dropped, _elem17)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return thrift.PrependError("error reading list end: ", err)
	}
	return nil
}

func (p *DddPartitionInfo) ReadField3(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return thrift.PrependError("error reading field 3: ", err)
	} else {
		p.Reason = v
	}
	return nil
}

func (p *DddPartitionInfo) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("ddd_partition_info"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		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 := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *DddPartitionInfo) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("config", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:config: ", p), err)
	}
	if err := p.Config.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Config), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:config: ", p), err)
	}
	return err
}

func (p *DddPartitionInfo) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("dropped", thrift.LIST, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:dropped: ", p), err)
	}
	if err := oprot.WriteListBegin(thrift.STRUCT, len(p.Dropped)); err != nil {
		return thrift.PrependError("error writing list begin: ", err)
	}
	for _, v := range p.Dropped {
		if err := v.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", v), err)
		}
	}
	if err := oprot.WriteListEnd(); err != nil {
		return thrift.PrependError("error writing list end: ", err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:dropped: ", p), err)
	}
	return err
}

func (p *DddPartitionInfo) writeField3(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("reason", thrift.STRING, 3); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:reason: ", p), err)
	}
	if err := oprot.WriteString(string(p.Reason)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.reason (3) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:reason: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Err
//  - Partitions
type DddDiagnoseResponse struct {
	Err        *base.ErrorCode     `thrift:"err,1" db:"err" json:"err"`
	Partitions []*DddPartitionInfo `thrift:"partitions,2" db:"partitions" json:"partitions"`
}

func NewDddDiagnoseResponse() *DddDiagnoseResponse {
	return &DddDiagnoseResponse{}
}

var DddDiagnoseResponse_Err_DEFAULT *base.ErrorCode

func (p *DddDiagnoseResponse) GetErr() *base.ErrorCode {
	if !p.IsSetErr() {
		return DddDiagnoseResponse_Err_DEFAULT
	}
	return p.Err
}

func (p *DddDiagnoseResponse) GetPartitions() []*DddPartitionInfo {
	return p.Partitions
}
func (p *DddDiagnoseResponse) IsSetErr() bool {
	return p.Err != nil
}

func (p *DddDiagnoseResponse) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.LIST {
				if err := p.ReadField2(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *DddDiagnoseResponse) ReadField1(iprot thrift.TProtocol) error {
	p.Err = &base.ErrorCode{}
	if err := p.Err.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Err), err)
	}
	return nil
}

func (p *DddDiagnoseResponse) ReadField2(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return thrift.PrependError("error reading list begin: ", err)
	}
	tSlice := make([]*DddPartitionInfo, 0, size)
	p.Partitions = tSlice
	for i := 0; i < size; i++ {
		_elem18 := &DddPartitionInfo{}
		if err := _elem18.Read(iprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem18), err)
		}
		p.Partitions = append(p.Partitions, _elem18)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return thrift.PrependError("error reading list end: ", err)
	}
	return nil
}

func (p *DddDiagnoseResponse) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("ddd_diagnose_response"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		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 thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *DddDiagnoseResponse) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("err", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:err: ", p), err)
	}
	if err := p.Err.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Err), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:err: ", p), err)
	}
	return err
}

func (p *DddDiagnoseResponse) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("partitions", thrift.LIST, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:partitions: ", p), err)
	}
	if err := oprot.WriteListBegin(thrift.STRUCT, len(p.Partitions)); err != nil {
		return thrift.PrependError("error writing list begin: ", err)
	}
	for _, v := range p.Partitions {
		if err := v.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", v), err)
		}
	}
	if err := oprot.WriteListEnd(); err != nil {
		return thrift.PrependError("error writing list end: ", err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:partitions: ", p), err)
	}
	return err
}

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

// Attributes:
//  - AppName
type ConfigurationGetMaxReplicaCountRequest struct {
	AppName string `thrift:"app_name,1" db:"app_name" json:"app_name"`
}

func NewConfigurationGetMaxReplicaCountRequest() *ConfigurationGetMaxReplicaCountRequest {
	return &ConfigurationGetMaxReplicaCountRequest{}
}

func (p *ConfigurationGetMaxReplicaCountRequest) GetAppName() string {
	return p.AppName
}
func (p *ConfigurationGetMaxReplicaCountRequest) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRING {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ConfigurationGetMaxReplicaCountRequest) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return thrift.PrependError("error reading field 1: ", err)
	} else {
		p.AppName = v
	}
	return nil
}

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

func (p *ConfigurationGetMaxReplicaCountRequest) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("app_name", thrift.STRING, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:app_name: ", p), err)
	}
	if err := oprot.WriteString(string(p.AppName)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.app_name (1) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:app_name: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Err
//  - MaxReplicaCount
//  - HintMessage
type ConfigurationGetMaxReplicaCountResponse struct {
	Err             *base.ErrorCode `thrift:"err,1" db:"err" json:"err"`
	MaxReplicaCount int32           `thrift:"max_replica_count,2" db:"max_replica_count" json:"max_replica_count"`
	HintMessage     string          `thrift:"hint_message,3" db:"hint_message" json:"hint_message"`
}

func NewConfigurationGetMaxReplicaCountResponse() *ConfigurationGetMaxReplicaCountResponse {
	return &ConfigurationGetMaxReplicaCountResponse{}
}

var ConfigurationGetMaxReplicaCountResponse_Err_DEFAULT *base.ErrorCode

func (p *ConfigurationGetMaxReplicaCountResponse) GetErr() *base.ErrorCode {
	if !p.IsSetErr() {
		return ConfigurationGetMaxReplicaCountResponse_Err_DEFAULT
	}
	return p.Err
}

func (p *ConfigurationGetMaxReplicaCountResponse) GetMaxReplicaCount() int32 {
	return p.MaxReplicaCount
}

func (p *ConfigurationGetMaxReplicaCountResponse) GetHintMessage() string {
	return p.HintMessage
}
func (p *ConfigurationGetMaxReplicaCountResponse) IsSetErr() bool {
	return p.Err != nil
}

func (p *ConfigurationGetMaxReplicaCountResponse) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.I32 {
				if err := p.ReadField2(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 3:
			if fieldTypeId == thrift.STRING {
				if err := p.ReadField3(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ConfigurationGetMaxReplicaCountResponse) ReadField1(iprot thrift.TProtocol) error {
	p.Err = &base.ErrorCode{}
	if err := p.Err.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Err), err)
	}
	return nil
}

func (p *ConfigurationGetMaxReplicaCountResponse) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return thrift.PrependError("error reading field 2: ", err)
	} else {
		p.MaxReplicaCount = v
	}
	return nil
}

func (p *ConfigurationGetMaxReplicaCountResponse) ReadField3(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return thrift.PrependError("error reading field 3: ", err)
	} else {
		p.HintMessage = v
	}
	return nil
}

func (p *ConfigurationGetMaxReplicaCountResponse) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("configuration_get_max_replica_count_response"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		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 := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ConfigurationGetMaxReplicaCountResponse) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("err", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:err: ", p), err)
	}
	if err := p.Err.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Err), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:err: ", p), err)
	}
	return err
}

func (p *ConfigurationGetMaxReplicaCountResponse) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("max_replica_count", thrift.I32, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:max_replica_count: ", p), err)
	}
	if err := oprot.WriteI32(int32(p.MaxReplicaCount)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.max_replica_count (2) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:max_replica_count: ", p), err)
	}
	return err
}

func (p *ConfigurationGetMaxReplicaCountResponse) writeField3(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("hint_message", thrift.STRING, 3); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:hint_message: ", p), err)
	}
	if err := oprot.WriteString(string(p.HintMessage)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.hint_message (3) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:hint_message: ", p), err)
	}
	return err
}

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

// Attributes:
//  - AppName
//  - MaxReplicaCount
type ConfigurationSetMaxReplicaCountRequest struct {
	AppName         string `thrift:"app_name,1" db:"app_name" json:"app_name"`
	MaxReplicaCount int32  `thrift:"max_replica_count,2" db:"max_replica_count" json:"max_replica_count"`
}

func NewConfigurationSetMaxReplicaCountRequest() *ConfigurationSetMaxReplicaCountRequest {
	return &ConfigurationSetMaxReplicaCountRequest{}
}

func (p *ConfigurationSetMaxReplicaCountRequest) GetAppName() string {
	return p.AppName
}

func (p *ConfigurationSetMaxReplicaCountRequest) GetMaxReplicaCount() int32 {
	return p.MaxReplicaCount
}
func (p *ConfigurationSetMaxReplicaCountRequest) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRING {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.I32 {
				if err := p.ReadField2(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ConfigurationSetMaxReplicaCountRequest) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return thrift.PrependError("error reading field 1: ", err)
	} else {
		p.AppName = v
	}
	return nil
}

func (p *ConfigurationSetMaxReplicaCountRequest) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return thrift.PrependError("error reading field 2: ", err)
	} else {
		p.MaxReplicaCount = v
	}
	return nil
}

func (p *ConfigurationSetMaxReplicaCountRequest) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("configuration_set_max_replica_count_request"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		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 thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ConfigurationSetMaxReplicaCountRequest) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("app_name", thrift.STRING, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:app_name: ", p), err)
	}
	if err := oprot.WriteString(string(p.AppName)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.app_name (1) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:app_name: ", p), err)
	}
	return err
}

func (p *ConfigurationSetMaxReplicaCountRequest) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("max_replica_count", thrift.I32, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:max_replica_count: ", p), err)
	}
	if err := oprot.WriteI32(int32(p.MaxReplicaCount)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.max_replica_count (2) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:max_replica_count: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Err
//  - OldMaxReplicaCount
//  - HintMessage
type ConfigurationSetMaxReplicaCountResponse struct {
	Err                *base.ErrorCode `thrift:"err,1" db:"err" json:"err"`
	OldMaxReplicaCount int32           `thrift:"old_max_replica_count,2" db:"old_max_replica_count" json:"old_max_replica_count"`
	HintMessage        string          `thrift:"hint_message,3" db:"hint_message" json:"hint_message"`
}

func NewConfigurationSetMaxReplicaCountResponse() *ConfigurationSetMaxReplicaCountResponse {
	return &ConfigurationSetMaxReplicaCountResponse{}
}

var ConfigurationSetMaxReplicaCountResponse_Err_DEFAULT *base.ErrorCode

func (p *ConfigurationSetMaxReplicaCountResponse) GetErr() *base.ErrorCode {
	if !p.IsSetErr() {
		return ConfigurationSetMaxReplicaCountResponse_Err_DEFAULT
	}
	return p.Err
}

func (p *ConfigurationSetMaxReplicaCountResponse) GetOldMaxReplicaCount() int32 {
	return p.OldMaxReplicaCount
}

func (p *ConfigurationSetMaxReplicaCountResponse) GetHintMessage() string {
	return p.HintMessage
}
func (p *ConfigurationSetMaxReplicaCountResponse) IsSetErr() bool {
	return p.Err != nil
}

func (p *ConfigurationSetMaxReplicaCountResponse) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.I32 {
				if err := p.ReadField2(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 3:
			if fieldTypeId == thrift.STRING {
				if err := p.ReadField3(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ConfigurationSetMaxReplicaCountResponse) ReadField1(iprot thrift.TProtocol) error {
	p.Err = &base.ErrorCode{}
	if err := p.Err.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Err), err)
	}
	return nil
}

func (p *ConfigurationSetMaxReplicaCountResponse) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return thrift.PrependError("error reading field 2: ", err)
	} else {
		p.OldMaxReplicaCount = v
	}
	return nil
}

func (p *ConfigurationSetMaxReplicaCountResponse) ReadField3(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return thrift.PrependError("error reading field 3: ", err)
	} else {
		p.HintMessage = v
	}
	return nil
}

func (p *ConfigurationSetMaxReplicaCountResponse) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("configuration_set_max_replica_count_response"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		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 := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ConfigurationSetMaxReplicaCountResponse) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("err", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:err: ", p), err)
	}
	if err := p.Err.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Err), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:err: ", p), err)
	}
	return err
}

func (p *ConfigurationSetMaxReplicaCountResponse) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("old_max_replica_count", thrift.I32, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:old_max_replica_count: ", p), err)
	}
	if err := oprot.WriteI32(int32(p.OldMaxReplicaCount)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.old_max_replica_count (2) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:old_max_replica_count: ", p), err)
	}
	return err
}

func (p *ConfigurationSetMaxReplicaCountResponse) writeField3(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("hint_message", thrift.STRING, 3); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:hint_message: ", p), err)
	}
	if err := oprot.WriteString(string(p.HintMessage)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.hint_message (3) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:hint_message: ", p), err)
	}
	return err
}

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

// Attributes:
//  - AppName
type ConfigurationGetAtomicIdempotentRequest struct {
	AppName string `thrift:"app_name,1" db:"app_name" json:"app_name"`
}

func NewConfigurationGetAtomicIdempotentRequest() *ConfigurationGetAtomicIdempotentRequest {
	return &ConfigurationGetAtomicIdempotentRequest{}
}

func (p *ConfigurationGetAtomicIdempotentRequest) GetAppName() string {
	return p.AppName
}
func (p *ConfigurationGetAtomicIdempotentRequest) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRING {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ConfigurationGetAtomicIdempotentRequest) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return thrift.PrependError("error reading field 1: ", err)
	} else {
		p.AppName = v
	}
	return nil
}

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

func (p *ConfigurationGetAtomicIdempotentRequest) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("app_name", thrift.STRING, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:app_name: ", p), err)
	}
	if err := oprot.WriteString(string(p.AppName)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.app_name (1) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:app_name: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Err
//  - AtomicIdempotent
//  - HintMessage
type ConfigurationGetAtomicIdempotentResponse struct {
	Err              *base.ErrorCode `thrift:"err,1" db:"err" json:"err"`
	AtomicIdempotent bool            `thrift:"atomic_idempotent,2" db:"atomic_idempotent" json:"atomic_idempotent"`
	HintMessage      string          `thrift:"hint_message,3" db:"hint_message" json:"hint_message"`
}

func NewConfigurationGetAtomicIdempotentResponse() *ConfigurationGetAtomicIdempotentResponse {
	return &ConfigurationGetAtomicIdempotentResponse{}
}

var ConfigurationGetAtomicIdempotentResponse_Err_DEFAULT *base.ErrorCode

func (p *ConfigurationGetAtomicIdempotentResponse) GetErr() *base.ErrorCode {
	if !p.IsSetErr() {
		return ConfigurationGetAtomicIdempotentResponse_Err_DEFAULT
	}
	return p.Err
}

func (p *ConfigurationGetAtomicIdempotentResponse) GetAtomicIdempotent() bool {
	return p.AtomicIdempotent
}

func (p *ConfigurationGetAtomicIdempotentResponse) GetHintMessage() string {
	return p.HintMessage
}
func (p *ConfigurationGetAtomicIdempotentResponse) IsSetErr() bool {
	return p.Err != nil
}

func (p *ConfigurationGetAtomicIdempotentResponse) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.BOOL {
				if err := p.ReadField2(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 3:
			if fieldTypeId == thrift.STRING {
				if err := p.ReadField3(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ConfigurationGetAtomicIdempotentResponse) ReadField1(iprot thrift.TProtocol) error {
	p.Err = &base.ErrorCode{}
	if err := p.Err.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Err), err)
	}
	return nil
}

func (p *ConfigurationGetAtomicIdempotentResponse) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBool(); err != nil {
		return thrift.PrependError("error reading field 2: ", err)
	} else {
		p.AtomicIdempotent = v
	}
	return nil
}

func (p *ConfigurationGetAtomicIdempotentResponse) ReadField3(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return thrift.PrependError("error reading field 3: ", err)
	} else {
		p.HintMessage = v
	}
	return nil
}

func (p *ConfigurationGetAtomicIdempotentResponse) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("configuration_get_atomic_idempotent_response"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		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 := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ConfigurationGetAtomicIdempotentResponse) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("err", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:err: ", p), err)
	}
	if err := p.Err.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Err), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:err: ", p), err)
	}
	return err
}

func (p *ConfigurationGetAtomicIdempotentResponse) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("atomic_idempotent", thrift.BOOL, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:atomic_idempotent: ", p), err)
	}
	if err := oprot.WriteBool(bool(p.AtomicIdempotent)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.atomic_idempotent (2) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:atomic_idempotent: ", p), err)
	}
	return err
}

func (p *ConfigurationGetAtomicIdempotentResponse) writeField3(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("hint_message", thrift.STRING, 3); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:hint_message: ", p), err)
	}
	if err := oprot.WriteString(string(p.HintMessage)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.hint_message (3) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:hint_message: ", p), err)
	}
	return err
}

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

// Attributes:
//  - AppName
//  - AtomicIdempotent
type ConfigurationSetAtomicIdempotentRequest struct {
	AppName          string `thrift:"app_name,1" db:"app_name" json:"app_name"`
	AtomicIdempotent bool   `thrift:"atomic_idempotent,2" db:"atomic_idempotent" json:"atomic_idempotent"`
}

func NewConfigurationSetAtomicIdempotentRequest() *ConfigurationSetAtomicIdempotentRequest {
	return &ConfigurationSetAtomicIdempotentRequest{}
}

func (p *ConfigurationSetAtomicIdempotentRequest) GetAppName() string {
	return p.AppName
}

func (p *ConfigurationSetAtomicIdempotentRequest) GetAtomicIdempotent() bool {
	return p.AtomicIdempotent
}
func (p *ConfigurationSetAtomicIdempotentRequest) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRING {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.BOOL {
				if err := p.ReadField2(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ConfigurationSetAtomicIdempotentRequest) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return thrift.PrependError("error reading field 1: ", err)
	} else {
		p.AppName = v
	}
	return nil
}

func (p *ConfigurationSetAtomicIdempotentRequest) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBool(); err != nil {
		return thrift.PrependError("error reading field 2: ", err)
	} else {
		p.AtomicIdempotent = v
	}
	return nil
}

func (p *ConfigurationSetAtomicIdempotentRequest) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("configuration_set_atomic_idempotent_request"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		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 thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ConfigurationSetAtomicIdempotentRequest) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("app_name", thrift.STRING, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:app_name: ", p), err)
	}
	if err := oprot.WriteString(string(p.AppName)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.app_name (1) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:app_name: ", p), err)
	}
	return err
}

func (p *ConfigurationSetAtomicIdempotentRequest) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("atomic_idempotent", thrift.BOOL, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:atomic_idempotent: ", p), err)
	}
	if err := oprot.WriteBool(bool(p.AtomicIdempotent)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.atomic_idempotent (2) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:atomic_idempotent: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Err
//  - OldAtomicIdempotent
//  - HintMessage
type ConfigurationSetAtomicIdempotentResponse struct {
	Err                 *base.ErrorCode `thrift:"err,1" db:"err" json:"err"`
	OldAtomicIdempotent bool            `thrift:"old_atomic_idempotent,2" db:"old_atomic_idempotent" json:"old_atomic_idempotent"`
	HintMessage         string          `thrift:"hint_message,3" db:"hint_message" json:"hint_message"`
}

func NewConfigurationSetAtomicIdempotentResponse() *ConfigurationSetAtomicIdempotentResponse {
	return &ConfigurationSetAtomicIdempotentResponse{}
}

var ConfigurationSetAtomicIdempotentResponse_Err_DEFAULT *base.ErrorCode

func (p *ConfigurationSetAtomicIdempotentResponse) GetErr() *base.ErrorCode {
	if !p.IsSetErr() {
		return ConfigurationSetAtomicIdempotentResponse_Err_DEFAULT
	}
	return p.Err
}

func (p *ConfigurationSetAtomicIdempotentResponse) GetOldAtomicIdempotent() bool {
	return p.OldAtomicIdempotent
}

func (p *ConfigurationSetAtomicIdempotentResponse) GetHintMessage() string {
	return p.HintMessage
}
func (p *ConfigurationSetAtomicIdempotentResponse) IsSetErr() bool {
	return p.Err != nil
}

func (p *ConfigurationSetAtomicIdempotentResponse) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.BOOL {
				if err := p.ReadField2(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 3:
			if fieldTypeId == thrift.STRING {
				if err := p.ReadField3(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ConfigurationSetAtomicIdempotentResponse) ReadField1(iprot thrift.TProtocol) error {
	p.Err = &base.ErrorCode{}
	if err := p.Err.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Err), err)
	}
	return nil
}

func (p *ConfigurationSetAtomicIdempotentResponse) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBool(); err != nil {
		return thrift.PrependError("error reading field 2: ", err)
	} else {
		p.OldAtomicIdempotent = v
	}
	return nil
}

func (p *ConfigurationSetAtomicIdempotentResponse) ReadField3(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return thrift.PrependError("error reading field 3: ", err)
	} else {
		p.HintMessage = v
	}
	return nil
}

func (p *ConfigurationSetAtomicIdempotentResponse) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("configuration_set_atomic_idempotent_response"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		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 := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ConfigurationSetAtomicIdempotentResponse) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("err", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:err: ", p), err)
	}
	if err := p.Err.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Err), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:err: ", p), err)
	}
	return err
}

func (p *ConfigurationSetAtomicIdempotentResponse) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("old_atomic_idempotent", thrift.BOOL, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:old_atomic_idempotent: ", p), err)
	}
	if err := oprot.WriteBool(bool(p.OldAtomicIdempotent)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.old_atomic_idempotent (2) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:old_atomic_idempotent: ", p), err)
	}
	return err
}

func (p *ConfigurationSetAtomicIdempotentResponse) writeField3(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("hint_message", thrift.STRING, 3); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:hint_message: ", p), err)
	}
	if err := oprot.WriteString(string(p.HintMessage)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.hint_message (3) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:hint_message: ", p), err)
	}
	return err
}

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

type AdminClient interface {
	// Parameters:
	//  - Req
	CreateApp(ctx context.Context, req *ConfigurationCreateAppRequest) (r *ConfigurationCreateAppResponse, err error)
	// Parameters:
	//  - Req
	DropApp(ctx context.Context, req *ConfigurationDropAppRequest) (r *ConfigurationDropAppResponse, err error)
	// Parameters:
	//  - Req
	RecallApp(ctx context.Context, req *ConfigurationRecallAppRequest) (r *ConfigurationRecallAppResponse, err error)
	// Parameters:
	//  - Req
	ListApps(ctx context.Context, req *ConfigurationListAppsRequest) (r *ConfigurationListAppsResponse, err error)
	// Parameters:
	//  - Req
	AddDuplication(ctx context.Context, req *DuplicationAddRequest) (r *DuplicationAddResponse, err error)
	// Parameters:
	//  - Req
	QueryDuplication(ctx context.Context, req *DuplicationQueryRequest) (r *DuplicationQueryResponse, err error)
	// Parameters:
	//  - Req
	ModifyDuplication(ctx context.Context, req *DuplicationModifyRequest) (r *DuplicationModifyResponse, err error)
	// Parameters:
	//  - Req
	ListDuplication(ctx context.Context, req *DuplicationListRequest) (r *DuplicationListResponse, err error)
	// Parameters:
	//  - Req
	QueryAppInfo(ctx context.Context, req *QueryAppInfoRequest) (r *QueryAppInfoResponse, err error)
	// Parameters:
	//  - Req
	UpdateAppEnv(ctx context.Context, req *ConfigurationUpdateAppEnvRequest) (r *ConfigurationUpdateAppEnvResponse, err error)
	// Parameters:
	//  - Req
	ListNodes(ctx context.Context, req *ConfigurationListNodesRequest) (r *ConfigurationListNodesResponse, err error)
	// Parameters:
	//  - Req
	QueryClusterInfo(ctx context.Context, req *ConfigurationClusterInfoRequest) (r *ConfigurationClusterInfoResponse, err error)
	// Parameters:
	//  - Req
	MetaControl(ctx context.Context, req *ConfigurationMetaControlRequest) (r *ConfigurationMetaControlResponse, err error)
	// Parameters:
	//  - Req
	QueryBackupPolicy(ctx context.Context, req *ConfigurationQueryBackupPolicyRequest) (r *ConfigurationQueryBackupPolicyResponse, err error)
	// Parameters:
	//  - Req
	Balance(ctx context.Context, req *ConfigurationBalancerRequest) (r *ConfigurationBalancerResponse, err error)
	// Parameters:
	//  - Req
	StartBackupApp(ctx context.Context, req *StartBackupAppRequest) (r *StartBackupAppResponse, err error)
	// Parameters:
	//  - Req
	QueryBackupStatus(ctx context.Context, req *QueryBackupStatusRequest) (r *QueryBackupStatusResponse, err error)
	// Parameters:
	//  - Req
	RestoreApp(ctx context.Context, req *ConfigurationRestoreRequest) (r *ConfigurationCreateAppResponse, err error)
	// Parameters:
	//  - Req
	StartPartitionSplit(ctx context.Context, req *StartPartitionSplitRequest) (r *StartPartitionSplitResponse, err error)
	// Parameters:
	//  - Req
	QuerySplitStatus(ctx context.Context, req *QuerySplitRequest) (r *QuerySplitResponse, err error)
	// Parameters:
	//  - Req
	ControlPartitionSplit(ctx context.Context, req *ControlSplitRequest) (r *ControlSplitResponse, err error)
	// Parameters:
	//  - Req
	StartBulkLoad(ctx context.Context, req *StartBulkLoadRequest) (r *StartBulkLoadResponse, err error)
	// Parameters:
	//  - Req
	QueryBulkLoadStatus(ctx context.Context, req *QueryBulkLoadRequest) (r *QueryBulkLoadResponse, err error)
	// Parameters:
	//  - Req
	ControlBulkLoad(ctx context.Context, req *ControlBulkLoadRequest) (r *ControlBulkLoadResponse, err error)
	// Parameters:
	//  - Req
	ClearBulkLoad(ctx context.Context, req *ClearBulkLoadStateRequest) (r *ClearBulkLoadStateResponse, err error)
	// Parameters:
	//  - Req
	StartManualCompact(ctx context.Context, req *StartAppManualCompactRequest) (r *StartAppManualCompactResponse, err error)
	// Parameters:
	//  - Req
	QueryManualCompact(ctx context.Context, req *QueryAppManualCompactRequest) (r *QueryAppManualCompactResponse, err error)
}

type AdminClientClient struct {
	c thrift.TClient
}

func NewAdminClientClientFactory(t thrift.TTransport, f thrift.TProtocolFactory) *AdminClientClient {
	return &AdminClientClient{
		c: thrift.NewTStandardClient(f.GetProtocol(t), f.GetProtocol(t)),
	}
}

func NewAdminClientClientProtocol(t thrift.TTransport, iprot thrift.TProtocol, oprot thrift.TProtocol) *AdminClientClient {
	return &AdminClientClient{
		c: thrift.NewTStandardClient(iprot, oprot),
	}
}

func NewAdminClientClient(c thrift.TClient) *AdminClientClient {
	return &AdminClientClient{
		c: c,
	}
}

func (p *AdminClientClient) Client_() thrift.TClient {
	return p.c
}

// Parameters:
//  - Req
func (p *AdminClientClient) CreateApp(ctx context.Context, req *ConfigurationCreateAppRequest) (r *ConfigurationCreateAppResponse, err error) {
	var _args19 AdminClientCreateAppArgs
	_args19.Req = req
	var _result20 AdminClientCreateAppResult
	if err = p.Client_().Call(ctx, "create_app", &_args19, &_result20); err != nil {
		return
	}
	return _result20.GetSuccess(), nil
}

// Parameters:
//  - Req
func (p *AdminClientClient) DropApp(ctx context.Context, req *ConfigurationDropAppRequest) (r *ConfigurationDropAppResponse, err error) {
	var _args21 AdminClientDropAppArgs
	_args21.Req = req
	var _result22 AdminClientDropAppResult
	if err = p.Client_().Call(ctx, "drop_app", &_args21, &_result22); err != nil {
		return
	}
	return _result22.GetSuccess(), nil
}

// Parameters:
//  - Req
func (p *AdminClientClient) RecallApp(ctx context.Context, req *ConfigurationRecallAppRequest) (r *ConfigurationRecallAppResponse, err error) {
	var _args23 AdminClientRecallAppArgs
	_args23.Req = req
	var _result24 AdminClientRecallAppResult
	if err = p.Client_().Call(ctx, "recall_app", &_args23, &_result24); err != nil {
		return
	}
	return _result24.GetSuccess(), nil
}

// Parameters:
//  - Req
func (p *AdminClientClient) ListApps(ctx context.Context, req *ConfigurationListAppsRequest) (r *ConfigurationListAppsResponse, err error) {
	var _args25 AdminClientListAppsArgs
	_args25.Req = req
	var _result26 AdminClientListAppsResult
	if err = p.Client_().Call(ctx, "list_apps", &_args25, &_result26); err != nil {
		return
	}
	return _result26.GetSuccess(), nil
}

// Parameters:
//  - Req
func (p *AdminClientClient) AddDuplication(ctx context.Context, req *DuplicationAddRequest) (r *DuplicationAddResponse, err error) {
	var _args27 AdminClientAddDuplicationArgs
	_args27.Req = req
	var _result28 AdminClientAddDuplicationResult
	if err = p.Client_().Call(ctx, "add_duplication", &_args27, &_result28); err != nil {
		return
	}
	return _result28.GetSuccess(), nil
}

// Parameters:
//  - Req
func (p *AdminClientClient) QueryDuplication(ctx context.Context, req *DuplicationQueryRequest) (r *DuplicationQueryResponse, err error) {
	var _args29 AdminClientQueryDuplicationArgs
	_args29.Req = req
	var _result30 AdminClientQueryDuplicationResult
	if err = p.Client_().Call(ctx, "query_duplication", &_args29, &_result30); err != nil {
		return
	}
	return _result30.GetSuccess(), nil
}

// Parameters:
//  - Req
func (p *AdminClientClient) ModifyDuplication(ctx context.Context, req *DuplicationModifyRequest) (r *DuplicationModifyResponse, err error) {
	var _args31 AdminClientModifyDuplicationArgs
	_args31.Req = req
	var _result32 AdminClientModifyDuplicationResult
	if err = p.Client_().Call(ctx, "modify_duplication", &_args31, &_result32); err != nil {
		return
	}
	return _result32.GetSuccess(), nil
}

// Parameters:
//  - Req
func (p *AdminClientClient) ListDuplication(ctx context.Context, req *DuplicationListRequest) (r *DuplicationListResponse, err error) {
	var _args33 AdminClientListDuplicationArgs
	_args33.Req = req
	var _result34 AdminClientListDuplicationResult
	if err = p.Client_().Call(ctx, "list_duplication", &_args33, &_result34); err != nil {
		return
	}
	return _result34.GetSuccess(), nil
}

// Parameters:
//  - Req
func (p *AdminClientClient) QueryAppInfo(ctx context.Context, req *QueryAppInfoRequest) (r *QueryAppInfoResponse, err error) {
	var _args35 AdminClientQueryAppInfoArgs
	_args35.Req = req
	var _result36 AdminClientQueryAppInfoResult
	if err = p.Client_().Call(ctx, "query_app_info", &_args35, &_result36); err != nil {
		return
	}
	return _result36.GetSuccess(), nil
}

// Parameters:
//  - Req
func (p *AdminClientClient) UpdateAppEnv(ctx context.Context, req *ConfigurationUpdateAppEnvRequest) (r *ConfigurationUpdateAppEnvResponse, err error) {
	var _args37 AdminClientUpdateAppEnvArgs
	_args37.Req = req
	var _result38 AdminClientUpdateAppEnvResult
	if err = p.Client_().Call(ctx, "update_app_env", &_args37, &_result38); err != nil {
		return
	}
	return _result38.GetSuccess(), nil
}

// Parameters:
//  - Req
func (p *AdminClientClient) ListNodes(ctx context.Context, req *ConfigurationListNodesRequest) (r *ConfigurationListNodesResponse, err error) {
	var _args39 AdminClientListNodesArgs
	_args39.Req = req
	var _result40 AdminClientListNodesResult
	if err = p.Client_().Call(ctx, "list_nodes", &_args39, &_result40); err != nil {
		return
	}
	return _result40.GetSuccess(), nil
}

// Parameters:
//  - Req
func (p *AdminClientClient) QueryClusterInfo(ctx context.Context, req *ConfigurationClusterInfoRequest) (r *ConfigurationClusterInfoResponse, err error) {
	var _args41 AdminClientQueryClusterInfoArgs
	_args41.Req = req
	var _result42 AdminClientQueryClusterInfoResult
	if err = p.Client_().Call(ctx, "query_cluster_info", &_args41, &_result42); err != nil {
		return
	}
	return _result42.GetSuccess(), nil
}

// Parameters:
//  - Req
func (p *AdminClientClient) MetaControl(ctx context.Context, req *ConfigurationMetaControlRequest) (r *ConfigurationMetaControlResponse, err error) {
	var _args43 AdminClientMetaControlArgs
	_args43.Req = req
	var _result44 AdminClientMetaControlResult
	if err = p.Client_().Call(ctx, "meta_control", &_args43, &_result44); err != nil {
		return
	}
	return _result44.GetSuccess(), nil
}

// Parameters:
//  - Req
func (p *AdminClientClient) QueryBackupPolicy(ctx context.Context, req *ConfigurationQueryBackupPolicyRequest) (r *ConfigurationQueryBackupPolicyResponse, err error) {
	var _args45 AdminClientQueryBackupPolicyArgs
	_args45.Req = req
	var _result46 AdminClientQueryBackupPolicyResult
	if err = p.Client_().Call(ctx, "query_backup_policy", &_args45, &_result46); err != nil {
		return
	}
	return _result46.GetSuccess(), nil
}

// Parameters:
//  - Req
func (p *AdminClientClient) Balance(ctx context.Context, req *ConfigurationBalancerRequest) (r *ConfigurationBalancerResponse, err error) {
	var _args47 AdminClientBalanceArgs
	_args47.Req = req
	var _result48 AdminClientBalanceResult
	if err = p.Client_().Call(ctx, "balance", &_args47, &_result48); err != nil {
		return
	}
	return _result48.GetSuccess(), nil
}

// Parameters:
//  - Req
func (p *AdminClientClient) StartBackupApp(ctx context.Context, req *StartBackupAppRequest) (r *StartBackupAppResponse, err error) {
	var _args49 AdminClientStartBackupAppArgs
	_args49.Req = req
	var _result50 AdminClientStartBackupAppResult
	if err = p.Client_().Call(ctx, "start_backup_app", &_args49, &_result50); err != nil {
		return
	}
	return _result50.GetSuccess(), nil
}

// Parameters:
//  - Req
func (p *AdminClientClient) QueryBackupStatus(ctx context.Context, req *QueryBackupStatusRequest) (r *QueryBackupStatusResponse, err error) {
	var _args51 AdminClientQueryBackupStatusArgs
	_args51.Req = req
	var _result52 AdminClientQueryBackupStatusResult
	if err = p.Client_().Call(ctx, "query_backup_status", &_args51, &_result52); err != nil {
		return
	}
	return _result52.GetSuccess(), nil
}

// Parameters:
//  - Req
func (p *AdminClientClient) RestoreApp(ctx context.Context, req *ConfigurationRestoreRequest) (r *ConfigurationCreateAppResponse, err error) {
	var _args53 AdminClientRestoreAppArgs
	_args53.Req = req
	var _result54 AdminClientRestoreAppResult
	if err = p.Client_().Call(ctx, "restore_app", &_args53, &_result54); err != nil {
		return
	}
	return _result54.GetSuccess(), nil
}

// Parameters:
//  - Req
func (p *AdminClientClient) StartPartitionSplit(ctx context.Context, req *StartPartitionSplitRequest) (r *StartPartitionSplitResponse, err error) {
	var _args55 AdminClientStartPartitionSplitArgs
	_args55.Req = req
	var _result56 AdminClientStartPartitionSplitResult
	if err = p.Client_().Call(ctx, "start_partition_split", &_args55, &_result56); err != nil {
		return
	}
	return _result56.GetSuccess(), nil
}

// Parameters:
//  - Req
func (p *AdminClientClient) QuerySplitStatus(ctx context.Context, req *QuerySplitRequest) (r *QuerySplitResponse, err error) {
	var _args57 AdminClientQuerySplitStatusArgs
	_args57.Req = req
	var _result58 AdminClientQuerySplitStatusResult
	if err = p.Client_().Call(ctx, "query_split_status", &_args57, &_result58); err != nil {
		return
	}
	return _result58.GetSuccess(), nil
}

// Parameters:
//  - Req
func (p *AdminClientClient) ControlPartitionSplit(ctx context.Context, req *ControlSplitRequest) (r *ControlSplitResponse, err error) {
	var _args59 AdminClientControlPartitionSplitArgs
	_args59.Req = req
	var _result60 AdminClientControlPartitionSplitResult
	if err = p.Client_().Call(ctx, "control_partition_split", &_args59, &_result60); err != nil {
		return
	}
	return _result60.GetSuccess(), nil
}

// Parameters:
//  - Req
func (p *AdminClientClient) StartBulkLoad(ctx context.Context, req *StartBulkLoadRequest) (r *StartBulkLoadResponse, err error) {
	var _args61 AdminClientStartBulkLoadArgs
	_args61.Req = req
	var _result62 AdminClientStartBulkLoadResult
	if err = p.Client_().Call(ctx, "start_bulk_load", &_args61, &_result62); err != nil {
		return
	}
	return _result62.GetSuccess(), nil
}

// Parameters:
//  - Req
func (p *AdminClientClient) QueryBulkLoadStatus(ctx context.Context, req *QueryBulkLoadRequest) (r *QueryBulkLoadResponse, err error) {
	var _args63 AdminClientQueryBulkLoadStatusArgs
	_args63.Req = req
	var _result64 AdminClientQueryBulkLoadStatusResult
	if err = p.Client_().Call(ctx, "query_bulk_load_status", &_args63, &_result64); err != nil {
		return
	}
	return _result64.GetSuccess(), nil
}

// Parameters:
//  - Req
func (p *AdminClientClient) ControlBulkLoad(ctx context.Context, req *ControlBulkLoadRequest) (r *ControlBulkLoadResponse, err error) {
	var _args65 AdminClientControlBulkLoadArgs
	_args65.Req = req
	var _result66 AdminClientControlBulkLoadResult
	if err = p.Client_().Call(ctx, "control_bulk_load", &_args65, &_result66); err != nil {
		return
	}
	return _result66.GetSuccess(), nil
}

// Parameters:
//  - Req
func (p *AdminClientClient) ClearBulkLoad(ctx context.Context, req *ClearBulkLoadStateRequest) (r *ClearBulkLoadStateResponse, err error) {
	var _args67 AdminClientClearBulkLoadArgs
	_args67.Req = req
	var _result68 AdminClientClearBulkLoadResult
	if err = p.Client_().Call(ctx, "clear_bulk_load", &_args67, &_result68); err != nil {
		return
	}
	return _result68.GetSuccess(), nil
}

// Parameters:
//  - Req
func (p *AdminClientClient) StartManualCompact(ctx context.Context, req *StartAppManualCompactRequest) (r *StartAppManualCompactResponse, err error) {
	var _args69 AdminClientStartManualCompactArgs
	_args69.Req = req
	var _result70 AdminClientStartManualCompactResult
	if err = p.Client_().Call(ctx, "start_manual_compact", &_args69, &_result70); err != nil {
		return
	}
	return _result70.GetSuccess(), nil
}

// Parameters:
//  - Req
func (p *AdminClientClient) QueryManualCompact(ctx context.Context, req *QueryAppManualCompactRequest) (r *QueryAppManualCompactResponse, err error) {
	var _args71 AdminClientQueryManualCompactArgs
	_args71.Req = req
	var _result72 AdminClientQueryManualCompactResult
	if err = p.Client_().Call(ctx, "query_manual_compact", &_args71, &_result72); err != nil {
		return
	}
	return _result72.GetSuccess(), nil
}

type AdminClientProcessor struct {
	processorMap map[string]thrift.TProcessorFunction
	handler      AdminClient
}

func (p *AdminClientProcessor) AddToProcessorMap(key string, processor thrift.TProcessorFunction) {
	p.processorMap[key] = processor
}

func (p *AdminClientProcessor) GetProcessorFunction(key string) (processor thrift.TProcessorFunction, ok bool) {
	processor, ok = p.processorMap[key]
	return processor, ok
}

func (p *AdminClientProcessor) ProcessorMap() map[string]thrift.TProcessorFunction {
	return p.processorMap
}

func NewAdminClientProcessor(handler AdminClient) *AdminClientProcessor {

	self73 := &AdminClientProcessor{handler: handler, processorMap: make(map[string]thrift.TProcessorFunction)}
	self73.processorMap["create_app"] = &adminClientProcessorCreateApp{handler: handler}
	self73.processorMap["drop_app"] = &adminClientProcessorDropApp{handler: handler}
	self73.processorMap["recall_app"] = &adminClientProcessorRecallApp{handler: handler}
	self73.processorMap["list_apps"] = &adminClientProcessorListApps{handler: handler}
	self73.processorMap["add_duplication"] = &adminClientProcessorAddDuplication{handler: handler}
	self73.processorMap["query_duplication"] = &adminClientProcessorQueryDuplication{handler: handler}
	self73.processorMap["modify_duplication"] = &adminClientProcessorModifyDuplication{handler: handler}
	self73.processorMap["list_duplication"] = &adminClientProcessorListDuplication{handler: handler}
	self73.processorMap["query_app_info"] = &adminClientProcessorQueryAppInfo{handler: handler}
	self73.processorMap["update_app_env"] = &adminClientProcessorUpdateAppEnv{handler: handler}
	self73.processorMap["list_nodes"] = &adminClientProcessorListNodes{handler: handler}
	self73.processorMap["query_cluster_info"] = &adminClientProcessorQueryClusterInfo{handler: handler}
	self73.processorMap["meta_control"] = &adminClientProcessorMetaControl{handler: handler}
	self73.processorMap["query_backup_policy"] = &adminClientProcessorQueryBackupPolicy{handler: handler}
	self73.processorMap["balance"] = &adminClientProcessorBalance{handler: handler}
	self73.processorMap["start_backup_app"] = &adminClientProcessorStartBackupApp{handler: handler}
	self73.processorMap["query_backup_status"] = &adminClientProcessorQueryBackupStatus{handler: handler}
	self73.processorMap["restore_app"] = &adminClientProcessorRestoreApp{handler: handler}
	self73.processorMap["start_partition_split"] = &adminClientProcessorStartPartitionSplit{handler: handler}
	self73.processorMap["query_split_status"] = &adminClientProcessorQuerySplitStatus{handler: handler}
	self73.processorMap["control_partition_split"] = &adminClientProcessorControlPartitionSplit{handler: handler}
	self73.processorMap["start_bulk_load"] = &adminClientProcessorStartBulkLoad{handler: handler}
	self73.processorMap["query_bulk_load_status"] = &adminClientProcessorQueryBulkLoadStatus{handler: handler}
	self73.processorMap["control_bulk_load"] = &adminClientProcessorControlBulkLoad{handler: handler}
	self73.processorMap["clear_bulk_load"] = &adminClientProcessorClearBulkLoad{handler: handler}
	self73.processorMap["start_manual_compact"] = &adminClientProcessorStartManualCompact{handler: handler}
	self73.processorMap["query_manual_compact"] = &adminClientProcessorQueryManualCompact{handler: handler}
	return self73
}

func (p *AdminClientProcessor) Process(ctx context.Context, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	name, _, seqId, err := iprot.ReadMessageBegin()
	if err != nil {
		return false, err
	}
	if processor, ok := p.GetProcessorFunction(name); ok {
		return processor.Process(ctx, seqId, iprot, oprot)
	}
	iprot.Skip(thrift.STRUCT)
	iprot.ReadMessageEnd()
	x74 := thrift.NewTApplicationException(thrift.UNKNOWN_METHOD, "Unknown function "+name)
	oprot.WriteMessageBegin(name, thrift.EXCEPTION, seqId)
	x74.Write(oprot)
	oprot.WriteMessageEnd()
	oprot.Flush(ctx)
	return false, x74

}

type adminClientProcessorCreateApp struct {
	handler AdminClient
}

func (p *adminClientProcessorCreateApp) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := AdminClientCreateAppArgs{}
	if err = args.Read(iprot); err != nil {
		iprot.ReadMessageEnd()
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
		oprot.WriteMessageBegin("create_app", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return false, err
	}

	iprot.ReadMessageEnd()
	result := AdminClientCreateAppResult{}
	var retval *ConfigurationCreateAppResponse
	var err2 error
	if retval, err2 = p.handler.CreateApp(ctx, args.Req); err2 != nil {
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing create_app: "+err2.Error())
		oprot.WriteMessageBegin("create_app", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return true, err2
	} else {
		result.Success = retval
	}
	if err2 = oprot.WriteMessageBegin("create_app", thrift.REPLY, seqId); err2 != nil {
		err = err2
	}
	if err2 = result.Write(oprot); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
		err = err2
	}
	if err != nil {
		return
	}
	return true, err
}

type adminClientProcessorDropApp struct {
	handler AdminClient
}

func (p *adminClientProcessorDropApp) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := AdminClientDropAppArgs{}
	if err = args.Read(iprot); err != nil {
		iprot.ReadMessageEnd()
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
		oprot.WriteMessageBegin("drop_app", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return false, err
	}

	iprot.ReadMessageEnd()
	result := AdminClientDropAppResult{}
	var retval *ConfigurationDropAppResponse
	var err2 error
	if retval, err2 = p.handler.DropApp(ctx, args.Req); err2 != nil {
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing drop_app: "+err2.Error())
		oprot.WriteMessageBegin("drop_app", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return true, err2
	} else {
		result.Success = retval
	}
	if err2 = oprot.WriteMessageBegin("drop_app", thrift.REPLY, seqId); err2 != nil {
		err = err2
	}
	if err2 = result.Write(oprot); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
		err = err2
	}
	if err != nil {
		return
	}
	return true, err
}

type adminClientProcessorRecallApp struct {
	handler AdminClient
}

func (p *adminClientProcessorRecallApp) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := AdminClientRecallAppArgs{}
	if err = args.Read(iprot); err != nil {
		iprot.ReadMessageEnd()
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
		oprot.WriteMessageBegin("recall_app", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return false, err
	}

	iprot.ReadMessageEnd()
	result := AdminClientRecallAppResult{}
	var retval *ConfigurationRecallAppResponse
	var err2 error
	if retval, err2 = p.handler.RecallApp(ctx, args.Req); err2 != nil {
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing recall_app: "+err2.Error())
		oprot.WriteMessageBegin("recall_app", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return true, err2
	} else {
		result.Success = retval
	}
	if err2 = oprot.WriteMessageBegin("recall_app", thrift.REPLY, seqId); err2 != nil {
		err = err2
	}
	if err2 = result.Write(oprot); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
		err = err2
	}
	if err != nil {
		return
	}
	return true, err
}

type adminClientProcessorListApps struct {
	handler AdminClient
}

func (p *adminClientProcessorListApps) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := AdminClientListAppsArgs{}
	if err = args.Read(iprot); err != nil {
		iprot.ReadMessageEnd()
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
		oprot.WriteMessageBegin("list_apps", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return false, err
	}

	iprot.ReadMessageEnd()
	result := AdminClientListAppsResult{}
	var retval *ConfigurationListAppsResponse
	var err2 error
	if retval, err2 = p.handler.ListApps(ctx, args.Req); err2 != nil {
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing list_apps: "+err2.Error())
		oprot.WriteMessageBegin("list_apps", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return true, err2
	} else {
		result.Success = retval
	}
	if err2 = oprot.WriteMessageBegin("list_apps", thrift.REPLY, seqId); err2 != nil {
		err = err2
	}
	if err2 = result.Write(oprot); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
		err = err2
	}
	if err != nil {
		return
	}
	return true, err
}

type adminClientProcessorAddDuplication struct {
	handler AdminClient
}

func (p *adminClientProcessorAddDuplication) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := AdminClientAddDuplicationArgs{}
	if err = args.Read(iprot); err != nil {
		iprot.ReadMessageEnd()
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
		oprot.WriteMessageBegin("add_duplication", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return false, err
	}

	iprot.ReadMessageEnd()
	result := AdminClientAddDuplicationResult{}
	var retval *DuplicationAddResponse
	var err2 error
	if retval, err2 = p.handler.AddDuplication(ctx, args.Req); err2 != nil {
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing add_duplication: "+err2.Error())
		oprot.WriteMessageBegin("add_duplication", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return true, err2
	} else {
		result.Success = retval
	}
	if err2 = oprot.WriteMessageBegin("add_duplication", thrift.REPLY, seqId); err2 != nil {
		err = err2
	}
	if err2 = result.Write(oprot); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
		err = err2
	}
	if err != nil {
		return
	}
	return true, err
}

type adminClientProcessorQueryDuplication struct {
	handler AdminClient
}

func (p *adminClientProcessorQueryDuplication) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := AdminClientQueryDuplicationArgs{}
	if err = args.Read(iprot); err != nil {
		iprot.ReadMessageEnd()
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
		oprot.WriteMessageBegin("query_duplication", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return false, err
	}

	iprot.ReadMessageEnd()
	result := AdminClientQueryDuplicationResult{}
	var retval *DuplicationQueryResponse
	var err2 error
	if retval, err2 = p.handler.QueryDuplication(ctx, args.Req); err2 != nil {
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing query_duplication: "+err2.Error())
		oprot.WriteMessageBegin("query_duplication", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return true, err2
	} else {
		result.Success = retval
	}
	if err2 = oprot.WriteMessageBegin("query_duplication", thrift.REPLY, seqId); err2 != nil {
		err = err2
	}
	if err2 = result.Write(oprot); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
		err = err2
	}
	if err != nil {
		return
	}
	return true, err
}

type adminClientProcessorModifyDuplication struct {
	handler AdminClient
}

func (p *adminClientProcessorModifyDuplication) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := AdminClientModifyDuplicationArgs{}
	if err = args.Read(iprot); err != nil {
		iprot.ReadMessageEnd()
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
		oprot.WriteMessageBegin("modify_duplication", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return false, err
	}

	iprot.ReadMessageEnd()
	result := AdminClientModifyDuplicationResult{}
	var retval *DuplicationModifyResponse
	var err2 error
	if retval, err2 = p.handler.ModifyDuplication(ctx, args.Req); err2 != nil {
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing modify_duplication: "+err2.Error())
		oprot.WriteMessageBegin("modify_duplication", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return true, err2
	} else {
		result.Success = retval
	}
	if err2 = oprot.WriteMessageBegin("modify_duplication", thrift.REPLY, seqId); err2 != nil {
		err = err2
	}
	if err2 = result.Write(oprot); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
		err = err2
	}
	if err != nil {
		return
	}
	return true, err
}

type adminClientProcessorListDuplication struct {
	handler AdminClient
}

func (p *adminClientProcessorListDuplication) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := AdminClientListDuplicationArgs{}
	if err = args.Read(iprot); err != nil {
		iprot.ReadMessageEnd()
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
		oprot.WriteMessageBegin("list_duplication", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return false, err
	}

	iprot.ReadMessageEnd()
	result := AdminClientListDuplicationResult{}
	var retval *DuplicationListResponse
	var err2 error
	if retval, err2 = p.handler.ListDuplication(ctx, args.Req); err2 != nil {
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing list_duplication: "+err2.Error())
		oprot.WriteMessageBegin("list_duplication", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return true, err2
	} else {
		result.Success = retval
	}
	if err2 = oprot.WriteMessageBegin("list_duplication", thrift.REPLY, seqId); err2 != nil {
		err = err2
	}
	if err2 = result.Write(oprot); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
		err = err2
	}
	if err != nil {
		return
	}
	return true, err
}

type adminClientProcessorQueryAppInfo struct {
	handler AdminClient
}

func (p *adminClientProcessorQueryAppInfo) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := AdminClientQueryAppInfoArgs{}
	if err = args.Read(iprot); err != nil {
		iprot.ReadMessageEnd()
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
		oprot.WriteMessageBegin("query_app_info", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return false, err
	}

	iprot.ReadMessageEnd()
	result := AdminClientQueryAppInfoResult{}
	var retval *QueryAppInfoResponse
	var err2 error
	if retval, err2 = p.handler.QueryAppInfo(ctx, args.Req); err2 != nil {
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing query_app_info: "+err2.Error())
		oprot.WriteMessageBegin("query_app_info", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return true, err2
	} else {
		result.Success = retval
	}
	if err2 = oprot.WriteMessageBegin("query_app_info", thrift.REPLY, seqId); err2 != nil {
		err = err2
	}
	if err2 = result.Write(oprot); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
		err = err2
	}
	if err != nil {
		return
	}
	return true, err
}

type adminClientProcessorUpdateAppEnv struct {
	handler AdminClient
}

func (p *adminClientProcessorUpdateAppEnv) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := AdminClientUpdateAppEnvArgs{}
	if err = args.Read(iprot); err != nil {
		iprot.ReadMessageEnd()
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
		oprot.WriteMessageBegin("update_app_env", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return false, err
	}

	iprot.ReadMessageEnd()
	result := AdminClientUpdateAppEnvResult{}
	var retval *ConfigurationUpdateAppEnvResponse
	var err2 error
	if retval, err2 = p.handler.UpdateAppEnv(ctx, args.Req); err2 != nil {
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing update_app_env: "+err2.Error())
		oprot.WriteMessageBegin("update_app_env", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return true, err2
	} else {
		result.Success = retval
	}
	if err2 = oprot.WriteMessageBegin("update_app_env", thrift.REPLY, seqId); err2 != nil {
		err = err2
	}
	if err2 = result.Write(oprot); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
		err = err2
	}
	if err != nil {
		return
	}
	return true, err
}

type adminClientProcessorListNodes struct {
	handler AdminClient
}

func (p *adminClientProcessorListNodes) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := AdminClientListNodesArgs{}
	if err = args.Read(iprot); err != nil {
		iprot.ReadMessageEnd()
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
		oprot.WriteMessageBegin("list_nodes", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return false, err
	}

	iprot.ReadMessageEnd()
	result := AdminClientListNodesResult{}
	var retval *ConfigurationListNodesResponse
	var err2 error
	if retval, err2 = p.handler.ListNodes(ctx, args.Req); err2 != nil {
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing list_nodes: "+err2.Error())
		oprot.WriteMessageBegin("list_nodes", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return true, err2
	} else {
		result.Success = retval
	}
	if err2 = oprot.WriteMessageBegin("list_nodes", thrift.REPLY, seqId); err2 != nil {
		err = err2
	}
	if err2 = result.Write(oprot); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
		err = err2
	}
	if err != nil {
		return
	}
	return true, err
}

type adminClientProcessorQueryClusterInfo struct {
	handler AdminClient
}

func (p *adminClientProcessorQueryClusterInfo) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := AdminClientQueryClusterInfoArgs{}
	if err = args.Read(iprot); err != nil {
		iprot.ReadMessageEnd()
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
		oprot.WriteMessageBegin("query_cluster_info", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return false, err
	}

	iprot.ReadMessageEnd()
	result := AdminClientQueryClusterInfoResult{}
	var retval *ConfigurationClusterInfoResponse
	var err2 error
	if retval, err2 = p.handler.QueryClusterInfo(ctx, args.Req); err2 != nil {
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing query_cluster_info: "+err2.Error())
		oprot.WriteMessageBegin("query_cluster_info", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return true, err2
	} else {
		result.Success = retval
	}
	if err2 = oprot.WriteMessageBegin("query_cluster_info", thrift.REPLY, seqId); err2 != nil {
		err = err2
	}
	if err2 = result.Write(oprot); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
		err = err2
	}
	if err != nil {
		return
	}
	return true, err
}

type adminClientProcessorMetaControl struct {
	handler AdminClient
}

func (p *adminClientProcessorMetaControl) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := AdminClientMetaControlArgs{}
	if err = args.Read(iprot); err != nil {
		iprot.ReadMessageEnd()
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
		oprot.WriteMessageBegin("meta_control", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return false, err
	}

	iprot.ReadMessageEnd()
	result := AdminClientMetaControlResult{}
	var retval *ConfigurationMetaControlResponse
	var err2 error
	if retval, err2 = p.handler.MetaControl(ctx, args.Req); err2 != nil {
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing meta_control: "+err2.Error())
		oprot.WriteMessageBegin("meta_control", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return true, err2
	} else {
		result.Success = retval
	}
	if err2 = oprot.WriteMessageBegin("meta_control", thrift.REPLY, seqId); err2 != nil {
		err = err2
	}
	if err2 = result.Write(oprot); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
		err = err2
	}
	if err != nil {
		return
	}
	return true, err
}

type adminClientProcessorQueryBackupPolicy struct {
	handler AdminClient
}

func (p *adminClientProcessorQueryBackupPolicy) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := AdminClientQueryBackupPolicyArgs{}
	if err = args.Read(iprot); err != nil {
		iprot.ReadMessageEnd()
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
		oprot.WriteMessageBegin("query_backup_policy", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return false, err
	}

	iprot.ReadMessageEnd()
	result := AdminClientQueryBackupPolicyResult{}
	var retval *ConfigurationQueryBackupPolicyResponse
	var err2 error
	if retval, err2 = p.handler.QueryBackupPolicy(ctx, args.Req); err2 != nil {
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing query_backup_policy: "+err2.Error())
		oprot.WriteMessageBegin("query_backup_policy", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return true, err2
	} else {
		result.Success = retval
	}
	if err2 = oprot.WriteMessageBegin("query_backup_policy", thrift.REPLY, seqId); err2 != nil {
		err = err2
	}
	if err2 = result.Write(oprot); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
		err = err2
	}
	if err != nil {
		return
	}
	return true, err
}

type adminClientProcessorBalance struct {
	handler AdminClient
}

func (p *adminClientProcessorBalance) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := AdminClientBalanceArgs{}
	if err = args.Read(iprot); err != nil {
		iprot.ReadMessageEnd()
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
		oprot.WriteMessageBegin("balance", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return false, err
	}

	iprot.ReadMessageEnd()
	result := AdminClientBalanceResult{}
	var retval *ConfigurationBalancerResponse
	var err2 error
	if retval, err2 = p.handler.Balance(ctx, args.Req); err2 != nil {
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing balance: "+err2.Error())
		oprot.WriteMessageBegin("balance", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return true, err2
	} else {
		result.Success = retval
	}
	if err2 = oprot.WriteMessageBegin("balance", thrift.REPLY, seqId); err2 != nil {
		err = err2
	}
	if err2 = result.Write(oprot); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
		err = err2
	}
	if err != nil {
		return
	}
	return true, err
}

type adminClientProcessorStartBackupApp struct {
	handler AdminClient
}

func (p *adminClientProcessorStartBackupApp) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := AdminClientStartBackupAppArgs{}
	if err = args.Read(iprot); err != nil {
		iprot.ReadMessageEnd()
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
		oprot.WriteMessageBegin("start_backup_app", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return false, err
	}

	iprot.ReadMessageEnd()
	result := AdminClientStartBackupAppResult{}
	var retval *StartBackupAppResponse
	var err2 error
	if retval, err2 = p.handler.StartBackupApp(ctx, args.Req); err2 != nil {
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing start_backup_app: "+err2.Error())
		oprot.WriteMessageBegin("start_backup_app", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return true, err2
	} else {
		result.Success = retval
	}
	if err2 = oprot.WriteMessageBegin("start_backup_app", thrift.REPLY, seqId); err2 != nil {
		err = err2
	}
	if err2 = result.Write(oprot); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
		err = err2
	}
	if err != nil {
		return
	}
	return true, err
}

type adminClientProcessorQueryBackupStatus struct {
	handler AdminClient
}

func (p *adminClientProcessorQueryBackupStatus) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := AdminClientQueryBackupStatusArgs{}
	if err = args.Read(iprot); err != nil {
		iprot.ReadMessageEnd()
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
		oprot.WriteMessageBegin("query_backup_status", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return false, err
	}

	iprot.ReadMessageEnd()
	result := AdminClientQueryBackupStatusResult{}
	var retval *QueryBackupStatusResponse
	var err2 error
	if retval, err2 = p.handler.QueryBackupStatus(ctx, args.Req); err2 != nil {
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing query_backup_status: "+err2.Error())
		oprot.WriteMessageBegin("query_backup_status", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return true, err2
	} else {
		result.Success = retval
	}
	if err2 = oprot.WriteMessageBegin("query_backup_status", thrift.REPLY, seqId); err2 != nil {
		err = err2
	}
	if err2 = result.Write(oprot); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
		err = err2
	}
	if err != nil {
		return
	}
	return true, err
}

type adminClientProcessorRestoreApp struct {
	handler AdminClient
}

func (p *adminClientProcessorRestoreApp) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := AdminClientRestoreAppArgs{}
	if err = args.Read(iprot); err != nil {
		iprot.ReadMessageEnd()
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
		oprot.WriteMessageBegin("restore_app", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return false, err
	}

	iprot.ReadMessageEnd()
	result := AdminClientRestoreAppResult{}
	var retval *ConfigurationCreateAppResponse
	var err2 error
	if retval, err2 = p.handler.RestoreApp(ctx, args.Req); err2 != nil {
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing restore_app: "+err2.Error())
		oprot.WriteMessageBegin("restore_app", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return true, err2
	} else {
		result.Success = retval
	}
	if err2 = oprot.WriteMessageBegin("restore_app", thrift.REPLY, seqId); err2 != nil {
		err = err2
	}
	if err2 = result.Write(oprot); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
		err = err2
	}
	if err != nil {
		return
	}
	return true, err
}

type adminClientProcessorStartPartitionSplit struct {
	handler AdminClient
}

func (p *adminClientProcessorStartPartitionSplit) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := AdminClientStartPartitionSplitArgs{}
	if err = args.Read(iprot); err != nil {
		iprot.ReadMessageEnd()
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
		oprot.WriteMessageBegin("start_partition_split", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return false, err
	}

	iprot.ReadMessageEnd()
	result := AdminClientStartPartitionSplitResult{}
	var retval *StartPartitionSplitResponse
	var err2 error
	if retval, err2 = p.handler.StartPartitionSplit(ctx, args.Req); err2 != nil {
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing start_partition_split: "+err2.Error())
		oprot.WriteMessageBegin("start_partition_split", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return true, err2
	} else {
		result.Success = retval
	}
	if err2 = oprot.WriteMessageBegin("start_partition_split", thrift.REPLY, seqId); err2 != nil {
		err = err2
	}
	if err2 = result.Write(oprot); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
		err = err2
	}
	if err != nil {
		return
	}
	return true, err
}

type adminClientProcessorQuerySplitStatus struct {
	handler AdminClient
}

func (p *adminClientProcessorQuerySplitStatus) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := AdminClientQuerySplitStatusArgs{}
	if err = args.Read(iprot); err != nil {
		iprot.ReadMessageEnd()
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
		oprot.WriteMessageBegin("query_split_status", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return false, err
	}

	iprot.ReadMessageEnd()
	result := AdminClientQuerySplitStatusResult{}
	var retval *QuerySplitResponse
	var err2 error
	if retval, err2 = p.handler.QuerySplitStatus(ctx, args.Req); err2 != nil {
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing query_split_status: "+err2.Error())
		oprot.WriteMessageBegin("query_split_status", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return true, err2
	} else {
		result.Success = retval
	}
	if err2 = oprot.WriteMessageBegin("query_split_status", thrift.REPLY, seqId); err2 != nil {
		err = err2
	}
	if err2 = result.Write(oprot); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
		err = err2
	}
	if err != nil {
		return
	}
	return true, err
}

type adminClientProcessorControlPartitionSplit struct {
	handler AdminClient
}

func (p *adminClientProcessorControlPartitionSplit) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := AdminClientControlPartitionSplitArgs{}
	if err = args.Read(iprot); err != nil {
		iprot.ReadMessageEnd()
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
		oprot.WriteMessageBegin("control_partition_split", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return false, err
	}

	iprot.ReadMessageEnd()
	result := AdminClientControlPartitionSplitResult{}
	var retval *ControlSplitResponse
	var err2 error
	if retval, err2 = p.handler.ControlPartitionSplit(ctx, args.Req); err2 != nil {
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing control_partition_split: "+err2.Error())
		oprot.WriteMessageBegin("control_partition_split", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return true, err2
	} else {
		result.Success = retval
	}
	if err2 = oprot.WriteMessageBegin("control_partition_split", thrift.REPLY, seqId); err2 != nil {
		err = err2
	}
	if err2 = result.Write(oprot); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
		err = err2
	}
	if err != nil {
		return
	}
	return true, err
}

type adminClientProcessorStartBulkLoad struct {
	handler AdminClient
}

func (p *adminClientProcessorStartBulkLoad) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := AdminClientStartBulkLoadArgs{}
	if err = args.Read(iprot); err != nil {
		iprot.ReadMessageEnd()
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
		oprot.WriteMessageBegin("start_bulk_load", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return false, err
	}

	iprot.ReadMessageEnd()
	result := AdminClientStartBulkLoadResult{}
	var retval *StartBulkLoadResponse
	var err2 error
	if retval, err2 = p.handler.StartBulkLoad(ctx, args.Req); err2 != nil {
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing start_bulk_load: "+err2.Error())
		oprot.WriteMessageBegin("start_bulk_load", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return true, err2
	} else {
		result.Success = retval
	}
	if err2 = oprot.WriteMessageBegin("start_bulk_load", thrift.REPLY, seqId); err2 != nil {
		err = err2
	}
	if err2 = result.Write(oprot); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
		err = err2
	}
	if err != nil {
		return
	}
	return true, err
}

type adminClientProcessorQueryBulkLoadStatus struct {
	handler AdminClient
}

func (p *adminClientProcessorQueryBulkLoadStatus) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := AdminClientQueryBulkLoadStatusArgs{}
	if err = args.Read(iprot); err != nil {
		iprot.ReadMessageEnd()
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
		oprot.WriteMessageBegin("query_bulk_load_status", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return false, err
	}

	iprot.ReadMessageEnd()
	result := AdminClientQueryBulkLoadStatusResult{}
	var retval *QueryBulkLoadResponse
	var err2 error
	if retval, err2 = p.handler.QueryBulkLoadStatus(ctx, args.Req); err2 != nil {
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing query_bulk_load_status: "+err2.Error())
		oprot.WriteMessageBegin("query_bulk_load_status", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return true, err2
	} else {
		result.Success = retval
	}
	if err2 = oprot.WriteMessageBegin("query_bulk_load_status", thrift.REPLY, seqId); err2 != nil {
		err = err2
	}
	if err2 = result.Write(oprot); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
		err = err2
	}
	if err != nil {
		return
	}
	return true, err
}

type adminClientProcessorControlBulkLoad struct {
	handler AdminClient
}

func (p *adminClientProcessorControlBulkLoad) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := AdminClientControlBulkLoadArgs{}
	if err = args.Read(iprot); err != nil {
		iprot.ReadMessageEnd()
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
		oprot.WriteMessageBegin("control_bulk_load", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return false, err
	}

	iprot.ReadMessageEnd()
	result := AdminClientControlBulkLoadResult{}
	var retval *ControlBulkLoadResponse
	var err2 error
	if retval, err2 = p.handler.ControlBulkLoad(ctx, args.Req); err2 != nil {
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing control_bulk_load: "+err2.Error())
		oprot.WriteMessageBegin("control_bulk_load", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return true, err2
	} else {
		result.Success = retval
	}
	if err2 = oprot.WriteMessageBegin("control_bulk_load", thrift.REPLY, seqId); err2 != nil {
		err = err2
	}
	if err2 = result.Write(oprot); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
		err = err2
	}
	if err != nil {
		return
	}
	return true, err
}

type adminClientProcessorClearBulkLoad struct {
	handler AdminClient
}

func (p *adminClientProcessorClearBulkLoad) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := AdminClientClearBulkLoadArgs{}
	if err = args.Read(iprot); err != nil {
		iprot.ReadMessageEnd()
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
		oprot.WriteMessageBegin("clear_bulk_load", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return false, err
	}

	iprot.ReadMessageEnd()
	result := AdminClientClearBulkLoadResult{}
	var retval *ClearBulkLoadStateResponse
	var err2 error
	if retval, err2 = p.handler.ClearBulkLoad(ctx, args.Req); err2 != nil {
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing clear_bulk_load: "+err2.Error())
		oprot.WriteMessageBegin("clear_bulk_load", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return true, err2
	} else {
		result.Success = retval
	}
	if err2 = oprot.WriteMessageBegin("clear_bulk_load", thrift.REPLY, seqId); err2 != nil {
		err = err2
	}
	if err2 = result.Write(oprot); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
		err = err2
	}
	if err != nil {
		return
	}
	return true, err
}

type adminClientProcessorStartManualCompact struct {
	handler AdminClient
}

func (p *adminClientProcessorStartManualCompact) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := AdminClientStartManualCompactArgs{}
	if err = args.Read(iprot); err != nil {
		iprot.ReadMessageEnd()
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
		oprot.WriteMessageBegin("start_manual_compact", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return false, err
	}

	iprot.ReadMessageEnd()
	result := AdminClientStartManualCompactResult{}
	var retval *StartAppManualCompactResponse
	var err2 error
	if retval, err2 = p.handler.StartManualCompact(ctx, args.Req); err2 != nil {
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing start_manual_compact: "+err2.Error())
		oprot.WriteMessageBegin("start_manual_compact", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return true, err2
	} else {
		result.Success = retval
	}
	if err2 = oprot.WriteMessageBegin("start_manual_compact", thrift.REPLY, seqId); err2 != nil {
		err = err2
	}
	if err2 = result.Write(oprot); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
		err = err2
	}
	if err != nil {
		return
	}
	return true, err
}

type adminClientProcessorQueryManualCompact struct {
	handler AdminClient
}

func (p *adminClientProcessorQueryManualCompact) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := AdminClientQueryManualCompactArgs{}
	if err = args.Read(iprot); err != nil {
		iprot.ReadMessageEnd()
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
		oprot.WriteMessageBegin("query_manual_compact", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return false, err
	}

	iprot.ReadMessageEnd()
	result := AdminClientQueryManualCompactResult{}
	var retval *QueryAppManualCompactResponse
	var err2 error
	if retval, err2 = p.handler.QueryManualCompact(ctx, args.Req); err2 != nil {
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing query_manual_compact: "+err2.Error())
		oprot.WriteMessageBegin("query_manual_compact", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return true, err2
	} else {
		result.Success = retval
	}
	if err2 = oprot.WriteMessageBegin("query_manual_compact", thrift.REPLY, seqId); err2 != nil {
		err = err2
	}
	if err2 = result.Write(oprot); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
		err = err2
	}
	if err != nil {
		return
	}
	return true, err
}

// HELPER FUNCTIONS AND STRUCTURES

// Attributes:
//  - Req
type AdminClientCreateAppArgs struct {
	Req *ConfigurationCreateAppRequest `thrift:"req,1" db:"req" json:"req"`
}

func NewAdminClientCreateAppArgs() *AdminClientCreateAppArgs {
	return &AdminClientCreateAppArgs{}
}

var AdminClientCreateAppArgs_Req_DEFAULT *ConfigurationCreateAppRequest

func (p *AdminClientCreateAppArgs) GetReq() *ConfigurationCreateAppRequest {
	if !p.IsSetReq() {
		return AdminClientCreateAppArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *AdminClientCreateAppArgs) IsSetReq() bool {
	return p.Req != nil
}

func (p *AdminClientCreateAppArgs) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientCreateAppArgs) ReadField1(iprot thrift.TProtocol) error {
	p.Req = &ConfigurationCreateAppRequest{}
	if err := p.Req.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err)
	}
	return nil
}

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

func (p *AdminClientCreateAppArgs) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("req", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:req: ", p), err)
	}
	if err := p.Req.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Req), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:req: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Success
type AdminClientCreateAppResult struct {
	Success *ConfigurationCreateAppResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewAdminClientCreateAppResult() *AdminClientCreateAppResult {
	return &AdminClientCreateAppResult{}
}

var AdminClientCreateAppResult_Success_DEFAULT *ConfigurationCreateAppResponse

func (p *AdminClientCreateAppResult) GetSuccess() *ConfigurationCreateAppResponse {
	if !p.IsSetSuccess() {
		return AdminClientCreateAppResult_Success_DEFAULT
	}
	return p.Success
}
func (p *AdminClientCreateAppResult) IsSetSuccess() bool {
	return p.Success != nil
}

func (p *AdminClientCreateAppResult) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 0:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField0(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientCreateAppResult) ReadField0(iprot thrift.TProtocol) error {
	p.Success = &ConfigurationCreateAppResponse{}
	if err := p.Success.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
	}
	return nil
}

func (p *AdminClientCreateAppResult) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("create_app_result"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		if err := p.writeField0(oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *AdminClientCreateAppResult) writeField0(oprot thrift.TProtocol) (err error) {
	if p.IsSetSuccess() {
		if err := oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
		}
		if err := p.Success.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - Req
type AdminClientDropAppArgs struct {
	Req *ConfigurationDropAppRequest `thrift:"req,1" db:"req" json:"req"`
}

func NewAdminClientDropAppArgs() *AdminClientDropAppArgs {
	return &AdminClientDropAppArgs{}
}

var AdminClientDropAppArgs_Req_DEFAULT *ConfigurationDropAppRequest

func (p *AdminClientDropAppArgs) GetReq() *ConfigurationDropAppRequest {
	if !p.IsSetReq() {
		return AdminClientDropAppArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *AdminClientDropAppArgs) IsSetReq() bool {
	return p.Req != nil
}

func (p *AdminClientDropAppArgs) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientDropAppArgs) ReadField1(iprot thrift.TProtocol) error {
	p.Req = &ConfigurationDropAppRequest{}
	if err := p.Req.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err)
	}
	return nil
}

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

func (p *AdminClientDropAppArgs) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("req", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:req: ", p), err)
	}
	if err := p.Req.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Req), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:req: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Success
type AdminClientDropAppResult struct {
	Success *ConfigurationDropAppResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewAdminClientDropAppResult() *AdminClientDropAppResult {
	return &AdminClientDropAppResult{}
}

var AdminClientDropAppResult_Success_DEFAULT *ConfigurationDropAppResponse

func (p *AdminClientDropAppResult) GetSuccess() *ConfigurationDropAppResponse {
	if !p.IsSetSuccess() {
		return AdminClientDropAppResult_Success_DEFAULT
	}
	return p.Success
}
func (p *AdminClientDropAppResult) IsSetSuccess() bool {
	return p.Success != nil
}

func (p *AdminClientDropAppResult) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 0:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField0(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientDropAppResult) ReadField0(iprot thrift.TProtocol) error {
	p.Success = &ConfigurationDropAppResponse{}
	if err := p.Success.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
	}
	return nil
}

func (p *AdminClientDropAppResult) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("drop_app_result"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		if err := p.writeField0(oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *AdminClientDropAppResult) writeField0(oprot thrift.TProtocol) (err error) {
	if p.IsSetSuccess() {
		if err := oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
		}
		if err := p.Success.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - Req
type AdminClientRecallAppArgs struct {
	Req *ConfigurationRecallAppRequest `thrift:"req,1" db:"req" json:"req"`
}

func NewAdminClientRecallAppArgs() *AdminClientRecallAppArgs {
	return &AdminClientRecallAppArgs{}
}

var AdminClientRecallAppArgs_Req_DEFAULT *ConfigurationRecallAppRequest

func (p *AdminClientRecallAppArgs) GetReq() *ConfigurationRecallAppRequest {
	if !p.IsSetReq() {
		return AdminClientRecallAppArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *AdminClientRecallAppArgs) IsSetReq() bool {
	return p.Req != nil
}

func (p *AdminClientRecallAppArgs) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientRecallAppArgs) ReadField1(iprot thrift.TProtocol) error {
	p.Req = &ConfigurationRecallAppRequest{}
	if err := p.Req.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err)
	}
	return nil
}

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

func (p *AdminClientRecallAppArgs) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("req", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:req: ", p), err)
	}
	if err := p.Req.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Req), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:req: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Success
type AdminClientRecallAppResult struct {
	Success *ConfigurationRecallAppResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewAdminClientRecallAppResult() *AdminClientRecallAppResult {
	return &AdminClientRecallAppResult{}
}

var AdminClientRecallAppResult_Success_DEFAULT *ConfigurationRecallAppResponse

func (p *AdminClientRecallAppResult) GetSuccess() *ConfigurationRecallAppResponse {
	if !p.IsSetSuccess() {
		return AdminClientRecallAppResult_Success_DEFAULT
	}
	return p.Success
}
func (p *AdminClientRecallAppResult) IsSetSuccess() bool {
	return p.Success != nil
}

func (p *AdminClientRecallAppResult) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 0:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField0(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientRecallAppResult) ReadField0(iprot thrift.TProtocol) error {
	p.Success = &ConfigurationRecallAppResponse{}
	if err := p.Success.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
	}
	return nil
}

func (p *AdminClientRecallAppResult) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("recall_app_result"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		if err := p.writeField0(oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *AdminClientRecallAppResult) writeField0(oprot thrift.TProtocol) (err error) {
	if p.IsSetSuccess() {
		if err := oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
		}
		if err := p.Success.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - Req
type AdminClientListAppsArgs struct {
	Req *ConfigurationListAppsRequest `thrift:"req,1" db:"req" json:"req"`
}

func NewAdminClientListAppsArgs() *AdminClientListAppsArgs {
	return &AdminClientListAppsArgs{}
}

var AdminClientListAppsArgs_Req_DEFAULT *ConfigurationListAppsRequest

func (p *AdminClientListAppsArgs) GetReq() *ConfigurationListAppsRequest {
	if !p.IsSetReq() {
		return AdminClientListAppsArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *AdminClientListAppsArgs) IsSetReq() bool {
	return p.Req != nil
}

func (p *AdminClientListAppsArgs) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientListAppsArgs) ReadField1(iprot thrift.TProtocol) error {
	p.Req = &ConfigurationListAppsRequest{
		Status: 0,
	}
	if err := p.Req.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err)
	}
	return nil
}

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

func (p *AdminClientListAppsArgs) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("req", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:req: ", p), err)
	}
	if err := p.Req.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Req), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:req: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Success
type AdminClientListAppsResult struct {
	Success *ConfigurationListAppsResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewAdminClientListAppsResult() *AdminClientListAppsResult {
	return &AdminClientListAppsResult{}
}

var AdminClientListAppsResult_Success_DEFAULT *ConfigurationListAppsResponse

func (p *AdminClientListAppsResult) GetSuccess() *ConfigurationListAppsResponse {
	if !p.IsSetSuccess() {
		return AdminClientListAppsResult_Success_DEFAULT
	}
	return p.Success
}
func (p *AdminClientListAppsResult) IsSetSuccess() bool {
	return p.Success != nil
}

func (p *AdminClientListAppsResult) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 0:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField0(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientListAppsResult) ReadField0(iprot thrift.TProtocol) error {
	p.Success = &ConfigurationListAppsResponse{}
	if err := p.Success.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
	}
	return nil
}

func (p *AdminClientListAppsResult) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("list_apps_result"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		if err := p.writeField0(oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *AdminClientListAppsResult) writeField0(oprot thrift.TProtocol) (err error) {
	if p.IsSetSuccess() {
		if err := oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
		}
		if err := p.Success.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - Req
type AdminClientAddDuplicationArgs struct {
	Req *DuplicationAddRequest `thrift:"req,1" db:"req" json:"req"`
}

func NewAdminClientAddDuplicationArgs() *AdminClientAddDuplicationArgs {
	return &AdminClientAddDuplicationArgs{}
}

var AdminClientAddDuplicationArgs_Req_DEFAULT *DuplicationAddRequest

func (p *AdminClientAddDuplicationArgs) GetReq() *DuplicationAddRequest {
	if !p.IsSetReq() {
		return AdminClientAddDuplicationArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *AdminClientAddDuplicationArgs) IsSetReq() bool {
	return p.Req != nil
}

func (p *AdminClientAddDuplicationArgs) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientAddDuplicationArgs) ReadField1(iprot thrift.TProtocol) error {
	p.Req = &DuplicationAddRequest{
		IsDuplicatingCheckpoint: true,
	}
	if err := p.Req.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err)
	}
	return nil
}

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

func (p *AdminClientAddDuplicationArgs) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("req", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:req: ", p), err)
	}
	if err := p.Req.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Req), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:req: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Success
type AdminClientAddDuplicationResult struct {
	Success *DuplicationAddResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewAdminClientAddDuplicationResult() *AdminClientAddDuplicationResult {
	return &AdminClientAddDuplicationResult{}
}

var AdminClientAddDuplicationResult_Success_DEFAULT *DuplicationAddResponse

func (p *AdminClientAddDuplicationResult) GetSuccess() *DuplicationAddResponse {
	if !p.IsSetSuccess() {
		return AdminClientAddDuplicationResult_Success_DEFAULT
	}
	return p.Success
}
func (p *AdminClientAddDuplicationResult) IsSetSuccess() bool {
	return p.Success != nil
}

func (p *AdminClientAddDuplicationResult) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 0:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField0(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientAddDuplicationResult) ReadField0(iprot thrift.TProtocol) error {
	p.Success = &DuplicationAddResponse{}
	if err := p.Success.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
	}
	return nil
}

func (p *AdminClientAddDuplicationResult) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("add_duplication_result"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		if err := p.writeField0(oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *AdminClientAddDuplicationResult) writeField0(oprot thrift.TProtocol) (err error) {
	if p.IsSetSuccess() {
		if err := oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
		}
		if err := p.Success.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - Req
type AdminClientQueryDuplicationArgs struct {
	Req *DuplicationQueryRequest `thrift:"req,1" db:"req" json:"req"`
}

func NewAdminClientQueryDuplicationArgs() *AdminClientQueryDuplicationArgs {
	return &AdminClientQueryDuplicationArgs{}
}

var AdminClientQueryDuplicationArgs_Req_DEFAULT *DuplicationQueryRequest

func (p *AdminClientQueryDuplicationArgs) GetReq() *DuplicationQueryRequest {
	if !p.IsSetReq() {
		return AdminClientQueryDuplicationArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *AdminClientQueryDuplicationArgs) IsSetReq() bool {
	return p.Req != nil
}

func (p *AdminClientQueryDuplicationArgs) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientQueryDuplicationArgs) ReadField1(iprot thrift.TProtocol) error {
	p.Req = &DuplicationQueryRequest{}
	if err := p.Req.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err)
	}
	return nil
}

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

func (p *AdminClientQueryDuplicationArgs) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("req", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:req: ", p), err)
	}
	if err := p.Req.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Req), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:req: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Success
type AdminClientQueryDuplicationResult struct {
	Success *DuplicationQueryResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewAdminClientQueryDuplicationResult() *AdminClientQueryDuplicationResult {
	return &AdminClientQueryDuplicationResult{}
}

var AdminClientQueryDuplicationResult_Success_DEFAULT *DuplicationQueryResponse

func (p *AdminClientQueryDuplicationResult) GetSuccess() *DuplicationQueryResponse {
	if !p.IsSetSuccess() {
		return AdminClientQueryDuplicationResult_Success_DEFAULT
	}
	return p.Success
}
func (p *AdminClientQueryDuplicationResult) IsSetSuccess() bool {
	return p.Success != nil
}

func (p *AdminClientQueryDuplicationResult) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 0:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField0(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientQueryDuplicationResult) ReadField0(iprot thrift.TProtocol) error {
	p.Success = &DuplicationQueryResponse{}
	if err := p.Success.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
	}
	return nil
}

func (p *AdminClientQueryDuplicationResult) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("query_duplication_result"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		if err := p.writeField0(oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *AdminClientQueryDuplicationResult) writeField0(oprot thrift.TProtocol) (err error) {
	if p.IsSetSuccess() {
		if err := oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
		}
		if err := p.Success.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - Req
type AdminClientModifyDuplicationArgs struct {
	Req *DuplicationModifyRequest `thrift:"req,1" db:"req" json:"req"`
}

func NewAdminClientModifyDuplicationArgs() *AdminClientModifyDuplicationArgs {
	return &AdminClientModifyDuplicationArgs{}
}

var AdminClientModifyDuplicationArgs_Req_DEFAULT *DuplicationModifyRequest

func (p *AdminClientModifyDuplicationArgs) GetReq() *DuplicationModifyRequest {
	if !p.IsSetReq() {
		return AdminClientModifyDuplicationArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *AdminClientModifyDuplicationArgs) IsSetReq() bool {
	return p.Req != nil
}

func (p *AdminClientModifyDuplicationArgs) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientModifyDuplicationArgs) ReadField1(iprot thrift.TProtocol) error {
	p.Req = &DuplicationModifyRequest{}
	if err := p.Req.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err)
	}
	return nil
}

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

func (p *AdminClientModifyDuplicationArgs) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("req", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:req: ", p), err)
	}
	if err := p.Req.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Req), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:req: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Success
type AdminClientModifyDuplicationResult struct {
	Success *DuplicationModifyResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewAdminClientModifyDuplicationResult() *AdminClientModifyDuplicationResult {
	return &AdminClientModifyDuplicationResult{}
}

var AdminClientModifyDuplicationResult_Success_DEFAULT *DuplicationModifyResponse

func (p *AdminClientModifyDuplicationResult) GetSuccess() *DuplicationModifyResponse {
	if !p.IsSetSuccess() {
		return AdminClientModifyDuplicationResult_Success_DEFAULT
	}
	return p.Success
}
func (p *AdminClientModifyDuplicationResult) IsSetSuccess() bool {
	return p.Success != nil
}

func (p *AdminClientModifyDuplicationResult) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 0:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField0(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientModifyDuplicationResult) ReadField0(iprot thrift.TProtocol) error {
	p.Success = &DuplicationModifyResponse{}
	if err := p.Success.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
	}
	return nil
}

func (p *AdminClientModifyDuplicationResult) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("modify_duplication_result"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		if err := p.writeField0(oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *AdminClientModifyDuplicationResult) writeField0(oprot thrift.TProtocol) (err error) {
	if p.IsSetSuccess() {
		if err := oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
		}
		if err := p.Success.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - Req
type AdminClientListDuplicationArgs struct {
	Req *DuplicationListRequest `thrift:"req,1" db:"req" json:"req"`
}

func NewAdminClientListDuplicationArgs() *AdminClientListDuplicationArgs {
	return &AdminClientListDuplicationArgs{}
}

var AdminClientListDuplicationArgs_Req_DEFAULT *DuplicationListRequest

func (p *AdminClientListDuplicationArgs) GetReq() *DuplicationListRequest {
	if !p.IsSetReq() {
		return AdminClientListDuplicationArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *AdminClientListDuplicationArgs) IsSetReq() bool {
	return p.Req != nil
}

func (p *AdminClientListDuplicationArgs) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientListDuplicationArgs) ReadField1(iprot thrift.TProtocol) error {
	p.Req = &DuplicationListRequest{}
	if err := p.Req.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err)
	}
	return nil
}

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

func (p *AdminClientListDuplicationArgs) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("req", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:req: ", p), err)
	}
	if err := p.Req.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Req), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:req: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Success
type AdminClientListDuplicationResult struct {
	Success *DuplicationListResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewAdminClientListDuplicationResult() *AdminClientListDuplicationResult {
	return &AdminClientListDuplicationResult{}
}

var AdminClientListDuplicationResult_Success_DEFAULT *DuplicationListResponse

func (p *AdminClientListDuplicationResult) GetSuccess() *DuplicationListResponse {
	if !p.IsSetSuccess() {
		return AdminClientListDuplicationResult_Success_DEFAULT
	}
	return p.Success
}
func (p *AdminClientListDuplicationResult) IsSetSuccess() bool {
	return p.Success != nil
}

func (p *AdminClientListDuplicationResult) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 0:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField0(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientListDuplicationResult) ReadField0(iprot thrift.TProtocol) error {
	p.Success = &DuplicationListResponse{}
	if err := p.Success.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
	}
	return nil
}

func (p *AdminClientListDuplicationResult) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("list_duplication_result"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		if err := p.writeField0(oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *AdminClientListDuplicationResult) writeField0(oprot thrift.TProtocol) (err error) {
	if p.IsSetSuccess() {
		if err := oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
		}
		if err := p.Success.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - Req
type AdminClientQueryAppInfoArgs struct {
	Req *QueryAppInfoRequest `thrift:"req,1" db:"req" json:"req"`
}

func NewAdminClientQueryAppInfoArgs() *AdminClientQueryAppInfoArgs {
	return &AdminClientQueryAppInfoArgs{}
}

var AdminClientQueryAppInfoArgs_Req_DEFAULT *QueryAppInfoRequest

func (p *AdminClientQueryAppInfoArgs) GetReq() *QueryAppInfoRequest {
	if !p.IsSetReq() {
		return AdminClientQueryAppInfoArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *AdminClientQueryAppInfoArgs) IsSetReq() bool {
	return p.Req != nil
}

func (p *AdminClientQueryAppInfoArgs) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientQueryAppInfoArgs) ReadField1(iprot thrift.TProtocol) error {
	p.Req = &QueryAppInfoRequest{}
	if err := p.Req.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err)
	}
	return nil
}

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

func (p *AdminClientQueryAppInfoArgs) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("req", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:req: ", p), err)
	}
	if err := p.Req.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Req), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:req: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Success
type AdminClientQueryAppInfoResult struct {
	Success *QueryAppInfoResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewAdminClientQueryAppInfoResult() *AdminClientQueryAppInfoResult {
	return &AdminClientQueryAppInfoResult{}
}

var AdminClientQueryAppInfoResult_Success_DEFAULT *QueryAppInfoResponse

func (p *AdminClientQueryAppInfoResult) GetSuccess() *QueryAppInfoResponse {
	if !p.IsSetSuccess() {
		return AdminClientQueryAppInfoResult_Success_DEFAULT
	}
	return p.Success
}
func (p *AdminClientQueryAppInfoResult) IsSetSuccess() bool {
	return p.Success != nil
}

func (p *AdminClientQueryAppInfoResult) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 0:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField0(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientQueryAppInfoResult) ReadField0(iprot thrift.TProtocol) error {
	p.Success = &QueryAppInfoResponse{}
	if err := p.Success.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
	}
	return nil
}

func (p *AdminClientQueryAppInfoResult) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("query_app_info_result"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		if err := p.writeField0(oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *AdminClientQueryAppInfoResult) writeField0(oprot thrift.TProtocol) (err error) {
	if p.IsSetSuccess() {
		if err := oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
		}
		if err := p.Success.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - Req
type AdminClientUpdateAppEnvArgs struct {
	Req *ConfigurationUpdateAppEnvRequest `thrift:"req,1" db:"req" json:"req"`
}

func NewAdminClientUpdateAppEnvArgs() *AdminClientUpdateAppEnvArgs {
	return &AdminClientUpdateAppEnvArgs{}
}

var AdminClientUpdateAppEnvArgs_Req_DEFAULT *ConfigurationUpdateAppEnvRequest

func (p *AdminClientUpdateAppEnvArgs) GetReq() *ConfigurationUpdateAppEnvRequest {
	if !p.IsSetReq() {
		return AdminClientUpdateAppEnvArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *AdminClientUpdateAppEnvArgs) IsSetReq() bool {
	return p.Req != nil
}

func (p *AdminClientUpdateAppEnvArgs) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientUpdateAppEnvArgs) ReadField1(iprot thrift.TProtocol) error {
	p.Req = &ConfigurationUpdateAppEnvRequest{
		Op: 0,
	}
	if err := p.Req.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err)
	}
	return nil
}

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

func (p *AdminClientUpdateAppEnvArgs) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("req", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:req: ", p), err)
	}
	if err := p.Req.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Req), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:req: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Success
type AdminClientUpdateAppEnvResult struct {
	Success *ConfigurationUpdateAppEnvResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewAdminClientUpdateAppEnvResult() *AdminClientUpdateAppEnvResult {
	return &AdminClientUpdateAppEnvResult{}
}

var AdminClientUpdateAppEnvResult_Success_DEFAULT *ConfigurationUpdateAppEnvResponse

func (p *AdminClientUpdateAppEnvResult) GetSuccess() *ConfigurationUpdateAppEnvResponse {
	if !p.IsSetSuccess() {
		return AdminClientUpdateAppEnvResult_Success_DEFAULT
	}
	return p.Success
}
func (p *AdminClientUpdateAppEnvResult) IsSetSuccess() bool {
	return p.Success != nil
}

func (p *AdminClientUpdateAppEnvResult) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 0:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField0(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientUpdateAppEnvResult) ReadField0(iprot thrift.TProtocol) error {
	p.Success = &ConfigurationUpdateAppEnvResponse{}
	if err := p.Success.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
	}
	return nil
}

func (p *AdminClientUpdateAppEnvResult) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("update_app_env_result"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		if err := p.writeField0(oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *AdminClientUpdateAppEnvResult) writeField0(oprot thrift.TProtocol) (err error) {
	if p.IsSetSuccess() {
		if err := oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
		}
		if err := p.Success.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - Req
type AdminClientListNodesArgs struct {
	Req *ConfigurationListNodesRequest `thrift:"req,1" db:"req" json:"req"`
}

func NewAdminClientListNodesArgs() *AdminClientListNodesArgs {
	return &AdminClientListNodesArgs{}
}

var AdminClientListNodesArgs_Req_DEFAULT *ConfigurationListNodesRequest

func (p *AdminClientListNodesArgs) GetReq() *ConfigurationListNodesRequest {
	if !p.IsSetReq() {
		return AdminClientListNodesArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *AdminClientListNodesArgs) IsSetReq() bool {
	return p.Req != nil
}

func (p *AdminClientListNodesArgs) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientListNodesArgs) ReadField1(iprot thrift.TProtocol) error {
	p.Req = &ConfigurationListNodesRequest{
		Status: 0,
	}
	if err := p.Req.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err)
	}
	return nil
}

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

func (p *AdminClientListNodesArgs) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("req", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:req: ", p), err)
	}
	if err := p.Req.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Req), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:req: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Success
type AdminClientListNodesResult struct {
	Success *ConfigurationListNodesResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewAdminClientListNodesResult() *AdminClientListNodesResult {
	return &AdminClientListNodesResult{}
}

var AdminClientListNodesResult_Success_DEFAULT *ConfigurationListNodesResponse

func (p *AdminClientListNodesResult) GetSuccess() *ConfigurationListNodesResponse {
	if !p.IsSetSuccess() {
		return AdminClientListNodesResult_Success_DEFAULT
	}
	return p.Success
}
func (p *AdminClientListNodesResult) IsSetSuccess() bool {
	return p.Success != nil
}

func (p *AdminClientListNodesResult) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 0:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField0(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientListNodesResult) ReadField0(iprot thrift.TProtocol) error {
	p.Success = &ConfigurationListNodesResponse{}
	if err := p.Success.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
	}
	return nil
}

func (p *AdminClientListNodesResult) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("list_nodes_result"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		if err := p.writeField0(oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *AdminClientListNodesResult) writeField0(oprot thrift.TProtocol) (err error) {
	if p.IsSetSuccess() {
		if err := oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
		}
		if err := p.Success.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - Req
type AdminClientQueryClusterInfoArgs struct {
	Req *ConfigurationClusterInfoRequest `thrift:"req,1" db:"req" json:"req"`
}

func NewAdminClientQueryClusterInfoArgs() *AdminClientQueryClusterInfoArgs {
	return &AdminClientQueryClusterInfoArgs{}
}

var AdminClientQueryClusterInfoArgs_Req_DEFAULT *ConfigurationClusterInfoRequest

func (p *AdminClientQueryClusterInfoArgs) GetReq() *ConfigurationClusterInfoRequest {
	if !p.IsSetReq() {
		return AdminClientQueryClusterInfoArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *AdminClientQueryClusterInfoArgs) IsSetReq() bool {
	return p.Req != nil
}

func (p *AdminClientQueryClusterInfoArgs) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientQueryClusterInfoArgs) ReadField1(iprot thrift.TProtocol) error {
	p.Req = &ConfigurationClusterInfoRequest{}
	if err := p.Req.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err)
	}
	return nil
}

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

func (p *AdminClientQueryClusterInfoArgs) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("req", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:req: ", p), err)
	}
	if err := p.Req.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Req), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:req: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Success
type AdminClientQueryClusterInfoResult struct {
	Success *ConfigurationClusterInfoResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewAdminClientQueryClusterInfoResult() *AdminClientQueryClusterInfoResult {
	return &AdminClientQueryClusterInfoResult{}
}

var AdminClientQueryClusterInfoResult_Success_DEFAULT *ConfigurationClusterInfoResponse

func (p *AdminClientQueryClusterInfoResult) GetSuccess() *ConfigurationClusterInfoResponse {
	if !p.IsSetSuccess() {
		return AdminClientQueryClusterInfoResult_Success_DEFAULT
	}
	return p.Success
}
func (p *AdminClientQueryClusterInfoResult) IsSetSuccess() bool {
	return p.Success != nil
}

func (p *AdminClientQueryClusterInfoResult) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 0:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField0(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientQueryClusterInfoResult) ReadField0(iprot thrift.TProtocol) error {
	p.Success = &ConfigurationClusterInfoResponse{}
	if err := p.Success.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
	}
	return nil
}

func (p *AdminClientQueryClusterInfoResult) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("query_cluster_info_result"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		if err := p.writeField0(oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *AdminClientQueryClusterInfoResult) writeField0(oprot thrift.TProtocol) (err error) {
	if p.IsSetSuccess() {
		if err := oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
		}
		if err := p.Success.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - Req
type AdminClientMetaControlArgs struct {
	Req *ConfigurationMetaControlRequest `thrift:"req,1" db:"req" json:"req"`
}

func NewAdminClientMetaControlArgs() *AdminClientMetaControlArgs {
	return &AdminClientMetaControlArgs{}
}

var AdminClientMetaControlArgs_Req_DEFAULT *ConfigurationMetaControlRequest

func (p *AdminClientMetaControlArgs) GetReq() *ConfigurationMetaControlRequest {
	if !p.IsSetReq() {
		return AdminClientMetaControlArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *AdminClientMetaControlArgs) IsSetReq() bool {
	return p.Req != nil
}

func (p *AdminClientMetaControlArgs) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientMetaControlArgs) ReadField1(iprot thrift.TProtocol) error {
	p.Req = &ConfigurationMetaControlRequest{}
	if err := p.Req.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err)
	}
	return nil
}

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

func (p *AdminClientMetaControlArgs) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("req", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:req: ", p), err)
	}
	if err := p.Req.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Req), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:req: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Success
type AdminClientMetaControlResult struct {
	Success *ConfigurationMetaControlResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewAdminClientMetaControlResult() *AdminClientMetaControlResult {
	return &AdminClientMetaControlResult{}
}

var AdminClientMetaControlResult_Success_DEFAULT *ConfigurationMetaControlResponse

func (p *AdminClientMetaControlResult) GetSuccess() *ConfigurationMetaControlResponse {
	if !p.IsSetSuccess() {
		return AdminClientMetaControlResult_Success_DEFAULT
	}
	return p.Success
}
func (p *AdminClientMetaControlResult) IsSetSuccess() bool {
	return p.Success != nil
}

func (p *AdminClientMetaControlResult) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 0:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField0(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientMetaControlResult) ReadField0(iprot thrift.TProtocol) error {
	p.Success = &ConfigurationMetaControlResponse{}
	if err := p.Success.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
	}
	return nil
}

func (p *AdminClientMetaControlResult) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("meta_control_result"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		if err := p.writeField0(oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *AdminClientMetaControlResult) writeField0(oprot thrift.TProtocol) (err error) {
	if p.IsSetSuccess() {
		if err := oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
		}
		if err := p.Success.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - Req
type AdminClientQueryBackupPolicyArgs struct {
	Req *ConfigurationQueryBackupPolicyRequest `thrift:"req,1" db:"req" json:"req"`
}

func NewAdminClientQueryBackupPolicyArgs() *AdminClientQueryBackupPolicyArgs {
	return &AdminClientQueryBackupPolicyArgs{}
}

var AdminClientQueryBackupPolicyArgs_Req_DEFAULT *ConfigurationQueryBackupPolicyRequest

func (p *AdminClientQueryBackupPolicyArgs) GetReq() *ConfigurationQueryBackupPolicyRequest {
	if !p.IsSetReq() {
		return AdminClientQueryBackupPolicyArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *AdminClientQueryBackupPolicyArgs) IsSetReq() bool {
	return p.Req != nil
}

func (p *AdminClientQueryBackupPolicyArgs) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientQueryBackupPolicyArgs) ReadField1(iprot thrift.TProtocol) error {
	p.Req = &ConfigurationQueryBackupPolicyRequest{}
	if err := p.Req.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err)
	}
	return nil
}

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

func (p *AdminClientQueryBackupPolicyArgs) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("req", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:req: ", p), err)
	}
	if err := p.Req.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Req), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:req: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Success
type AdminClientQueryBackupPolicyResult struct {
	Success *ConfigurationQueryBackupPolicyResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewAdminClientQueryBackupPolicyResult() *AdminClientQueryBackupPolicyResult {
	return &AdminClientQueryBackupPolicyResult{}
}

var AdminClientQueryBackupPolicyResult_Success_DEFAULT *ConfigurationQueryBackupPolicyResponse

func (p *AdminClientQueryBackupPolicyResult) GetSuccess() *ConfigurationQueryBackupPolicyResponse {
	if !p.IsSetSuccess() {
		return AdminClientQueryBackupPolicyResult_Success_DEFAULT
	}
	return p.Success
}
func (p *AdminClientQueryBackupPolicyResult) IsSetSuccess() bool {
	return p.Success != nil
}

func (p *AdminClientQueryBackupPolicyResult) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 0:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField0(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientQueryBackupPolicyResult) ReadField0(iprot thrift.TProtocol) error {
	p.Success = &ConfigurationQueryBackupPolicyResponse{}
	if err := p.Success.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
	}
	return nil
}

func (p *AdminClientQueryBackupPolicyResult) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("query_backup_policy_result"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		if err := p.writeField0(oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *AdminClientQueryBackupPolicyResult) writeField0(oprot thrift.TProtocol) (err error) {
	if p.IsSetSuccess() {
		if err := oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
		}
		if err := p.Success.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - Req
type AdminClientBalanceArgs struct {
	Req *ConfigurationBalancerRequest `thrift:"req,1" db:"req" json:"req"`
}

func NewAdminClientBalanceArgs() *AdminClientBalanceArgs {
	return &AdminClientBalanceArgs{}
}

var AdminClientBalanceArgs_Req_DEFAULT *ConfigurationBalancerRequest

func (p *AdminClientBalanceArgs) GetReq() *ConfigurationBalancerRequest {
	if !p.IsSetReq() {
		return AdminClientBalanceArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *AdminClientBalanceArgs) IsSetReq() bool {
	return p.Req != nil
}

func (p *AdminClientBalanceArgs) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientBalanceArgs) ReadField1(iprot thrift.TProtocol) error {
	p.Req = &ConfigurationBalancerRequest{}
	if err := p.Req.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err)
	}
	return nil
}

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

func (p *AdminClientBalanceArgs) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("req", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:req: ", p), err)
	}
	if err := p.Req.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Req), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:req: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Success
type AdminClientBalanceResult struct {
	Success *ConfigurationBalancerResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewAdminClientBalanceResult() *AdminClientBalanceResult {
	return &AdminClientBalanceResult{}
}

var AdminClientBalanceResult_Success_DEFAULT *ConfigurationBalancerResponse

func (p *AdminClientBalanceResult) GetSuccess() *ConfigurationBalancerResponse {
	if !p.IsSetSuccess() {
		return AdminClientBalanceResult_Success_DEFAULT
	}
	return p.Success
}
func (p *AdminClientBalanceResult) IsSetSuccess() bool {
	return p.Success != nil
}

func (p *AdminClientBalanceResult) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 0:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField0(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientBalanceResult) ReadField0(iprot thrift.TProtocol) error {
	p.Success = &ConfigurationBalancerResponse{}
	if err := p.Success.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
	}
	return nil
}

func (p *AdminClientBalanceResult) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("balance_result"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		if err := p.writeField0(oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *AdminClientBalanceResult) writeField0(oprot thrift.TProtocol) (err error) {
	if p.IsSetSuccess() {
		if err := oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
		}
		if err := p.Success.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - Req
type AdminClientStartBackupAppArgs struct {
	Req *StartBackupAppRequest `thrift:"req,1" db:"req" json:"req"`
}

func NewAdminClientStartBackupAppArgs() *AdminClientStartBackupAppArgs {
	return &AdminClientStartBackupAppArgs{}
}

var AdminClientStartBackupAppArgs_Req_DEFAULT *StartBackupAppRequest

func (p *AdminClientStartBackupAppArgs) GetReq() *StartBackupAppRequest {
	if !p.IsSetReq() {
		return AdminClientStartBackupAppArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *AdminClientStartBackupAppArgs) IsSetReq() bool {
	return p.Req != nil
}

func (p *AdminClientStartBackupAppArgs) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientStartBackupAppArgs) ReadField1(iprot thrift.TProtocol) error {
	p.Req = &StartBackupAppRequest{}
	if err := p.Req.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err)
	}
	return nil
}

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

func (p *AdminClientStartBackupAppArgs) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("req", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:req: ", p), err)
	}
	if err := p.Req.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Req), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:req: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Success
type AdminClientStartBackupAppResult struct {
	Success *StartBackupAppResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewAdminClientStartBackupAppResult() *AdminClientStartBackupAppResult {
	return &AdminClientStartBackupAppResult{}
}

var AdminClientStartBackupAppResult_Success_DEFAULT *StartBackupAppResponse

func (p *AdminClientStartBackupAppResult) GetSuccess() *StartBackupAppResponse {
	if !p.IsSetSuccess() {
		return AdminClientStartBackupAppResult_Success_DEFAULT
	}
	return p.Success
}
func (p *AdminClientStartBackupAppResult) IsSetSuccess() bool {
	return p.Success != nil
}

func (p *AdminClientStartBackupAppResult) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 0:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField0(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientStartBackupAppResult) ReadField0(iprot thrift.TProtocol) error {
	p.Success = &StartBackupAppResponse{}
	if err := p.Success.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
	}
	return nil
}

func (p *AdminClientStartBackupAppResult) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("start_backup_app_result"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		if err := p.writeField0(oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *AdminClientStartBackupAppResult) writeField0(oprot thrift.TProtocol) (err error) {
	if p.IsSetSuccess() {
		if err := oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
		}
		if err := p.Success.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - Req
type AdminClientQueryBackupStatusArgs struct {
	Req *QueryBackupStatusRequest `thrift:"req,1" db:"req" json:"req"`
}

func NewAdminClientQueryBackupStatusArgs() *AdminClientQueryBackupStatusArgs {
	return &AdminClientQueryBackupStatusArgs{}
}

var AdminClientQueryBackupStatusArgs_Req_DEFAULT *QueryBackupStatusRequest

func (p *AdminClientQueryBackupStatusArgs) GetReq() *QueryBackupStatusRequest {
	if !p.IsSetReq() {
		return AdminClientQueryBackupStatusArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *AdminClientQueryBackupStatusArgs) IsSetReq() bool {
	return p.Req != nil
}

func (p *AdminClientQueryBackupStatusArgs) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientQueryBackupStatusArgs) ReadField1(iprot thrift.TProtocol) error {
	p.Req = &QueryBackupStatusRequest{}
	if err := p.Req.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err)
	}
	return nil
}

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

func (p *AdminClientQueryBackupStatusArgs) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("req", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:req: ", p), err)
	}
	if err := p.Req.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Req), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:req: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Success
type AdminClientQueryBackupStatusResult struct {
	Success *QueryBackupStatusResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewAdminClientQueryBackupStatusResult() *AdminClientQueryBackupStatusResult {
	return &AdminClientQueryBackupStatusResult{}
}

var AdminClientQueryBackupStatusResult_Success_DEFAULT *QueryBackupStatusResponse

func (p *AdminClientQueryBackupStatusResult) GetSuccess() *QueryBackupStatusResponse {
	if !p.IsSetSuccess() {
		return AdminClientQueryBackupStatusResult_Success_DEFAULT
	}
	return p.Success
}
func (p *AdminClientQueryBackupStatusResult) IsSetSuccess() bool {
	return p.Success != nil
}

func (p *AdminClientQueryBackupStatusResult) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 0:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField0(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientQueryBackupStatusResult) ReadField0(iprot thrift.TProtocol) error {
	p.Success = &QueryBackupStatusResponse{}
	if err := p.Success.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
	}
	return nil
}

func (p *AdminClientQueryBackupStatusResult) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("query_backup_status_result"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		if err := p.writeField0(oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *AdminClientQueryBackupStatusResult) writeField0(oprot thrift.TProtocol) (err error) {
	if p.IsSetSuccess() {
		if err := oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
		}
		if err := p.Success.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - Req
type AdminClientRestoreAppArgs struct {
	Req *ConfigurationRestoreRequest `thrift:"req,1" db:"req" json:"req"`
}

func NewAdminClientRestoreAppArgs() *AdminClientRestoreAppArgs {
	return &AdminClientRestoreAppArgs{}
}

var AdminClientRestoreAppArgs_Req_DEFAULT *ConfigurationRestoreRequest

func (p *AdminClientRestoreAppArgs) GetReq() *ConfigurationRestoreRequest {
	if !p.IsSetReq() {
		return AdminClientRestoreAppArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *AdminClientRestoreAppArgs) IsSetReq() bool {
	return p.Req != nil
}

func (p *AdminClientRestoreAppArgs) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientRestoreAppArgs) ReadField1(iprot thrift.TProtocol) error {
	p.Req = &ConfigurationRestoreRequest{}
	if err := p.Req.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err)
	}
	return nil
}

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

func (p *AdminClientRestoreAppArgs) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("req", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:req: ", p), err)
	}
	if err := p.Req.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Req), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:req: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Success
type AdminClientRestoreAppResult struct {
	Success *ConfigurationCreateAppResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewAdminClientRestoreAppResult() *AdminClientRestoreAppResult {
	return &AdminClientRestoreAppResult{}
}

var AdminClientRestoreAppResult_Success_DEFAULT *ConfigurationCreateAppResponse

func (p *AdminClientRestoreAppResult) GetSuccess() *ConfigurationCreateAppResponse {
	if !p.IsSetSuccess() {
		return AdminClientRestoreAppResult_Success_DEFAULT
	}
	return p.Success
}
func (p *AdminClientRestoreAppResult) IsSetSuccess() bool {
	return p.Success != nil
}

func (p *AdminClientRestoreAppResult) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 0:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField0(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientRestoreAppResult) ReadField0(iprot thrift.TProtocol) error {
	p.Success = &ConfigurationCreateAppResponse{}
	if err := p.Success.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
	}
	return nil
}

func (p *AdminClientRestoreAppResult) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("restore_app_result"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		if err := p.writeField0(oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *AdminClientRestoreAppResult) writeField0(oprot thrift.TProtocol) (err error) {
	if p.IsSetSuccess() {
		if err := oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
		}
		if err := p.Success.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - Req
type AdminClientStartPartitionSplitArgs struct {
	Req *StartPartitionSplitRequest `thrift:"req,1" db:"req" json:"req"`
}

func NewAdminClientStartPartitionSplitArgs() *AdminClientStartPartitionSplitArgs {
	return &AdminClientStartPartitionSplitArgs{}
}

var AdminClientStartPartitionSplitArgs_Req_DEFAULT *StartPartitionSplitRequest

func (p *AdminClientStartPartitionSplitArgs) GetReq() *StartPartitionSplitRequest {
	if !p.IsSetReq() {
		return AdminClientStartPartitionSplitArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *AdminClientStartPartitionSplitArgs) IsSetReq() bool {
	return p.Req != nil
}

func (p *AdminClientStartPartitionSplitArgs) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientStartPartitionSplitArgs) ReadField1(iprot thrift.TProtocol) error {
	p.Req = &StartPartitionSplitRequest{}
	if err := p.Req.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err)
	}
	return nil
}

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

func (p *AdminClientStartPartitionSplitArgs) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("req", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:req: ", p), err)
	}
	if err := p.Req.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Req), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:req: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Success
type AdminClientStartPartitionSplitResult struct {
	Success *StartPartitionSplitResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewAdminClientStartPartitionSplitResult() *AdminClientStartPartitionSplitResult {
	return &AdminClientStartPartitionSplitResult{}
}

var AdminClientStartPartitionSplitResult_Success_DEFAULT *StartPartitionSplitResponse

func (p *AdminClientStartPartitionSplitResult) GetSuccess() *StartPartitionSplitResponse {
	if !p.IsSetSuccess() {
		return AdminClientStartPartitionSplitResult_Success_DEFAULT
	}
	return p.Success
}
func (p *AdminClientStartPartitionSplitResult) IsSetSuccess() bool {
	return p.Success != nil
}

func (p *AdminClientStartPartitionSplitResult) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 0:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField0(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientStartPartitionSplitResult) ReadField0(iprot thrift.TProtocol) error {
	p.Success = &StartPartitionSplitResponse{}
	if err := p.Success.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
	}
	return nil
}

func (p *AdminClientStartPartitionSplitResult) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("start_partition_split_result"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		if err := p.writeField0(oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *AdminClientStartPartitionSplitResult) writeField0(oprot thrift.TProtocol) (err error) {
	if p.IsSetSuccess() {
		if err := oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
		}
		if err := p.Success.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - Req
type AdminClientQuerySplitStatusArgs struct {
	Req *QuerySplitRequest `thrift:"req,1" db:"req" json:"req"`
}

func NewAdminClientQuerySplitStatusArgs() *AdminClientQuerySplitStatusArgs {
	return &AdminClientQuerySplitStatusArgs{}
}

var AdminClientQuerySplitStatusArgs_Req_DEFAULT *QuerySplitRequest

func (p *AdminClientQuerySplitStatusArgs) GetReq() *QuerySplitRequest {
	if !p.IsSetReq() {
		return AdminClientQuerySplitStatusArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *AdminClientQuerySplitStatusArgs) IsSetReq() bool {
	return p.Req != nil
}

func (p *AdminClientQuerySplitStatusArgs) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientQuerySplitStatusArgs) ReadField1(iprot thrift.TProtocol) error {
	p.Req = &QuerySplitRequest{}
	if err := p.Req.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err)
	}
	return nil
}

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

func (p *AdminClientQuerySplitStatusArgs) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("req", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:req: ", p), err)
	}
	if err := p.Req.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Req), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:req: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Success
type AdminClientQuerySplitStatusResult struct {
	Success *QuerySplitResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewAdminClientQuerySplitStatusResult() *AdminClientQuerySplitStatusResult {
	return &AdminClientQuerySplitStatusResult{}
}

var AdminClientQuerySplitStatusResult_Success_DEFAULT *QuerySplitResponse

func (p *AdminClientQuerySplitStatusResult) GetSuccess() *QuerySplitResponse {
	if !p.IsSetSuccess() {
		return AdminClientQuerySplitStatusResult_Success_DEFAULT
	}
	return p.Success
}
func (p *AdminClientQuerySplitStatusResult) IsSetSuccess() bool {
	return p.Success != nil
}

func (p *AdminClientQuerySplitStatusResult) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 0:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField0(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientQuerySplitStatusResult) ReadField0(iprot thrift.TProtocol) error {
	p.Success = &QuerySplitResponse{}
	if err := p.Success.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
	}
	return nil
}

func (p *AdminClientQuerySplitStatusResult) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("query_split_status_result"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		if err := p.writeField0(oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *AdminClientQuerySplitStatusResult) writeField0(oprot thrift.TProtocol) (err error) {
	if p.IsSetSuccess() {
		if err := oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
		}
		if err := p.Success.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - Req
type AdminClientControlPartitionSplitArgs struct {
	Req *ControlSplitRequest `thrift:"req,1" db:"req" json:"req"`
}

func NewAdminClientControlPartitionSplitArgs() *AdminClientControlPartitionSplitArgs {
	return &AdminClientControlPartitionSplitArgs{}
}

var AdminClientControlPartitionSplitArgs_Req_DEFAULT *ControlSplitRequest

func (p *AdminClientControlPartitionSplitArgs) GetReq() *ControlSplitRequest {
	if !p.IsSetReq() {
		return AdminClientControlPartitionSplitArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *AdminClientControlPartitionSplitArgs) IsSetReq() bool {
	return p.Req != nil
}

func (p *AdminClientControlPartitionSplitArgs) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientControlPartitionSplitArgs) ReadField1(iprot thrift.TProtocol) error {
	p.Req = &ControlSplitRequest{}
	if err := p.Req.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err)
	}
	return nil
}

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

func (p *AdminClientControlPartitionSplitArgs) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("req", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:req: ", p), err)
	}
	if err := p.Req.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Req), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:req: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Success
type AdminClientControlPartitionSplitResult struct {
	Success *ControlSplitResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewAdminClientControlPartitionSplitResult() *AdminClientControlPartitionSplitResult {
	return &AdminClientControlPartitionSplitResult{}
}

var AdminClientControlPartitionSplitResult_Success_DEFAULT *ControlSplitResponse

func (p *AdminClientControlPartitionSplitResult) GetSuccess() *ControlSplitResponse {
	if !p.IsSetSuccess() {
		return AdminClientControlPartitionSplitResult_Success_DEFAULT
	}
	return p.Success
}
func (p *AdminClientControlPartitionSplitResult) IsSetSuccess() bool {
	return p.Success != nil
}

func (p *AdminClientControlPartitionSplitResult) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 0:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField0(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientControlPartitionSplitResult) ReadField0(iprot thrift.TProtocol) error {
	p.Success = &ControlSplitResponse{}
	if err := p.Success.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
	}
	return nil
}

func (p *AdminClientControlPartitionSplitResult) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("control_partition_split_result"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		if err := p.writeField0(oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *AdminClientControlPartitionSplitResult) writeField0(oprot thrift.TProtocol) (err error) {
	if p.IsSetSuccess() {
		if err := oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
		}
		if err := p.Success.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - Req
type AdminClientStartBulkLoadArgs struct {
	Req *StartBulkLoadRequest `thrift:"req,1" db:"req" json:"req"`
}

func NewAdminClientStartBulkLoadArgs() *AdminClientStartBulkLoadArgs {
	return &AdminClientStartBulkLoadArgs{}
}

var AdminClientStartBulkLoadArgs_Req_DEFAULT *StartBulkLoadRequest

func (p *AdminClientStartBulkLoadArgs) GetReq() *StartBulkLoadRequest {
	if !p.IsSetReq() {
		return AdminClientStartBulkLoadArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *AdminClientStartBulkLoadArgs) IsSetReq() bool {
	return p.Req != nil
}

func (p *AdminClientStartBulkLoadArgs) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientStartBulkLoadArgs) ReadField1(iprot thrift.TProtocol) error {
	p.Req = &StartBulkLoadRequest{}
	if err := p.Req.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err)
	}
	return nil
}

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

func (p *AdminClientStartBulkLoadArgs) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("req", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:req: ", p), err)
	}
	if err := p.Req.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Req), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:req: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Success
type AdminClientStartBulkLoadResult struct {
	Success *StartBulkLoadResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewAdminClientStartBulkLoadResult() *AdminClientStartBulkLoadResult {
	return &AdminClientStartBulkLoadResult{}
}

var AdminClientStartBulkLoadResult_Success_DEFAULT *StartBulkLoadResponse

func (p *AdminClientStartBulkLoadResult) GetSuccess() *StartBulkLoadResponse {
	if !p.IsSetSuccess() {
		return AdminClientStartBulkLoadResult_Success_DEFAULT
	}
	return p.Success
}
func (p *AdminClientStartBulkLoadResult) IsSetSuccess() bool {
	return p.Success != nil
}

func (p *AdminClientStartBulkLoadResult) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 0:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField0(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientStartBulkLoadResult) ReadField0(iprot thrift.TProtocol) error {
	p.Success = &StartBulkLoadResponse{}
	if err := p.Success.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
	}
	return nil
}

func (p *AdminClientStartBulkLoadResult) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("start_bulk_load_result"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		if err := p.writeField0(oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *AdminClientStartBulkLoadResult) writeField0(oprot thrift.TProtocol) (err error) {
	if p.IsSetSuccess() {
		if err := oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
		}
		if err := p.Success.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - Req
type AdminClientQueryBulkLoadStatusArgs struct {
	Req *QueryBulkLoadRequest `thrift:"req,1" db:"req" json:"req"`
}

func NewAdminClientQueryBulkLoadStatusArgs() *AdminClientQueryBulkLoadStatusArgs {
	return &AdminClientQueryBulkLoadStatusArgs{}
}

var AdminClientQueryBulkLoadStatusArgs_Req_DEFAULT *QueryBulkLoadRequest

func (p *AdminClientQueryBulkLoadStatusArgs) GetReq() *QueryBulkLoadRequest {
	if !p.IsSetReq() {
		return AdminClientQueryBulkLoadStatusArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *AdminClientQueryBulkLoadStatusArgs) IsSetReq() bool {
	return p.Req != nil
}

func (p *AdminClientQueryBulkLoadStatusArgs) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientQueryBulkLoadStatusArgs) ReadField1(iprot thrift.TProtocol) error {
	p.Req = &QueryBulkLoadRequest{}
	if err := p.Req.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err)
	}
	return nil
}

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

func (p *AdminClientQueryBulkLoadStatusArgs) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("req", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:req: ", p), err)
	}
	if err := p.Req.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Req), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:req: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Success
type AdminClientQueryBulkLoadStatusResult struct {
	Success *QueryBulkLoadResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewAdminClientQueryBulkLoadStatusResult() *AdminClientQueryBulkLoadStatusResult {
	return &AdminClientQueryBulkLoadStatusResult{}
}

var AdminClientQueryBulkLoadStatusResult_Success_DEFAULT *QueryBulkLoadResponse

func (p *AdminClientQueryBulkLoadStatusResult) GetSuccess() *QueryBulkLoadResponse {
	if !p.IsSetSuccess() {
		return AdminClientQueryBulkLoadStatusResult_Success_DEFAULT
	}
	return p.Success
}
func (p *AdminClientQueryBulkLoadStatusResult) IsSetSuccess() bool {
	return p.Success != nil
}

func (p *AdminClientQueryBulkLoadStatusResult) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 0:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField0(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientQueryBulkLoadStatusResult) ReadField0(iprot thrift.TProtocol) error {
	p.Success = &QueryBulkLoadResponse{}
	if err := p.Success.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
	}
	return nil
}

func (p *AdminClientQueryBulkLoadStatusResult) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("query_bulk_load_status_result"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		if err := p.writeField0(oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *AdminClientQueryBulkLoadStatusResult) writeField0(oprot thrift.TProtocol) (err error) {
	if p.IsSetSuccess() {
		if err := oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
		}
		if err := p.Success.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - Req
type AdminClientControlBulkLoadArgs struct {
	Req *ControlBulkLoadRequest `thrift:"req,1" db:"req" json:"req"`
}

func NewAdminClientControlBulkLoadArgs() *AdminClientControlBulkLoadArgs {
	return &AdminClientControlBulkLoadArgs{}
}

var AdminClientControlBulkLoadArgs_Req_DEFAULT *ControlBulkLoadRequest

func (p *AdminClientControlBulkLoadArgs) GetReq() *ControlBulkLoadRequest {
	if !p.IsSetReq() {
		return AdminClientControlBulkLoadArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *AdminClientControlBulkLoadArgs) IsSetReq() bool {
	return p.Req != nil
}

func (p *AdminClientControlBulkLoadArgs) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientControlBulkLoadArgs) ReadField1(iprot thrift.TProtocol) error {
	p.Req = &ControlBulkLoadRequest{}
	if err := p.Req.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err)
	}
	return nil
}

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

func (p *AdminClientControlBulkLoadArgs) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("req", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:req: ", p), err)
	}
	if err := p.Req.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Req), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:req: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Success
type AdminClientControlBulkLoadResult struct {
	Success *ControlBulkLoadResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewAdminClientControlBulkLoadResult() *AdminClientControlBulkLoadResult {
	return &AdminClientControlBulkLoadResult{}
}

var AdminClientControlBulkLoadResult_Success_DEFAULT *ControlBulkLoadResponse

func (p *AdminClientControlBulkLoadResult) GetSuccess() *ControlBulkLoadResponse {
	if !p.IsSetSuccess() {
		return AdminClientControlBulkLoadResult_Success_DEFAULT
	}
	return p.Success
}
func (p *AdminClientControlBulkLoadResult) IsSetSuccess() bool {
	return p.Success != nil
}

func (p *AdminClientControlBulkLoadResult) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 0:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField0(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientControlBulkLoadResult) ReadField0(iprot thrift.TProtocol) error {
	p.Success = &ControlBulkLoadResponse{}
	if err := p.Success.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
	}
	return nil
}

func (p *AdminClientControlBulkLoadResult) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("control_bulk_load_result"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		if err := p.writeField0(oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *AdminClientControlBulkLoadResult) writeField0(oprot thrift.TProtocol) (err error) {
	if p.IsSetSuccess() {
		if err := oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
		}
		if err := p.Success.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - Req
type AdminClientClearBulkLoadArgs struct {
	Req *ClearBulkLoadStateRequest `thrift:"req,1" db:"req" json:"req"`
}

func NewAdminClientClearBulkLoadArgs() *AdminClientClearBulkLoadArgs {
	return &AdminClientClearBulkLoadArgs{}
}

var AdminClientClearBulkLoadArgs_Req_DEFAULT *ClearBulkLoadStateRequest

func (p *AdminClientClearBulkLoadArgs) GetReq() *ClearBulkLoadStateRequest {
	if !p.IsSetReq() {
		return AdminClientClearBulkLoadArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *AdminClientClearBulkLoadArgs) IsSetReq() bool {
	return p.Req != nil
}

func (p *AdminClientClearBulkLoadArgs) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientClearBulkLoadArgs) ReadField1(iprot thrift.TProtocol) error {
	p.Req = &ClearBulkLoadStateRequest{}
	if err := p.Req.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err)
	}
	return nil
}

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

func (p *AdminClientClearBulkLoadArgs) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("req", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:req: ", p), err)
	}
	if err := p.Req.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Req), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:req: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Success
type AdminClientClearBulkLoadResult struct {
	Success *ClearBulkLoadStateResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewAdminClientClearBulkLoadResult() *AdminClientClearBulkLoadResult {
	return &AdminClientClearBulkLoadResult{}
}

var AdminClientClearBulkLoadResult_Success_DEFAULT *ClearBulkLoadStateResponse

func (p *AdminClientClearBulkLoadResult) GetSuccess() *ClearBulkLoadStateResponse {
	if !p.IsSetSuccess() {
		return AdminClientClearBulkLoadResult_Success_DEFAULT
	}
	return p.Success
}
func (p *AdminClientClearBulkLoadResult) IsSetSuccess() bool {
	return p.Success != nil
}

func (p *AdminClientClearBulkLoadResult) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 0:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField0(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientClearBulkLoadResult) ReadField0(iprot thrift.TProtocol) error {
	p.Success = &ClearBulkLoadStateResponse{}
	if err := p.Success.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
	}
	return nil
}

func (p *AdminClientClearBulkLoadResult) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("clear_bulk_load_result"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		if err := p.writeField0(oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *AdminClientClearBulkLoadResult) writeField0(oprot thrift.TProtocol) (err error) {
	if p.IsSetSuccess() {
		if err := oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
		}
		if err := p.Success.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - Req
type AdminClientStartManualCompactArgs struct {
	Req *StartAppManualCompactRequest `thrift:"req,1" db:"req" json:"req"`
}

func NewAdminClientStartManualCompactArgs() *AdminClientStartManualCompactArgs {
	return &AdminClientStartManualCompactArgs{}
}

var AdminClientStartManualCompactArgs_Req_DEFAULT *StartAppManualCompactRequest

func (p *AdminClientStartManualCompactArgs) GetReq() *StartAppManualCompactRequest {
	if !p.IsSetReq() {
		return AdminClientStartManualCompactArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *AdminClientStartManualCompactArgs) IsSetReq() bool {
	return p.Req != nil
}

func (p *AdminClientStartManualCompactArgs) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientStartManualCompactArgs) ReadField1(iprot thrift.TProtocol) error {
	p.Req = &StartAppManualCompactRequest{}
	if err := p.Req.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err)
	}
	return nil
}

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

func (p *AdminClientStartManualCompactArgs) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("req", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:req: ", p), err)
	}
	if err := p.Req.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Req), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:req: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Success
type AdminClientStartManualCompactResult struct {
	Success *StartAppManualCompactResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewAdminClientStartManualCompactResult() *AdminClientStartManualCompactResult {
	return &AdminClientStartManualCompactResult{}
}

var AdminClientStartManualCompactResult_Success_DEFAULT *StartAppManualCompactResponse

func (p *AdminClientStartManualCompactResult) GetSuccess() *StartAppManualCompactResponse {
	if !p.IsSetSuccess() {
		return AdminClientStartManualCompactResult_Success_DEFAULT
	}
	return p.Success
}
func (p *AdminClientStartManualCompactResult) IsSetSuccess() bool {
	return p.Success != nil
}

func (p *AdminClientStartManualCompactResult) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 0:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField0(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientStartManualCompactResult) ReadField0(iprot thrift.TProtocol) error {
	p.Success = &StartAppManualCompactResponse{}
	if err := p.Success.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
	}
	return nil
}

func (p *AdminClientStartManualCompactResult) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("start_manual_compact_result"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		if err := p.writeField0(oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *AdminClientStartManualCompactResult) writeField0(oprot thrift.TProtocol) (err error) {
	if p.IsSetSuccess() {
		if err := oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
		}
		if err := p.Success.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - Req
type AdminClientQueryManualCompactArgs struct {
	Req *QueryAppManualCompactRequest `thrift:"req,1" db:"req" json:"req"`
}

func NewAdminClientQueryManualCompactArgs() *AdminClientQueryManualCompactArgs {
	return &AdminClientQueryManualCompactArgs{}
}

var AdminClientQueryManualCompactArgs_Req_DEFAULT *QueryAppManualCompactRequest

func (p *AdminClientQueryManualCompactArgs) GetReq() *QueryAppManualCompactRequest {
	if !p.IsSetReq() {
		return AdminClientQueryManualCompactArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *AdminClientQueryManualCompactArgs) IsSetReq() bool {
	return p.Req != nil
}

func (p *AdminClientQueryManualCompactArgs) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientQueryManualCompactArgs) ReadField1(iprot thrift.TProtocol) error {
	p.Req = &QueryAppManualCompactRequest{}
	if err := p.Req.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err)
	}
	return nil
}

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

func (p *AdminClientQueryManualCompactArgs) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("req", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:req: ", p), err)
	}
	if err := p.Req.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Req), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:req: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Success
type AdminClientQueryManualCompactResult struct {
	Success *QueryAppManualCompactResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewAdminClientQueryManualCompactResult() *AdminClientQueryManualCompactResult {
	return &AdminClientQueryManualCompactResult{}
}

var AdminClientQueryManualCompactResult_Success_DEFAULT *QueryAppManualCompactResponse

func (p *AdminClientQueryManualCompactResult) GetSuccess() *QueryAppManualCompactResponse {
	if !p.IsSetSuccess() {
		return AdminClientQueryManualCompactResult_Success_DEFAULT
	}
	return p.Success
}
func (p *AdminClientQueryManualCompactResult) IsSetSuccess() bool {
	return p.Success != nil
}

func (p *AdminClientQueryManualCompactResult) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 0:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField0(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *AdminClientQueryManualCompactResult) ReadField0(iprot thrift.TProtocol) error {
	p.Success = &QueryAppManualCompactResponse{}
	if err := p.Success.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
	}
	return nil
}

func (p *AdminClientQueryManualCompactResult) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("query_manual_compact_result"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		if err := p.writeField0(oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *AdminClientQueryManualCompactResult) writeField0(oprot thrift.TProtocol) (err error) {
	if p.IsSetSuccess() {
		if err := oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
		}
		if err := p.Success.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
		}
	}
	return err
}

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