update

zhangmeng

2019-11-21 7af037c469a7f7ae37ccba9057ca2eacd6e79848

 sdk.pb.go

@@ -1038,15 +1038,346 @@
   return nil
}

// cloud
type PlateIDCloud struct {
   License      string `protobuf:"bytes,1,opt,name=license,proto3" json:"license,omitempty"`
   RcLocation   *Rect  `protobuf:"bytes,2,opt,name=rcLocation,proto3" json:"rcLocation,omitempty"`
   NConfidence  int32  `protobuf:"varint,3,opt,name=nConfidence,proto3" json:"nConfidence,omitempty"`
   NType        int32  `protobuf:"varint,4,opt,name=nType,proto3" json:"nType,omitempty"`
   NDirection   int32  `protobuf:"varint,5,opt,name=nDirection,proto3" json:"nDirection,omitempty"`
   NCarColor    int32  `protobuf:"varint,6,opt,name=nCarColor,proto3" json:"nCarColor,omitempty"`
   NCarColor1   int32  `protobuf:"varint,7,opt,name=nCarColor1,proto3" json:"nCarColor1,omitempty"`
   NCarBright   int32  `protobuf:"varint,8,opt,name=nCarBright,proto3" json:"nCarBright,omitempty"`
   FrameNo      int32  `protobuf:"varint,9,opt,name=frameNo,proto3" json:"frameNo,omitempty"`
   FaceWidth    int32  `protobuf:"varint,10,opt,name=faceWidth,proto3" json:"faceWidth,omitempty"`
   FaceHeight   int32  `protobuf:"varint,11,opt,name=faceHeight,proto3" json:"faceHeight,omitempty"`
   GrayFaceFlag int32  `protobuf:"varint,12,opt,name=grayFaceFlag,proto3" json:"grayFaceFlag,omitempty"`
   CharNum      int32  `protobuf:"varint,13,opt,name=charNum,proto3" json:"charNum,omitempty"`
}

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

var xxx_messageInfo_PlateIDCloud proto.InternalMessageInfo

func (m *PlateIDCloud) GetLicense() string {
   if m != nil {
      return m.License
   }
   return ""
}

func (m *PlateIDCloud) GetRcLocation() *Rect {
   if m != nil {
      return m.RcLocation
   }
   return nil
}

func (m *PlateIDCloud) GetNConfidence() int32 {
   if m != nil {
      return m.NConfidence
   }
   return 0
}

func (m *PlateIDCloud) GetNType() int32 {
   if m != nil {
      return m.NType
   }
   return 0
}

func (m *PlateIDCloud) GetNDirection() int32 {
   if m != nil {
      return m.NDirection
   }
   return 0
}

func (m *PlateIDCloud) GetNCarColor() int32 {
   if m != nil {
      return m.NCarColor
   }
   return 0
}

func (m *PlateIDCloud) GetNCarColor1() int32 {
   if m != nil {
      return m.NCarColor1
   }
   return 0
}

func (m *PlateIDCloud) GetNCarBright() int32 {
   if m != nil {
      return m.NCarBright
   }
   return 0
}

func (m *PlateIDCloud) GetFrameNo() int32 {
   if m != nil {
      return m.FrameNo
   }
   return 0
}

func (m *PlateIDCloud) GetFaceWidth() int32 {
   if m != nil {
      return m.FaceWidth
   }
   return 0
}

func (m *PlateIDCloud) GetFaceHeight() int32 {
   if m != nil {
      return m.FaceHeight
   }
   return 0
}

func (m *PlateIDCloud) GetGrayFaceFlag() int32 {
   if m != nil {
      return m.GrayFaceFlag
   }
   return 0
}

func (m *PlateIDCloud) GetCharNum() int32 {
   if m != nil {
      return m.CharNum
   }
   return 0
}

