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

package protomsg

import (
	fmt "fmt"
	proto "github.com/gogo/protobuf/proto"
	io "io"
	math "math"
	math_bits "math/bits"
)

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

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

type LocalConfig struct {
	ServerId           string `protobuf:"bytes,1,opt,name=server_id,json=serverId,proto3" json:"server_id,omitempty"`
	ServerName         string `protobuf:"bytes,2,opt,name=server_name,json=serverName,proto3" json:"server_name,omitempty"`
	ServerType         int32  `protobuf:"varint,3,opt,name=server_type,json=serverType,proto3" json:"server_type,omitempty"`
	ServerIp           string `protobuf:"bytes,4,opt,name=server_ip,json=serverIp,proto3" json:"server_ip,omitempty"`
	AlarmIp            string `protobuf:"bytes,5,opt,name=alarm_ip,json=alarmIp,proto3" json:"alarm_ip,omitempty"`
	AlarmPort          int32  `protobuf:"varint,6,opt,name=alarm_port,json=alarmPort,proto3" json:"alarm_port,omitempty"`
	WebPicIp           string `protobuf:"bytes,7,opt,name=web_pic_ip,json=webPicIp,proto3" json:"web_pic_ip,omitempty"`
	WebPicPort         int32  `protobuf:"varint,8,opt,name=web_pic_port,json=webPicPort,proto3" json:"web_pic_port,omitempty"`
	EsPicIp            string `protobuf:"bytes,9,opt,name=es_pic_ip,json=esPicIp,proto3" json:"es_pic_ip,omitempty"`
	EsPicPort          int32  `protobuf:"varint,10,opt,name=es_pic_port,json=esPicPort,proto3" json:"es_pic_port,omitempty"`
	CutMaxDuration     int32  `protobuf:"varint,11,opt,name=cut_max_duration,json=cutMaxDuration,proto3" json:"cut_max_duration,omitempty"`
	CutMinDuration     int32  `protobuf:"varint,12,opt,name=cut_min_duration,json=cutMinDuration,proto3" json:"cut_min_duration,omitempty"`
	Reserved           string `protobuf:"bytes,13,opt,name=reserved,proto3" json:"reserved,omitempty"`
	GateWay            string `protobuf:"bytes,14,opt,name=gate_way,json=gateWay,proto3" json:"gate_way,omitempty"`
	NetMask            string `protobuf:"bytes,15,opt,name=net_mask,json=netMask,proto3" json:"net_mask,omitempty"`
	RealMax            int32  `protobuf:"varint,16,opt,name=real_max,json=realMax,proto3" json:"real_max,omitempty"`
	AlarmThresholdType int32  `protobuf:"varint,17,opt,name=alarm_threshold_type,json=alarmThresholdType,proto3" json:"alarm_threshold_type,omitempty"`
	AlarmThreshold     int32  `protobuf:"varint,18,opt,name=alarm_threshold,json=alarmThreshold,proto3" json:"alarm_threshold,omitempty"`
}

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

var xxx_messageInfo_LocalConfig proto.InternalMessageInfo

func (m *LocalConfig) GetServerId() string {
	if m != nil {
		return m.ServerId
	}
	return ""
}

func (m *LocalConfig) GetServerName() string {
	if m != nil {
		return m.ServerName
	}
	return ""
}

func (m *LocalConfig) GetServerType() int32 {
	if m != nil {
		return m.ServerType
	}
	return 0
}

func (m *LocalConfig) GetServerIp() string {
	if m != nil {
		return m.ServerIp
	}
	return ""
}

func (m *LocalConfig) GetAlarmIp() string {
	if m != nil {
		return m.AlarmIp
	}
	return ""
}

func (m *LocalConfig) GetAlarmPort() int32 {
	if m != nil {
		return m.AlarmPort
	}
	return 0
}

func (m *LocalConfig) GetWebPicIp() string {
	if m != nil {
		return m.WebPicIp
	}
	return ""
}

func (m *LocalConfig) GetWebPicPort() int32 {
	if m != nil {
		return m.WebPicPort
	}
	return 0
}

func (m *LocalConfig) GetEsPicIp() string {
	if m != nil {
		return m.EsPicIp
	}
	return ""
}