type PlateIDVehicle struct {
   NPlateFlag       int32   `protobuf:"varint,1,opt,name=nPlateFlag,proto3" json:"nPlateFlag,omitempty"`
   NColor           int32   `protobuf:"varint,2,opt,name=nColor,proto3" json:"nColor,omitempty"`
   NType            int32   `protobuf:"varint,3,opt,name=nType,proto3" json:"nType,omitempty"`
   License          string  `protobuf:"bytes,4,opt,name=license,proto3" json:"license,omitempty"`
   NConfidence      int32   `protobuf:"varint,5,opt,name=nConfidence,proto3" json:"nConfidence,omitempty"`
   NCharNum         int32   `protobuf:"varint,6,opt,name=nCharNum,proto3" json:"nCharNum,omitempty"`
   NCharConfidence  []int32 `protobuf:"varint,7,rep,packed,name=nCharConfidence,proto3" json:"nCharConfidence,omitempty"`
   RcLocation       *Rect   `protobuf:"bytes,8,opt,name=rcLocation,proto3" json:"rcLocation,omitempty"`
   RcCarLocation    *Rect   `protobuf:"bytes,9,opt,name=rcCarLocation,proto3" json:"rcCarLocation,omitempty"`
   VehicleType      string  `protobuf:"bytes,10,opt,name=vehicleType,proto3" json:"vehicleType,omitempty"`
   VehicleBrand     string  `protobuf:"bytes,11,opt,name=vehicleBrand,proto3" json:"vehicleBrand,omitempty"`
   VehicleSub       string  `protobuf:"bytes,12,opt,name=vehicleSub,proto3" json:"vehicleSub,omitempty"`
   VehicleType1     string  `protobuf:"bytes,13,opt,name=vehicleType1,proto3" json:"vehicleType1,omitempty"`
   FvdConf          float32 `protobuf:"fixed32,14,opt,name=fvdConf,proto3" json:"fvdConf,omitempty"`
   FConfdence       float32 `protobuf:"fixed32,15,opt,name=fConfdence,proto3" json:"fConfdence,omitempty"`
   NVehicleSubModel int32   `protobuf:"varint,16,opt,name=nVehicleSubModel,proto3" json:"nVehicleSubModel,omitempty"`
   NVehicleBright   int32   `protobuf:"varint,17,opt,name=nVehicleBright,proto3" json:"nVehicleBright,omitempty"`
   NVehicleColor1   int32   `protobuf:"varint,18,opt,name=nVehicleColor1,proto3" json:"nVehicleColor1,omitempty"`
   NVehicleColor2   int32   `protobuf:"varint,19,opt,name=nVehicleColor2,proto3" json:"nVehicleColor2,omitempty"`
}

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

var xxx_messageInfo_PlateIDVehicle proto.InternalMessageInfo

func (m *PlateIDVehicle) GetNPlateFlag() int32 {
   if m != nil {
      return m.NPlateFlag
   }
   return 0
}

func (m *PlateIDVehicle) GetNColor() int32 {
   if m != nil {
      return m.NColor
   }
   return 0
}

func (m *PlateIDVehicle) GetNType() int32 {
   if m != nil {
      return m.NType
   }
   return 0
}

func (m *PlateIDVehicle) GetLicense() string {
   if m != nil {
      return m.License
   }
   return ""
}

func (m *PlateIDVehicle) GetNConfidence() int32 {
   if m != nil {
      return m.NConfidence
   }
   return 0
}

func (m *PlateIDVehicle) GetNCharNum() int32 {
   if m != nil {
      return m.NCharNum
   }
   return 0
}

func (m *PlateIDVehicle) GetNCharConfidence() []int32 {
   if m != nil {
      return m.NCharConfidence
   }
   return nil
}

func (m *PlateIDVehicle) GetRcLocation() *Rect {
   if m != nil {
      return m.RcLocation
   }
   return nil
}

func (m *PlateIDVehicle) GetRcCarLocation() *Rect {
   if m != nil {
      return m.RcCarLocation
   }
   return nil
}

func (m *PlateIDVehicle) GetVehicleType() string {
   if m != nil {
      return m.VehicleType
   }
   return ""
}

func (m *PlateIDVehicle) GetVehicleBrand() string {
   if m != nil {
      return m.VehicleBrand
   }
   return ""
}

func (m *PlateIDVehicle) GetVehicleSub() string {
   if m != nil {
      return m.VehicleSub
   }
   return ""
}

func (m *PlateIDVehicle) GetVehicleType1() string {
   if m != nil {
      return m.VehicleType1
   }
   return ""
}

func (m *PlateIDVehicle) GetFvdConf() float32 {
   if m != nil {
      return m.FvdConf
   }
   return 0
}

func (m *PlateIDVehicle) GetFConfdence() float32 {
   if m != nil {
      return m.FConfdence
   }
   return 0
}

func (m *PlateIDVehicle) GetNVehicleSubModel() int32 {
   if m != nil {
      return m.NVehicleSubModel
   }
   return 0
}

func (m *PlateIDVehicle) GetNVehicleBright() int32 {
   if m != nil {
      return m.NVehicleBright
   }
   return 0
}

func (m *PlateIDVehicle) GetNVehicleColor1() int32 {
   if m != nil {
      return m.NVehicleColor1
   }
   return 0
}

func (m *PlateIDVehicle) GetNVehicleColor2() int32 {
   if m != nil {
      return m.NVehicleColor2
   }
   return 0
}

type PlateIDResult struct {
   Result []*PlateID `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"`
   // repeated PlateID result = 1;
   // repeated PlateIDCloud result = 1;
   Result []*PlateIDVehicle `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"`
}

func (m *PlateIDResult) Reset()         { *m = PlateIDResult{} }
func (m *PlateIDResult) String() string { return proto.CompactTextString(m) }
func (*PlateIDResult) ProtoMessage()    {}
func (*PlateIDResult) Descriptor() ([]byte, []int) {
   return fileDescriptor_70decb0fb6f436df, []int{13}
   return fileDescriptor_70decb0fb6f436df, []int{15}
}
func (m *PlateIDResult) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -1075,424 +1406,7 @@

var xxx_messageInfo_PlateIDResult proto.InternalMessageInfo

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

// cloud
type PlateCloudID struct {
   License      string `protobuf:"bytes,1,opt,name=license,proto3" json:"license,omitempty"`
   RcLocation   *Rect  `protobuf:"bytes,2,opt,name=rcLocation,proto3" json:"rcLocation,omitempty"`
   NConfidence  int32  `protobuf:"varint,3,opt,name=nConfidence,proto3" json:"nConfidence,omitempty"`
   NType        int32  `protobuf:"varint,4,opt,name=nType,proto3" json:"nType,omitempty"`
   NDirection   int32  `protobuf:"varint,5,opt,name=nDirection,proto3" json:"nDirection,omitempty"`
   NCarColor    int32  `protobuf:"varint,6,opt,name=nCarColor,proto3" json:"nCarColor,omitempty"`
   NCarColor1   int32  `protobuf:"varint,7,opt,name=nCarColor1,proto3" json:"nCarColor1,omitempty"`
   NCarBright   int32  `protobuf:"varint,8,opt,name=nCarBright,proto3" json:"nCarBright,omitempty"`
   FrameNo      int32  `protobuf:"varint,9,opt,name=frameNo,proto3" json:"frameNo,omitempty"`
   FaceWidth    int32  `protobuf:"varint,10,opt,name=faceWidth,proto3" json:"faceWidth,omitempty"`
   FaceHeight   int32  `protobuf:"varint,11,opt,name=faceHeight,proto3" json:"faceHeight,omitempty"`
   GrayFaceFlag int32  `protobuf:"varint,12,opt,name=grayFaceFlag,proto3" json:"grayFaceFlag,omitempty"`
   CharNum      int32  `protobuf:"varint,13,opt,name=charNum,proto3" json:"charNum,omitempty"`
}

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

var xxx_messageInfo_PlateCloudID proto.InternalMessageInfo

func (m *PlateCloudID) GetLicense() string {
   if m != nil {
      return m.License
   }
   return ""
}

func (m *PlateCloudID) GetRcLocation() *Rect {
   if m != nil {
      return m.RcLocation
   }
   return nil
}