func (m *LocalConfig) GetEsPicPort() int32 {
	if m != nil {
		return m.EsPicPort
	}
	return 0
}

func (m *LocalConfig) GetCutMaxDuration() int32 {
	if m != nil {
		return m.CutMaxDuration
	}
	return 0
}

func (m *LocalConfig) GetCutMinDuration() int32 {
	if m != nil {
		return m.CutMinDuration
	}
	return 0
}

func (m *LocalConfig) GetReserved() string {
	if m != nil {
		return m.Reserved
	}
	return ""
}

func (m *LocalConfig) GetGateWay() string {
	if m != nil {
		return m.GateWay
	}
	return ""
}

func (m *LocalConfig) GetNetMask() string {
	if m != nil {
		return m.NetMask
	}
	return ""
}

func (m *LocalConfig) GetRealMax() int32 {
	if m != nil {
		return m.RealMax
	}
	return 0
}

func (m *LocalConfig) GetAlarmThresholdType() int32 {
	if m != nil {
		return m.AlarmThresholdType
	}
	return 0
}

func (m *LocalConfig) GetAlarmThreshold() int32 {
	if m != nil {
		return m.AlarmThreshold
	}
	return 0
}

type PollConfig struct {
	ServerId         string `protobuf:"bytes,1,opt,name=server_id,json=serverId,proto3" json:"server_id,omitempty"`
	PollPeriod       int32  `protobuf:"varint,2,opt,name=poll_period,json=pollPeriod,proto3" json:"poll_period,omitempty"`
	Delay            int32  `protobuf:"varint,3,opt,name=delay,proto3" json:"delay,omitempty"`
	Enable           bool   `protobuf:"varint,4,opt,name=enable,proto3" json:"enable,omitempty"`
	PollChannelCount int32  `protobuf:"varint,5,opt,name=pollChannelCount,proto3" json:"pollChannelCount,omitempty"`
}

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

var xxx_messageInfo_PollConfig proto.InternalMessageInfo

func (m *PollConfig) GetServerId() string {
	if m != nil {
		return m.ServerId
	}
	return ""
}

func (m *PollConfig) GetPollPeriod() int32 {
	if m != nil {
		return m.PollPeriod
	}
	return 0
}

func (m *PollConfig) GetDelay() int32 {
	if m != nil {
		return m.Delay
	}
	return 0
}

func (m *PollConfig) GetEnable() bool {
	if m != nil {
		return m.Enable
	}
	return false
}

func (m *PollConfig) GetPollChannelCount() int32 {
	if m != nil {
		return m.PollChannelCount
	}
	return 0
}

type Cluster struct {
	ClusterId   string         `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
	ClusterName string         `protobuf:"bytes,2,opt,name=cluster_name,json=clusterName,proto3" json:"cluster_name,omitempty"`
	Password    string         `protobuf:"bytes,3,opt,name=password,proto3" json:"password,omitempty"`
	VirtualIp   string         `protobuf:"bytes,4,opt,name=virtual_ip,json=virtualIp,proto3" json:"virtual_ip,omitempty"`
	Nodes       []*ClusterNode `protobuf:"bytes,5,rep,name=nodes,proto3" json:"nodes,omitempty"`
}

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

var xxx_messageInfo_Cluster proto.InternalMessageInfo

func (m *Cluster) GetClusterId() string {
	if m != nil {
		return m.ClusterId
	}
	return ""
}

func (m *Cluster) GetClusterName() string {
	if m != nil {
		return m.ClusterName
	}
	return ""
}

func (m *Cluster) GetPassword() string {
	if m != nil {
		return m.Password
	}
	return ""
}

func (m *Cluster) GetVirtualIp() string {
	if m != nil {
		return m.VirtualIp
	}
	return ""
}

func (m *Cluster) GetNodes() []*ClusterNode {
	if m != nil {
		return m.Nodes
	}
	return nil
}

type ClusterNode struct {
	Id         string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	ClusterId  string `protobuf:"bytes,2,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
	ServerId   string `protobuf:"bytes,3,opt,name=server_id,json=serverId,proto3" json:"server_id,omitempty"`
	ServerName string `protobuf:"bytes,4,opt,name=server_name,json=serverName,proto3" json:"server_name,omitempty"`
	NodeId     string `protobuf:"bytes,5,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"`
	NodeIp     string `protobuf:"bytes,6,opt,name=node_ip,json=nodeIp,proto3" json:"node_ip,omitempty"`
	CreateTime string `protobuf:"bytes,7,opt,name=create_time,json=createTime,proto3" json:"create_time,omitempty"`
}

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