func (m *PlateCloudID) GetNConfidence() int32 {
   if m != nil {
      return m.NConfidence
   }
   return 0
}

func (m *PlateCloudID) GetNType() int32 {
   if m != nil {
      return m.NType
   }
   return 0
}

func (m *PlateCloudID) GetNDirection() int32 {
   if m != nil {
      return m.NDirection
   }
   return 0
}

func (m *PlateCloudID) GetNCarColor() int32 {
   if m != nil {
      return m.NCarColor
   }
   return 0
}

func (m *PlateCloudID) GetNCarColor1() int32 {
   if m != nil {
      return m.NCarColor1
   }
   return 0
}

func (m *PlateCloudID) GetNCarBright() int32 {
   if m != nil {
      return m.NCarBright
   }
   return 0
}

func (m *PlateCloudID) GetFrameNo() int32 {
   if m != nil {
      return m.FrameNo
   }
   return 0
}

func (m *PlateCloudID) GetFaceWidth() int32 {
   if m != nil {
      return m.FaceWidth
   }
   return 0
}

func (m *PlateCloudID) GetFaceHeight() int32 {
   if m != nil {
      return m.FaceHeight
   }
   return 0
}

func (m *PlateCloudID) GetGrayFaceFlag() int32 {
   if m != nil {
      return m.GrayFaceFlag
   }
   return 0
}

func (m *PlateCloudID) GetCharNum() int32 {
   if m != nil {
      return m.CharNum
   }
   return 0
}

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

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

var xxx_messageInfo_PlateCloudIDResult proto.InternalMessageInfo

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

type PlateVehicleID struct {
   NPlateFlag       int32   `protobuf:"varint,1,opt,name=nPlateFlag,proto3" json:"nPlateFlag,omitempty"`
   NColor           int32   `protobuf:"varint,2,opt,name=nColor,proto3" json:"nColor,omitempty"`
   NType            int32   `protobuf:"varint,3,opt,name=nType,proto3" json:"nType,omitempty"`
   License          string  `protobuf:"bytes,4,opt,name=license,proto3" json:"license,omitempty"`
   NConfidence      int32   `protobuf:"varint,5,opt,name=nConfidence,proto3" json:"nConfidence,omitempty"`
   NCharNum         int32   `protobuf:"varint,6,opt,name=nCharNum,proto3" json:"nCharNum,omitempty"`
   NCharConfidence  []int32 `protobuf:"varint,7,rep,packed,name=nCharConfidence,proto3" json:"nCharConfidence,omitempty"`
   RcLocation       *Rect   `protobuf:"bytes,8,opt,name=rcLocation,proto3" json:"rcLocation,omitempty"`
   RcCarLocation    *Rect   `protobuf:"bytes,9,opt,name=rcCarLocation,proto3" json:"rcCarLocation,omitempty"`
   VehicleType      string  `protobuf:"bytes,10,opt,name=vehicleType,proto3" json:"vehicleType,omitempty"`
   VehicleBrand     string  `protobuf:"bytes,11,opt,name=vehicleBrand,proto3" json:"vehicleBrand,omitempty"`
   VehicleSub       string  `protobuf:"bytes,12,opt,name=vehicleSub,proto3" json:"vehicleSub,omitempty"`
   VehicleType1     string  `protobuf:"bytes,13,opt,name=vehicleType1,proto3" json:"vehicleType1,omitempty"`
   FvdConf          float32 `protobuf:"fixed32,14,opt,name=fvdConf,proto3" json:"fvdConf,omitempty"`
   FConfdence       float32 `protobuf:"fixed32,15,opt,name=fConfdence,proto3" json:"fConfdence,omitempty"`
   NVehicleSubModel int32   `protobuf:"varint,16,opt,name=nVehicleSubModel,proto3" json:"nVehicleSubModel,omitempty"`
   NVehicleBright   int32   `protobuf:"varint,17,opt,name=nVehicleBright,proto3" json:"nVehicleBright,omitempty"`
   NVehicleColor1   int32   `protobuf:"varint,18,opt,name=nVehicleColor1,proto3" json:"nVehicleColor1,omitempty"`
   NVehicleColor2   int32   `protobuf:"varint,19,opt,name=nVehicleColor2,proto3" json:"nVehicleColor2,omitempty"`
}

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

var xxx_messageInfo_PlateVehicleID proto.InternalMessageInfo

func (m *PlateVehicleID) GetNPlateFlag() int32 {
   if m != nil {
      return m.NPlateFlag
   }
   return 0
}

func (m *PlateVehicleID) GetNColor() int32 {
   if m != nil {
      return m.NColor
   }
   return 0
}

func (m *PlateVehicleID) GetNType() int32 {
   if m != nil {
      return m.NType
   }
   return 0
}

func (m *PlateVehicleID) GetLicense() string {
   if m != nil {
      return m.License
   }
   return ""
}

func (m *PlateVehicleID) GetNConfidence() int32 {
   if m != nil {
      return m.NConfidence
   }
   return 0
}

func (m *PlateVehicleID) GetNCharNum() int32 {
   if m != nil {
      return m.NCharNum
   }
   return 0
}

func (m *PlateVehicleID) GetNCharConfidence() []int32 {
   if m != nil {
      return m.NCharConfidence
   }
   return nil
}

func (m *PlateVehicleID) GetRcLocation() *Rect {
   if m != nil {
      return m.RcLocation
   }
   return nil
}

func (m *PlateVehicleID) GetRcCarLocation() *Rect {
   if m != nil {
      return m.RcCarLocation
   }
   return nil
}

func (m *PlateVehicleID) GetVehicleType() string {
   if m != nil {
      return m.VehicleType
   }
   return ""
}

func (m *PlateVehicleID) GetVehicleBrand() string {
   if m != nil {
      return m.VehicleBrand
   }
   return ""
}

func (m *PlateVehicleID) GetVehicleSub() string {
   if m != nil {
      return m.VehicleSub
   }
   return ""
}

func (m *PlateVehicleID) GetVehicleType1() string {
   if m != nil {
      return m.VehicleType1
   }
   return ""
}

func (m *PlateVehicleID) GetFvdConf() float32 {
   if m != nil {
      return m.FvdConf
   }
   return 0
}

func (m *PlateVehicleID) GetFConfdence() float32 {
   if m != nil {
      return m.FConfdence
   }
   return 0
}

func (m *PlateVehicleID) GetNVehicleSubModel() int32 {
   if m != nil {
      return m.NVehicleSubModel
   }
   return 0
}

func (m *PlateVehicleID) GetNVehicleBright() int32 {
   if m != nil {
      return m.NVehicleBright
   }
   return 0
}

func (m *PlateVehicleID) GetNVehicleColor1() int32 {
   if m != nil {
      return m.NVehicleColor1
   }
   return 0
}

func (m *PlateVehicleID) GetNVehicleColor2() int32 {
   if m != nil {
      return m.NVehicleColor2
   }
   return 0
}

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

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

var xxx_messageInfo_PlateVehicleIDResult proto.InternalMessageInfo