var xxx_messageInfo_ClusterNode proto.InternalMessageInfo

func (m *ClusterNode) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *ClusterNode) GetClusterId() string {
	if m != nil {
		return m.ClusterId
	}
	return ""
}

func (m *ClusterNode) GetServerId() string {
	if m != nil {
		return m.ServerId
	}
	return ""
}

func (m *ClusterNode) GetServerName() string {
	if m != nil {
		return m.ServerName
	}
	return ""
}

func (m *ClusterNode) GetNodeId() string {
	if m != nil {
		return m.NodeId
	}
	return ""
}

func (m *ClusterNode) GetNodeIp() string {
	if m != nil {
		return m.NodeIp
	}
	return ""
}

func (m *ClusterNode) GetCreateTime() string {
	if m != nil {
		return m.CreateTime
	}
	return ""
}

type ResourceConfig struct {
	IpType    int32  `protobuf:"varint,1,opt,name=ipType,proto3" json:"ipType,omitempty"`
	ServiceIp string `protobuf:"bytes,2,opt,name=serviceIp,proto3" json:"serviceIp,omitempty"`
	Domain    string `protobuf:"bytes,3,opt,name=domain,proto3" json:"domain,omitempty"`
	FilePort  int32  `protobuf:"varint,4,opt,name=filePort,proto3" json:"filePort,omitempty"`
}

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

var xxx_messageInfo_ResourceConfig proto.InternalMessageInfo

func (m *ResourceConfig) GetIpType() int32 {
	if m != nil {
		return m.IpType
	}
	return 0
}

func (m *ResourceConfig) GetServiceIp() string {
	if m != nil {
		return m.ServiceIp
	}
	return ""
}

func (m *ResourceConfig) GetDomain() string {
	if m != nil {
		return m.Domain
	}
	return ""
}

func (m *ResourceConfig) GetFilePort() int32 {
	if m != nil {
		return m.FilePort
	}
	return 0
}

type Gb28181Config struct {
	Id           string `protobuf:"bytes,1,opt,name=Id,proto3" json:"Id,omitempty"`
	ServerIp     string `protobuf:"bytes,2,opt,name=ServerIp,proto3" json:"ServerIp,omitempty"`
	ServerPort   string `protobuf:"bytes,3,opt,name=ServerPort,proto3" json:"ServerPort,omitempty"`
	PublicId     string `protobuf:"bytes,4,opt,name=PublicId,proto3" json:"PublicId,omitempty"`
	GbServerPort string `protobuf:"bytes,5,opt,name=GbServerPort,proto3" json:"GbServerPort,omitempty"`
	IsAuth       bool   `protobuf:"varint,6,opt,name=IsAuth,proto3" json:"IsAuth,omitempty"`
	Password     string `protobuf:"bytes,7,opt,name=Password,proto3" json:"Password,omitempty"`
	UpdateTime   string `protobuf:"bytes,8,opt,name=UpdateTime,proto3" json:"UpdateTime,omitempty"`
}

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

var xxx_messageInfo_Gb28181Config proto.InternalMessageInfo

func (m *Gb28181Config) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *Gb28181Config) GetServerIp() string {
	if m != nil {
		return m.ServerIp
	}
	return ""
}

func (m *Gb28181Config) GetServerPort() string {
	if m != nil {
		return m.ServerPort
	}
	return ""
}

func (m *Gb28181Config) GetPublicId() string {
	if m != nil {
		return m.PublicId
	}
	return ""
}

func (m *Gb28181Config) GetGbServerPort() string {
	if m != nil {
		return m.GbServerPort
	}
	return ""
}

func (m *Gb28181Config) GetIsAuth() bool {
	if m != nil {
		return m.IsAuth
	}
	return false
}

func (m *Gb28181Config) GetPassword() string {
	if m != nil {
		return m.Password
	}
	return ""
}

func (m *Gb28181Config) GetUpdateTime() string {
	if m != nil {
		return m.UpdateTime
	}
	return ""
}

func init() {
	proto.RegisterType((*LocalConfig)(nil), "protomsg.LocalConfig")
	proto.RegisterType((*PollConfig)(nil), "protomsg.PollConfig")
	proto.RegisterType((*Cluster)(nil), "protomsg.Cluster")
	proto.RegisterType((*ClusterNode)(nil), "protomsg.ClusterNode")
	proto.RegisterType((*ResourceConfig)(nil), "protomsg.ResourceConfig")
	proto.RegisterType((*Gb28181Config)(nil), "protomsg.Gb28181Config")
}

func init() { proto.RegisterFile("sysset.proto", fileDescriptor_5be590c6b2a0d755) }

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

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

func (m *LocalConfig) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.ServerId) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintSysset(dAtA, i, uint64(len(m.ServerId)))
		i += copy(dAtA[i:], m.ServerId)
	}
	if len(m.ServerName) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintSysset(dAtA, i, uint64(len(m.ServerName)))
		i += copy(dAtA[i:], m.ServerName)
	}
	if m.ServerType != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintSysset(dAtA, i, uint64(m.ServerType))
	}
	if len(m.ServerIp) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintSysset(dAtA, i, uint64(len(m.ServerIp)))
		i += copy(dAtA[i:], m.ServerIp)
	}
	if len(m.AlarmIp) > 0 {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintSysset(dAtA, i, uint64(len(m.AlarmIp)))
		i += copy(dAtA[i:], m.AlarmIp)
	}
	if m.AlarmPort != 0 {
		dAtA[i] = 0x30
		i++
		i = encodeVarintSysset(dAtA, i, uint64(m.AlarmPort))
	}
	if len(m.WebPicIp) > 0 {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintSysset(dAtA, i, uint64(len(m.WebPicIp)))
		i += copy(dAtA[i:], m.WebPicIp)
	}
	if m.WebPicPort != 0 {
		dAtA[i] = 0x40
		i++
		i = encodeVarintSysset(dAtA, i, uint64(m.WebPicPort))
	}
	if len(m.EsPicIp) > 0 {
		dAtA[i] = 0x4a
		i++
		i = encodeVarintSysset(dAtA, i, uint64(len(m.EsPicIp)))
		i += copy(dAtA[i:], m.EsPicIp)
	}
	if m.EsPicPort != 0 {
		dAtA[i] = 0x50
		i++
		i = encodeVarintSysset(dAtA, i, uint64(m.EsPicPort))
	}
	if m.CutMaxDuration != 0 {
		dAtA[i] = 0x58
		i++
		i = encodeVarintSysset(dAtA, i, uint64(m.CutMaxDuration))
	}
	if m.CutMinDuration != 0 {
		dAtA[i] = 0x60
		i++
		i = encodeVarintSysset(dAtA, i, uint64(m.CutMinDuration))
	}
	if len(m.Reserved) > 0 {
		dAtA[i] = 0x6a
		i++
		i = encodeVarintSysset(dAtA, i, uint64(len(m.Reserved)))
		i += copy(dAtA[i:], m.Reserved)
	}
	if len(m.GateWay) > 0 {
		dAtA[i] = 0x72
		i++
		i = encodeVarintSysset(dAtA, i, uint64(len(m.GateWay)))
		i += copy(dAtA[i:], m.GateWay)
	}
	if len(m.NetMask) > 0 {
		dAtA[i] = 0x7a
		i++
		i = encodeVarintSysset(dAtA, i, uint64(len(m.NetMask)))
		i += copy(dAtA[i:], m.NetMask)
	}
	if m.RealMax != 0 {
		dAtA[i] = 0x80
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintSysset(dAtA, i, uint64(m.RealMax))
	}
	if m.AlarmThresholdType != 0 {
		dAtA[i] = 0x88
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintSysset(dAtA, i, uint64(m.AlarmThresholdType))
	}
	if m.AlarmThreshold != 0 {
		dAtA[i] = 0x90
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintSysset(dAtA, i, uint64(m.AlarmThreshold))
	}
	return i, nil
}

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

func (m *PollConfig) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.ServerId) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintSysset(dAtA, i, uint64(len(m.ServerId)))
		i += copy(dAtA[i:], m.ServerId)
	}
	if m.PollPeriod != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintSysset(dAtA, i, uint64(m.PollPeriod))
	}
	if m.Delay != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintSysset(dAtA, i, uint64(m.Delay))
	}
	if m.Enable {
		dAtA[i] = 0x20
		i++
		if m.Enable {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.PollChannelCount != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintSysset(dAtA, i, uint64(m.PollChannelCount))
	}
	return i, nil
}

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

func (m *Cluster) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.ClusterId) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintSysset(dAtA, i, uint64(len(m.ClusterId)))
		i += copy(dAtA[i:], m.ClusterId)
	}
	if len(m.ClusterName) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintSysset(dAtA, i, uint64(len(m.ClusterName)))
		i += copy(dAtA[i:], m.ClusterName)
	}
	if len(m.Password) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintSysset(dAtA, i, uint64(len(m.Password)))
		i += copy(dAtA[i:], m.Password)
	}
	if len(m.VirtualIp) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintSysset(dAtA, i, uint64(len(m.VirtualIp)))
		i += copy(dAtA[i:], m.VirtualIp)
	}
	if len(m.Nodes) > 0 {
		for _, msg := range m.Nodes {
			dAtA[i] = 0x2a
			i++
			i = encodeVarintSysset(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

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

func (m *ClusterNode) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Id) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintSysset(dAtA, i, uint64(len(m.Id)))
		i += copy(dAtA[i:], m.Id)
	}
	if len(m.ClusterId) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintSysset(dAtA, i, uint64(len(m.ClusterId)))
		i += copy(dAtA[i:], m.ClusterId)
	}
	if len(m.ServerId) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintSysset(dAtA, i, uint64(len(m.ServerId)))
		i += copy(dAtA[i:], m.ServerId)
	}
	if len(m.ServerName) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintSysset(dAtA, i, uint64(len(m.ServerName)))
		i += copy(dAtA[i:], m.ServerName)
	}
	if len(m.NodeId) > 0 {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintSysset(dAtA, i, uint64(len(m.NodeId)))
		i += copy(dAtA[i:], m.NodeId)
	}
	if len(m.NodeIp) > 0 {
		dAtA[i] = 0x32
		i++
		i = encodeVarintSysset(dAtA, i, uint64(len(m.NodeIp)))
		i += copy(dAtA[i:], m.NodeIp)
	}
	if len(m.CreateTime) > 0 {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintSysset(dAtA, i, uint64(len(m.CreateTime)))
		i += copy(dAtA[i:], m.CreateTime)
	}
	return i, nil
}

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

func (m *ResourceConfig) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.IpType != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintSysset(dAtA, i, uint64(m.IpType))
	}
	if len(m.ServiceIp) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintSysset(dAtA, i, uint64(len(m.ServiceIp)))
		i += copy(dAtA[i:], m.ServiceIp)
	}
	if len(m.Domain) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintSysset(dAtA, i, uint64(len(m.Domain)))
		i += copy(dAtA[i:], m.Domain)
	}
	if m.FilePort != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintSysset(dAtA, i, uint64(m.FilePort))
	}
	return i, nil
}

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

func (m *Gb28181Config) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Id) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintSysset(dAtA, i, uint64(len(m.Id)))
		i += copy(dAtA[i:], m.Id)
	}
	if len(m.ServerIp) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintSysset(dAtA, i, uint64(len(m.ServerIp)))
		i += copy(dAtA[i:], m.ServerIp)
	}
	if len(m.ServerPort) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintSysset(dAtA, i, uint64(len(m.ServerPort)))
		i += copy(dAtA[i:], m.ServerPort)
	}
	if len(m.PublicId) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintSysset(dAtA, i, uint64(len(m.PublicId)))
		i += copy(dAtA[i:], m.PublicId)
	}
	if len(m.GbServerPort) > 0 {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintSysset(dAtA, i, uint64(len(m.GbServerPort)))
		i += copy(dAtA[i:], m.GbServerPort)
	}
	if m.IsAuth {
		dAtA[i] = 0x30
		i++
		if m.IsAuth {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if len(m.Password) > 0 {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintSysset(dAtA, i, uint64(len(m.Password)))
		i += copy(dAtA[i:], m.Password)
	}
	if len(m.UpdateTime) > 0 {
		dAtA[i] = 0x42
		i++
		i = encodeVarintSysset(dAtA, i, uint64(len(m.UpdateTime)))
		i += copy(dAtA[i:], m.UpdateTime)
	}
	return i, nil
}

func encodeVarintSysset(dAtA []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return offset + 1
}
func (m *LocalConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ServerId)
	if l > 0 {
		n += 1 + l + sovSysset(uint64(l))
	}
	l = len(m.ServerName)
	if l > 0 {
		n += 1 + l + sovSysset(uint64(l))
	}
	if m.ServerType != 0 {
		n += 1 + sovSysset(uint64(m.ServerType))
	}
	l = len(m.ServerIp)
	if l > 0 {
		n += 1 + l + sovSysset(uint64(l))
	}
	l = len(m.AlarmIp)
	if l > 0 {
		n += 1 + l + sovSysset(uint64(l))
	}
	if m.AlarmPort != 0 {
		n += 1 + sovSysset(uint64(m.AlarmPort))
	}
	l = len(m.WebPicIp)
	if l > 0 {
		n += 1 + l + sovSysset(uint64(l))
	}
	if m.WebPicPort != 0 {
		n += 1 + sovSysset(uint64(m.WebPicPort))
	}
	l = len(m.EsPicIp)
	if l > 0 {
		n += 1 + l + sovSysset(uint64(l))
	}
	if m.EsPicPort != 0 {
		n += 1 + sovSysset(uint64(m.EsPicPort))
	}
	if m.CutMaxDuration != 0 {
		n += 1 + sovSysset(uint64(m.CutMaxDuration))
	}
	if m.CutMinDuration != 0 {
		n += 1 + sovSysset(uint64(m.CutMinDuration))
	}
	l = len(m.Reserved)
	if l > 0 {
		n += 1 + l + sovSysset(uint64(l))
	}
	l = len(m.GateWay)
	if l > 0 {
		n += 1 + l + sovSysset(uint64(l))
	}
	l = len(m.NetMask)
	if l > 0 {
		n += 1 + l + sovSysset(uint64(l))
	}
	if m.RealMax != 0 {
		n += 2 + sovSysset(uint64(m.RealMax))
	}
	if m.AlarmThresholdType != 0 {
		n += 2 + sovSysset(uint64(m.AlarmThresholdType))
	}
	if m.AlarmThreshold != 0 {
		n += 2 + sovSysset(uint64(m.AlarmThreshold))
	}
	return n
}

func (m *PollConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ServerId)
	if l > 0 {
		n += 1 + l + sovSysset(uint64(l))
	}
	if m.PollPeriod != 0 {
		n += 1 + sovSysset(uint64(m.PollPeriod))
	}
	if m.Delay != 0 {
		n += 1 + sovSysset(uint64(m.Delay))
	}
	if m.Enable {
		n += 2
	}
	if m.PollChannelCount != 0 {
		n += 1 + sovSysset(uint64(m.PollChannelCount))
	}
	return n
}

func (m *Cluster) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ClusterId)
	if l > 0 {
		n += 1 + l + sovSysset(uint64(l))
	}
	l = len(m.ClusterName)
	if l > 0 {
		n += 1 + l + sovSysset(uint64(l))
	}
	l = len(m.Password)
	if l > 0 {
		n += 1 + l + sovSysset(uint64(l))
	}
	l = len(m.VirtualIp)
	if l > 0 {
		n += 1 + l + sovSysset(uint64(l))
	}
	if len(m.Nodes) > 0 {
		for _, e := range m.Nodes {
			l = e.Size()
			n += 1 + l + sovSysset(uint64(l))
		}
	}
	return n
}

func (m *ClusterNode) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovSysset(uint64(l))
	}
	l = len(m.ClusterId)
	if l > 0 {
		n += 1 + l + sovSysset(uint64(l))
	}
	l = len(m.ServerId)
	if l > 0 {
		n += 1 + l + sovSysset(uint64(l))
	}
	l = len(m.ServerName)
	if l > 0 {
		n += 1 + l + sovSysset(uint64(l))
	}
	l = len(m.NodeId)
	if l > 0 {
		n += 1 + l + sovSysset(uint64(l))
	}
	l = len(m.NodeIp)
	if l > 0 {
		n += 1 + l + sovSysset(uint64(l))
	}
	l = len(m.CreateTime)
	if l > 0 {
		n += 1 + l + sovSysset(uint64(l))
	}
	return n
}

func (m *ResourceConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.IpType != 0 {
		n += 1 + sovSysset(uint64(m.IpType))
	}
	l = len(m.ServiceIp)
	if l > 0 {
		n += 1 + l + sovSysset(uint64(l))
	}
	l = len(m.Domain)
	if l > 0 {
		n += 1 + l + sovSysset(uint64(l))
	}
	if m.FilePort != 0 {
		n += 1 + sovSysset(uint64(m.FilePort))
	}
	return n
}

func (m *Gb28181Config) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovSysset(uint64(l))
	}
	l = len(m.ServerIp)
	if l > 0 {
		n += 1 + l + sovSysset(uint64(l))
	}
	l = len(m.ServerPort)
	if l > 0 {
		n += 1 + l + sovSysset(uint64(l))
	}
	l = len(m.PublicId)
	if l > 0 {
		n += 1 + l + sovSysset(uint64(l))
	}
	l = len(m.GbServerPort)
	if l > 0 {
		n += 1 + l + sovSysset(uint64(l))
	}
	if m.IsAuth {
		n += 2
	}
	l = len(m.Password)
	if l > 0 {
		n += 1 + l + sovSysset(uint64(l))
	}
	l = len(m.UpdateTime)
	if l > 0 {
		n += 1 + l + sovSysset(uint64(l))
	}
	return n
}

func sovSysset(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozSysset(x uint64) (n int) {
	return sovSysset(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *LocalConfig) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowSysset
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: LocalConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LocalConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServerId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSysset
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthSysset
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSysset
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ServerId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServerName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSysset
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthSysset
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSysset
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ServerName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServerType", wireType)
			}
			m.ServerType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSysset
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ServerType |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServerIp", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSysset
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthSysset
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSysset
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ServerIp = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AlarmIp", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSysset
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthSysset
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSysset
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AlarmIp = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AlarmPort", wireType)
			}
			m.AlarmPort = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSysset
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AlarmPort |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WebPicIp", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSysset
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthSysset
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSysset
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.WebPicIp = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field WebPicPort", wireType)
			}
			m.WebPicPort = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSysset
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.WebPicPort |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EsPicIp", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSysset
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthSysset
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSysset
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EsPicIp = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EsPicPort", wireType)
			}
			m.EsPicPort = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSysset
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EsPicPort |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CutMaxDuration", wireType)
			}
			m.CutMaxDuration = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSysset
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CutMaxDuration |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CutMinDuration", wireType)
			}
			m.CutMinDuration = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSysset
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CutMinDuration |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reserved", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSysset
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthSysset
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSysset
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Reserved = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GateWay", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSysset
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthSysset
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSysset
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.GateWay = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NetMask", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSysset
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthSysset
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSysset
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NetMask = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 16:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RealMax", wireType)
			}
			m.RealMax = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSysset
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RealMax |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 17:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AlarmThresholdType", wireType)
			}
			m.AlarmThresholdType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSysset
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AlarmThresholdType |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 18:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AlarmThreshold", wireType)
			}
			m.AlarmThreshold = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSysset
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AlarmThreshold |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipSysset(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthSysset
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthSysset
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Gb28181Config) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowSysset
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Gb28181Config: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Gb28181Config: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSysset
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthSysset
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSysset
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServerIp", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSysset
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthSysset
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSysset
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ServerIp = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServerPort", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSysset
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthSysset
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSysset
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ServerPort = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PublicId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSysset
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthSysset
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSysset
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PublicId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GbServerPort", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSysset
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthSysset
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSysset
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.GbServerPort = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsAuth", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSysset
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsAuth = bool(v != 0)
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Password", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSysset
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthSysset
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSysset
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Password = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpdateTime", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSysset
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthSysset
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSysset
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UpdateTime = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSysset(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthSysset
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthSysset
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

var (
	ErrInvalidLengthSysset = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowSysset   = fmt.Errorf("proto: integer overflow")
)