func (m *PlateVehicleIDResult) GetResult() []*PlateVehicleID {
func (m *PlateIDResult) GetResult() []*PlateIDVehicle {
   if m != nil {
      return m.Result
   }
@@ -1513,101 +1427,97 @@
   proto.RegisterType((*ParamYoloObj)(nil), "protomsg.ParamYoloObj")
   proto.RegisterType((*SoInfo)(nil), "protomsg.SoInfo")
   proto.RegisterType((*PlateID)(nil), "protomsg.PlateID")
   proto.RegisterType((*PlateIDCloud)(nil), "protomsg.PlateIDCloud")
   proto.RegisterType((*PlateIDVehicle)(nil), "protomsg.PlateIDVehicle")
   proto.RegisterType((*PlateIDResult)(nil), "protomsg.PlateIDResult")
   proto.RegisterType((*PlateCloudID)(nil), "protomsg.PlateCloudID")
   proto.RegisterType((*PlateCloudIDResult)(nil), "protomsg.PlateCloudIDResult")
   proto.RegisterType((*PlateVehicleID)(nil), "protomsg.PlateVehicleID")
   proto.RegisterType((*PlateVehicleIDResult)(nil), "protomsg.PlateVehicleIDResult")
}

func init() { proto.RegisterFile("sdk.proto", fileDescriptor_70decb0fb6f436df) }

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

func (m *Image) Marshal() (dAtA []byte, err error) {
@@ -2323,7 +2233,7 @@
   return i, nil
}

func (m *PlateIDResult) Marshal() (dAtA []byte, err error) {
func (m *PlateIDCloud) Marshal() (dAtA []byte, err error) {
   size := m.Size()
   dAtA = make([]byte, size)
   n, err := m.MarshalTo(dAtA)
@@ -2333,37 +2243,7 @@
   return dAtA[:n], nil
}

func (m *PlateIDResult) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if len(m.Result) > 0 {
      for _, msg := range m.Result {
         dAtA[i] = 0xa
         i++
         i = encodeVarintSdk(dAtA, i, uint64(msg.Size()))
         n, err := msg.MarshalTo(dAtA[i:])
         if err != nil {
            return 0, err
         }
         i += n
      }
   }
   return i, nil
}

func (m *PlateCloudID) 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 *PlateCloudID) MarshalTo(dAtA []byte) (int, error) {
func (m *PlateIDCloud) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
@@ -2442,7 +2322,7 @@
   return i, nil
}

func (m *PlateCloudIDResult) Marshal() (dAtA []byte, err error) {
func (m *PlateIDVehicle) Marshal() (dAtA []byte, err error) {
   size := m.Size()
   dAtA = make([]byte, size)
   n, err := m.MarshalTo(dAtA)
@@ -2452,37 +2332,7 @@
   return dAtA[:n], nil
}

func (m *PlateCloudIDResult) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if len(m.Result) > 0 {
      for _, msg := range m.Result {
         dAtA[i] = 0xa
         i++
         i = encodeVarintSdk(dAtA, i, uint64(msg.Size()))
         n, err := msg.MarshalTo(dAtA[i:])
         if err != nil {
            return 0, err
         }
         i += n
      }
   }
   return i, nil
}

func (m *PlateVehicleID) 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 *PlateVehicleID) MarshalTo(dAtA []byte) (int, error) {
func (m *PlateIDVehicle) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
@@ -2623,7 +2473,7 @@
   return i, nil
}

func (m *PlateVehicleIDResult) Marshal() (dAtA []byte, err error) {
func (m *PlateIDResult) Marshal() (dAtA []byte, err error) {
   size := m.Size()
   dAtA = make([]byte, size)
   n, err := m.MarshalTo(dAtA)
@@ -2633,7 +2483,7 @@
   return dAtA[:n], nil
}

func (m *PlateVehicleIDResult) MarshalTo(dAtA []byte) (int, error) {
func (m *PlateIDResult) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
@@ -3028,22 +2878,7 @@
   return n
}

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

func (m *PlateCloudID) Size() (n int) {
func (m *PlateIDCloud) Size() (n int) {
   if m == nil {
      return 0
   }
@@ -3093,22 +2928,7 @@
   return n
}

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

func (m *PlateVehicleID) Size() (n int) {
func (m *PlateIDVehicle) Size() (n int) {
   if m == nil {
      return 0
   }
@@ -3185,7 +3005,7 @@
   return n
}

func (m *PlateVehicleIDResult) Size() (n int) {
func (m *PlateIDResult) Size() (n int) {
   if m == nil {
      return 0
   }
@@ -5785,7 +5605,7 @@
   }
   return nil
}
func (m *PlateIDResult) Unmarshal(dAtA []byte) error {
func (m *PlateIDCloud) Unmarshal(dAtA []byte) error {
   l := len(dAtA)
   iNdEx := 0
   for iNdEx < l {
@@ -5808,97 +5628,10 @@
      fieldNum := int32(wire >> 3)
      wireType := int(wire & 0x7)
      if wireType == 4 {
         return fmt.Errorf("proto: PlateIDResult: wiretype end group for non-group")
         return fmt.Errorf("proto: PlateIDCloud: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: PlateIDResult: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
         }
         var msglen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            msglen |= int(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         if msglen < 0 {
            return ErrInvalidLengthSdk
         }
         postIndex := iNdEx + msglen
         if postIndex < 0 {
            return ErrInvalidLengthSdk
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Result = append(m.Result, &PlateID{})
         if err := m.Result[len(m.Result)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex
      default:
         iNdEx = preIndex
         skippy, err := skipSdk(dAtA[iNdEx:])
         if err != nil {
            return err
         }
         if skippy < 0 {
            return ErrInvalidLengthSdk
         }
         if (iNdEx + skippy) < 0 {
            return ErrInvalidLengthSdk
         }
         if (iNdEx + skippy) > l {
            return io.ErrUnexpectedEOF
         }
         iNdEx += skippy
      }
   }

   if iNdEx > l {
      return io.ErrUnexpectedEOF
   }
   return nil
}
func (m *PlateCloudID) 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 ErrIntOverflowSdk
         }
         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: PlateCloudID: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: PlateCloudID: illegal tag %d (wire type %d)", fieldNum, wire)
         return fmt.Errorf("proto: PlateIDCloud: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
@@ -6202,7 +5935,7 @@
   }
   return nil
}
func (m *PlateCloudIDResult) Unmarshal(dAtA []byte) error {
func (m *PlateIDVehicle) Unmarshal(dAtA []byte) error {
   l := len(dAtA)
   iNdEx := 0
   for iNdEx < l {
@@ -6225,97 +5958,10 @@
      fieldNum := int32(wire >> 3)
      wireType := int(wire & 0x7)
      if wireType == 4 {
         return fmt.Errorf("proto: PlateCloudIDResult: wiretype end group for non-group")
         return fmt.Errorf("proto: PlateIDVehicle: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: PlateCloudIDResult: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
         }
         var msglen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            msglen |= int(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         if msglen < 0 {
            return ErrInvalidLengthSdk
         }
         postIndex := iNdEx + msglen
         if postIndex < 0 {
            return ErrInvalidLengthSdk
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Result = append(m.Result, &PlateCloudID{})
         if err := m.Result[len(m.Result)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex
      default:
         iNdEx = preIndex
         skippy, err := skipSdk(dAtA[iNdEx:])
         if err != nil {
            return err
         }
         if skippy < 0 {
            return ErrInvalidLengthSdk
         }
         if (iNdEx + skippy) < 0 {
            return ErrInvalidLengthSdk
         }
         if (iNdEx + skippy) > l {
            return io.ErrUnexpectedEOF
         }
         iNdEx += skippy
      }
   }

   if iNdEx > l {
      return io.ErrUnexpectedEOF
   }
   return nil
}
func (m *PlateVehicleID) 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 ErrIntOverflowSdk
         }
         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: PlateVehicleID: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: PlateVehicleID: illegal tag %d (wire type %d)", fieldNum, wire)
         return fmt.Errorf("proto: PlateIDVehicle: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
@@ -6843,7 +6489,7 @@
   }
   return nil
}
func (m *PlateVehicleIDResult) Unmarshal(dAtA []byte) error {
func (m *PlateIDResult) Unmarshal(dAtA []byte) error {
   l := len(dAtA)
   iNdEx := 0
   for iNdEx < l {
@@ -6866,10 +6512,10 @@
      fieldNum := int32(wire >> 3)
      wireType := int(wire & 0x7)
      if wireType == 4 {
         return fmt.Errorf("proto: PlateVehicleIDResult: wiretype end group for non-group")
         return fmt.Errorf("proto: PlateIDResult: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: PlateVehicleIDResult: illegal tag %d (wire type %d)", fieldNum, wire)
         return fmt.Errorf("proto: PlateIDResult: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
@@ -6901,7 +6547,7 @@
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Result = append(m.Result, &PlateVehicleID{})
         m.Result = append(m.Result, &PlateIDVehicle{})
         if err := m.Result[len(m.Result)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }