gateway.pb.go

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

package ttnpb

import (
	encoding_binary "encoding/binary"
	fmt "fmt"
	io "io"
	math "math"
	math_bits "math/bits"
	reflect "reflect"
	strings "strings"
	time "time"

	_ "github.com/envoyproxy/protoc-gen-validate/validate"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
	types "github.com/gogo/protobuf/types"
	golang_proto "github.com/golang/protobuf/proto"
	go_thethings_network_lorawan_stack_v3_pkg_types "go.thethings.network/lorawan-stack/v3/pkg/types"
)

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

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

type GatewayBrand struct {
	ID   string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	URL  string `protobuf:"bytes,3,opt,name=url,proto3" json:"url,omitempty"`
	// Logos contains file names of brand logos.
	Logos                []string `protobuf:"bytes,4,rep,name=logos,proto3" json:"logos,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_GatewayBrand proto.InternalMessageInfo

func (m *GatewayBrand) GetID() string {
	if m != nil {
		return m.ID
	}
	return ""
}

func (m *GatewayBrand) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *GatewayBrand) GetURL() string {
	if m != nil {
		return m.URL
	}
	return ""
}

func (m *GatewayBrand) GetLogos() []string {
	if m != nil {
		return m.Logos
	}
	return nil
}

type GatewayModel struct {
	BrandID              string   `protobuf:"bytes,1,opt,name=brand_id,json=brandId,proto3" json:"brand_id,omitempty"`
	ID                   string   `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
	Name                 string   `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_GatewayModel proto.InternalMessageInfo

func (m *GatewayModel) GetBrandID() string {
	if m != nil {
		return m.BrandID
	}
	return ""
}

func (m *GatewayModel) GetID() string {
	if m != nil {
		return m.ID
	}
	return ""
}

func (m *GatewayModel) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

// Identifies an end device model with version information.
type GatewayVersionIdentifiers struct {
	BrandID              string   `protobuf:"bytes,1,opt,name=brand_id,json=brandId,proto3" json:"brand_id,omitempty"`
	ModelID              string   `protobuf:"bytes,2,opt,name=model_id,json=modelId,proto3" json:"model_id,omitempty"`
	HardwareVersion      string   `protobuf:"bytes,3,opt,name=hardware_version,json=hardwareVersion,proto3" json:"hardware_version,omitempty"`
	FirmwareVersion      string   `protobuf:"bytes,4,opt,name=firmware_version,json=firmwareVersion,proto3" json:"firmware_version,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_GatewayVersionIdentifiers proto.InternalMessageInfo

func (m *GatewayVersionIdentifiers) GetBrandID() string {
	if m != nil {
		return m.BrandID
	}
	return ""
}

func (m *GatewayVersionIdentifiers) GetModelID() string {
	if m != nil {
		return m.ModelID
	}
	return ""
}

func (m *GatewayVersionIdentifiers) GetHardwareVersion() string {
	if m != nil {
		return m.HardwareVersion
	}
	return ""
}

func (m *GatewayVersionIdentifiers) GetFirmwareVersion() string {
	if m != nil {
		return m.FirmwareVersion
	}
	return ""
}

type GatewayRadio struct {
	Enable               bool                          `protobuf:"varint,1,opt,name=enable,proto3" json:"enable,omitempty"`
	ChipType             string                        `protobuf:"bytes,2,opt,name=chip_type,json=chipType,proto3" json:"chip_type,omitempty"`
	Frequency            uint64                        `protobuf:"varint,3,opt,name=frequency,proto3" json:"frequency,omitempty"`
	RSSIOffset           float32                       `protobuf:"fixed32,4,opt,name=rssi_offset,json=rssiOffset,proto3" json:"rssi_offset,omitempty"`
	TxConfiguration      *GatewayRadio_TxConfiguration `protobuf:"bytes,5,opt,name=tx_configuration,json=txConfiguration,proto3" json:"tx_configuration,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                      `json:"-"`
	XXX_sizecache        int32                         `json:"-"`
}

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

var xxx_messageInfo_GatewayRadio proto.InternalMessageInfo

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

func (m *GatewayRadio) GetChipType() string {
	if m != nil {
		return m.ChipType
	}
	return ""
}

func (m *GatewayRadio) GetFrequency() uint64 {
	if m != nil {
		return m.Frequency
	}
	return 0
}

func (m *GatewayRadio) GetRSSIOffset() float32 {
	if m != nil {
		return m.RSSIOffset
	}
	return 0
}

func (m *GatewayRadio) GetTxConfiguration() *GatewayRadio_TxConfiguration {
	if m != nil {
		return m.TxConfiguration
	}
	return nil
}

type GatewayRadio_TxConfiguration struct {
	MinFrequency         uint64   `protobuf:"varint,1,opt,name=min_frequency,json=minFrequency,proto3" json:"min_frequency,omitempty"`
	MaxFrequency         uint64   `protobuf:"varint,2,opt,name=max_frequency,json=maxFrequency,proto3" json:"max_frequency,omitempty"`
	NotchFrequency       uint64   `protobuf:"varint,3,opt,name=notch_frequency,json=notchFrequency,proto3" json:"notch_frequency,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GatewayRadio_TxConfiguration) Reset()      { *m = GatewayRadio_TxConfiguration{} }
func (*GatewayRadio_TxConfiguration) ProtoMessage() {}
func (*GatewayRadio_TxConfiguration) Descriptor() ([]byte, []int) {
	return fileDescriptor_1df6bae1ac946b39, []int{3, 0}
}
func (m *GatewayRadio_TxConfiguration) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GatewayRadio_TxConfiguration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GatewayRadio_TxConfiguration.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GatewayRadio_TxConfiguration) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GatewayRadio_TxConfiguration.Merge(m, src)
}
func (m *GatewayRadio_TxConfiguration) XXX_Size() int {
	return m.Size()
}
func (m *GatewayRadio_TxConfiguration) XXX_DiscardUnknown() {
	xxx_messageInfo_GatewayRadio_TxConfiguration.DiscardUnknown(m)
}

var xxx_messageInfo_GatewayRadio_TxConfiguration proto.InternalMessageInfo

func (m *GatewayRadio_TxConfiguration) GetMinFrequency() uint64 {
	if m != nil {
		return m.MinFrequency
	}
	return 0
}

func (m *GatewayRadio_TxConfiguration) GetMaxFrequency() uint64 {
	if m != nil {
		return m.MaxFrequency
	}
	return 0
}

func (m *GatewayRadio_TxConfiguration) GetNotchFrequency() uint64 {
	if m != nil {
		return m.NotchFrequency
	}
	return 0
}

// Template for creating gateways.
type GatewayVersion struct {
	// Version identifiers.
	GatewayVersionIdentifiers `protobuf:"bytes,1,opt,name=ids,proto3,embedded=ids" json:"ids"`
	// Photos contains file names of gateway photos.
	Photos               []string        `protobuf:"bytes,2,rep,name=photos,proto3" json:"photos,omitempty"`
	Radios               []*GatewayRadio `protobuf:"bytes,3,rep,name=radios,proto3" json:"radios,omitempty"`
	ClockSource          uint32          `protobuf:"varint,7,opt,name=clock_source,json=clockSource,proto3" json:"clock_source,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

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

var xxx_messageInfo_GatewayVersion proto.InternalMessageInfo

func (m *GatewayVersion) GetPhotos() []string {
	if m != nil {
		return m.Photos
	}
	return nil
}

func (m *GatewayVersion) GetRadios() []*GatewayRadio {
	if m != nil {
		return m.Radios
	}
	return nil
}

func (m *GatewayVersion) GetClockSource() uint32 {
	if m != nil {
		return m.ClockSource
	}
	return 0
}

// Gateway is the message that defines a gateway on the network.
type Gateway struct {
	GatewayIdentifiers        `protobuf:"bytes,1,opt,name=ids,proto3,embedded=ids" json:"ids"`
	CreatedAt                 time.Time         `protobuf:"bytes,2,opt,name=created_at,json=createdAt,proto3,stdtime" json:"created_at"`
	UpdatedAt                 time.Time         `protobuf:"bytes,3,opt,name=updated_at,json=updatedAt,proto3,stdtime" json:"updated_at"`
	Name                      string            `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty"`
	Description               string            `protobuf:"bytes,5,opt,name=description,proto3" json:"description,omitempty"`
	Attributes                map[string]string `protobuf:"bytes,6,rep,name=attributes,proto3" json:"attributes,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	ContactInfo               []*ContactInfo    `protobuf:"bytes,7,rep,name=contact_info,json=contactInfo,proto3" json:"contact_info,omitempty"`
	GatewayVersionIdentifiers `protobuf:"bytes,8,opt,name=version_ids,json=versionIds,proto3,embedded=version_ids" json:"version_ids"`
	// The address of the Gateway Server to connect to.
	// The typical format of the address is "host:port". If the port is omitted,
	// the normal port inference (with DNS lookup, otherwise defaults) is used.
	// The connection shall be established with transport layer security (TLS).
	// Custom certificate authorities may be configured out-of-band.
	GatewayServerAddress string `protobuf:"bytes,9,opt,name=gateway_server_address,json=gatewayServerAddress,proto3" json:"gateway_server_address,omitempty"`
	AutoUpdate           bool   `protobuf:"varint,10,opt,name=auto_update,json=autoUpdate,proto3" json:"auto_update,omitempty"`
	UpdateChannel        string `protobuf:"bytes,11,opt,name=update_channel,json=updateChannel,proto3" json:"update_channel,omitempty"`
	// Frequency plan ID of the gateway.
	// This equals the first element of the frequency_plan_ids field.
	FrequencyPlanID string `protobuf:"bytes,12,opt,name=frequency_plan_id,json=frequencyPlanId,proto3" json:"frequency_plan_id,omitempty"`
	// Frequency plan IDs of the gateway.
	// The first element equals the frequency_plan_id field.
	FrequencyPlanIDs []string         `protobuf:"bytes,20,rep,name=frequency_plan_ids,json=frequencyPlanIds,proto3" json:"frequency_plan_ids,omitempty"`
	Antennas         []GatewayAntenna `protobuf:"bytes,13,rep,name=antennas,proto3" json:"antennas"`
	// The status of this gateway may be publicly displayed.
	StatusPublic bool `protobuf:"varint,14,opt,name=status_public,json=statusPublic,proto3" json:"status_public,omitempty"`
	// The location of this gateway may be publicly displayed.
	LocationPublic bool `protobuf:"varint,15,opt,name=location_public,json=locationPublic,proto3" json:"location_public,omitempty"`
	// Enable server-side buffering of downlink messages. This is recommended for gateways using the Semtech UDP Packet
	// Forwarder v2.x or older, as it does not feature a just-in-time queue. If enabled, the Gateway Server schedules the
	// downlink message late to the gateway so that it does not overwrite previously scheduled downlink messages that have
	// not been transmitted yet.
	ScheduleDownlinkLate bool `protobuf:"varint,16,opt,name=schedule_downlink_late,json=scheduleDownlinkLate,proto3" json:"schedule_downlink_late,omitempty"`
	// Enforcing gateway duty cycle is recommended for all gateways to respect spectrum regulations. Disable enforcing the
	// duty cycle only in controlled research and development environments.
	EnforceDutyCycle       bool                   `protobuf:"varint,17,opt,name=enforce_duty_cycle,json=enforceDutyCycle,proto3" json:"enforce_duty_cycle,omitempty"`
	DownlinkPathConstraint DownlinkPathConstraint `protobuf:"varint,18,opt,name=downlink_path_constraint,json=downlinkPathConstraint,proto3,enum=ttn.lorawan.v3.DownlinkPathConstraint" json:"downlink_path_constraint,omitempty"`
	// Adjust the time that GS schedules class C messages in advance. This is useful for gateways that have a known high latency backhaul, like 3G and satellite.
	ScheduleAnytimeDelay *time.Duration `protobuf:"bytes,19,opt,name=schedule_anytime_delay,json=scheduleAnytimeDelay,proto3,stdduration" json:"schedule_anytime_delay,omitempty"`
	// update the location of this gateway from status messages
	UpdateLocationFromStatus bool     `protobuf:"varint,21,opt,name=update_location_from_status,json=updateLocationFromStatus,proto3" json:"update_location_from_status,omitempty"`
	XXX_NoUnkeyedLiteral     struct{} `json:"-"`
	XXX_sizecache            int32    `json:"-"`
}

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

var xxx_messageInfo_Gateway proto.InternalMessageInfo

func (m *Gateway) GetCreatedAt() time.Time {
	if m != nil {
		return m.CreatedAt
	}
	return time.Time{}
}

func (m *Gateway) GetUpdatedAt() time.Time {
	if m != nil {
		return m.UpdatedAt
	}
	return time.Time{}
}

func (m *Gateway) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *Gateway) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

func (m *Gateway) GetAttributes() map[string]string {
	if m != nil {
		return m.Attributes
	}
	return nil
}

func (m *Gateway) GetContactInfo() []*ContactInfo {
	if m != nil {
		return m.ContactInfo
	}
	return nil
}

func (m *Gateway) GetGatewayServerAddress() string {
	if m != nil {
		return m.GatewayServerAddress
	}
	return ""
}

func (m *Gateway) GetAutoUpdate() bool {
	if m != nil {
		return m.AutoUpdate
	}
	return false
}

func (m *Gateway) GetUpdateChannel() string {
	if m != nil {
		return m.UpdateChannel
	}
	return ""
}

func (m *Gateway) GetFrequencyPlanID() string {
	if m != nil {
		return m.FrequencyPlanID
	}
	return ""
}

func (m *Gateway) GetFrequencyPlanIDs() []string {
	if m != nil {
		return m.FrequencyPlanIDs
	}
	return nil
}

func (m *Gateway) GetAntennas() []GatewayAntenna {
	if m != nil {
		return m.Antennas
	}
	return nil
}

func (m *Gateway) GetStatusPublic() bool {
	if m != nil {
		return m.StatusPublic
	}
	return false
}

func (m *Gateway) GetLocationPublic() bool {
	if m != nil {
		return m.LocationPublic
	}
	return false
}

func (m *Gateway) GetScheduleDownlinkLate() bool {
	if m != nil {
		return m.ScheduleDownlinkLate
	}
	return false
}

func (m *Gateway) GetEnforceDutyCycle() bool {
	if m != nil {
		return m.EnforceDutyCycle
	}
	return false
}

func (m *Gateway) GetDownlinkPathConstraint() DownlinkPathConstraint {
	if m != nil {
		return m.DownlinkPathConstraint
	}
	return DOWNLINK_PATH_CONSTRAINT_NONE
}

func (m *Gateway) GetScheduleAnytimeDelay() *time.Duration {
	if m != nil {
		return m.ScheduleAnytimeDelay
	}
	return nil
}

func (m *Gateway) GetUpdateLocationFromStatus() bool {
	if m != nil {
		return m.UpdateLocationFromStatus
	}
	return false
}

type Gateways struct {
	Gateways             []*Gateway `protobuf:"bytes,1,rep,name=gateways,proto3" json:"gateways,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *Gateways) Reset()      { *m = Gateways{} }
func (*Gateways) ProtoMessage() {}
func (*Gateways) Descriptor() ([]byte, []int) {
	return fileDescriptor_1df6bae1ac946b39, []int{6}
}
func (m *Gateways) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Gateways) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Gateways.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Gateways) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Gateways.Merge(m, src)
}
func (m *Gateways) XXX_Size() int {
	return m.Size()
}
func (m *Gateways) XXX_DiscardUnknown() {
	xxx_messageInfo_Gateways.DiscardUnknown(m)
}

var xxx_messageInfo_Gateways proto.InternalMessageInfo

func (m *Gateways) GetGateways() []*Gateway {
	if m != nil {
		return m.Gateways
	}
	return nil
}

type GetGatewayRequest struct {
	GatewayIdentifiers   `protobuf:"bytes,1,opt,name=gateway_ids,json=gatewayIds,proto3,embedded=gateway_ids" json:"gateway_ids"`
	FieldMask            types.FieldMask `protobuf:"bytes,2,opt,name=field_mask,json=fieldMask,proto3" json:"field_mask"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *GetGatewayRequest) Reset()      { *m = GetGatewayRequest{} }
func (*GetGatewayRequest) ProtoMessage() {}
func (*GetGatewayRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_1df6bae1ac946b39, []int{7}
}
func (m *GetGatewayRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetGatewayRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetGatewayRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetGatewayRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetGatewayRequest.Merge(m, src)
}
func (m *GetGatewayRequest) XXX_Size() int {
	return m.Size()
}
func (m *GetGatewayRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetGatewayRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetGatewayRequest proto.InternalMessageInfo

func (m *GetGatewayRequest) GetFieldMask() types.FieldMask {
	if m != nil {
		return m.FieldMask
	}
	return types.FieldMask{}
}

type GetGatewayIdentifiersForEUIRequest struct {
	EUI                  go_thethings_network_lorawan_stack_v3_pkg_types.EUI64 `protobuf:"bytes,1,opt,name=eui,proto3,customtype=go.thethings.network/lorawan-stack/v3/pkg/types.EUI64" json:"eui"`
	XXX_NoUnkeyedLiteral struct{}                                              `json:"-"`
	XXX_sizecache        int32                                                 `json:"-"`
}

func (m *GetGatewayIdentifiersForEUIRequest) Reset()      { *m = GetGatewayIdentifiersForEUIRequest{} }
func (*GetGatewayIdentifiersForEUIRequest) ProtoMessage() {}
func (*GetGatewayIdentifiersForEUIRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_1df6bae1ac946b39, []int{8}
}
func (m *GetGatewayIdentifiersForEUIRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetGatewayIdentifiersForEUIRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetGatewayIdentifiersForEUIRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetGatewayIdentifiersForEUIRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetGatewayIdentifiersForEUIRequest.Merge(m, src)
}
func (m *GetGatewayIdentifiersForEUIRequest) XXX_Size() int {
	return m.Size()
}
func (m *GetGatewayIdentifiersForEUIRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetGatewayIdentifiersForEUIRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetGatewayIdentifiersForEUIRequest proto.InternalMessageInfo

type ListGatewaysRequest struct {
	Collaborator *OrganizationOrUserIdentifiers `protobuf:"bytes,1,opt,name=collaborator,proto3" json:"collaborator,omitempty"`
	FieldMask    types.FieldMask                `protobuf:"bytes,2,opt,name=field_mask,json=fieldMask,proto3" json:"field_mask"`
	// Order the results by this field path (must be present in the field mask).
	// Default ordering is by ID. Prepend with a minus (-) to reverse the order.
	Order string `protobuf:"bytes,3,opt,name=order,proto3" json:"order,omitempty"`
	// Limit the number of results per page.
	Limit uint32 `protobuf:"varint,4,opt,name=limit,proto3" json:"limit,omitempty"`
	// Page number for pagination. 0 is interpreted as 1.
	Page                 uint32   `protobuf:"varint,5,opt,name=page,proto3" json:"page,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ListGatewaysRequest) Reset()      { *m = ListGatewaysRequest{} }
func (*ListGatewaysRequest) ProtoMessage() {}
func (*ListGatewaysRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_1df6bae1ac946b39, []int{9}
}
func (m *ListGatewaysRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ListGatewaysRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ListGatewaysRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ListGatewaysRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListGatewaysRequest.Merge(m, src)
}
func (m *ListGatewaysRequest) XXX_Size() int {
	return m.Size()
}
func (m *ListGatewaysRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ListGatewaysRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ListGatewaysRequest proto.InternalMessageInfo

func (m *ListGatewaysRequest) GetCollaborator() *OrganizationOrUserIdentifiers {
	if m != nil {
		return m.Collaborator
	}
	return nil
}

func (m *ListGatewaysRequest) GetFieldMask() types.FieldMask {
	if m != nil {
		return m.FieldMask
	}
	return types.FieldMask{}
}

func (m *ListGatewaysRequest) GetOrder() string {
	if m != nil {
		return m.Order
	}
	return ""
}

func (m *ListGatewaysRequest) GetLimit() uint32 {
	if m != nil {
		return m.Limit
	}
	return 0
}

func (m *ListGatewaysRequest) GetPage() uint32 {
	if m != nil {
		return m.Page
	}
	return 0
}

type CreateGatewayRequest struct {
	Gateway `protobuf:"bytes,1,opt,name=gateway,proto3,embedded=gateway" json:"gateway"`
	// Collaborator to grant all rights on the newly created gateway.
	Collaborator         OrganizationOrUserIdentifiers `protobuf:"bytes,2,opt,name=collaborator,proto3" json:"collaborator"`
	XXX_NoUnkeyedLiteral struct{}                      `json:"-"`
	XXX_sizecache        int32                         `json:"-"`
}

func (m *CreateGatewayRequest) Reset()      { *m = CreateGatewayRequest{} }
func (*CreateGatewayRequest) ProtoMessage() {}
func (*CreateGatewayRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_1df6bae1ac946b39, []int{10}
}
func (m *CreateGatewayRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CreateGatewayRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CreateGatewayRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CreateGatewayRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CreateGatewayRequest.Merge(m, src)
}
func (m *CreateGatewayRequest) XXX_Size() int {
	return m.Size()
}
func (m *CreateGatewayRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_CreateGatewayRequest.DiscardUnknown(m)
}

var xxx_messageInfo_CreateGatewayRequest proto.InternalMessageInfo

func (m *CreateGatewayRequest) GetCollaborator() OrganizationOrUserIdentifiers {
	if m != nil {
		return m.Collaborator
	}
	return OrganizationOrUserIdentifiers{}
}

type UpdateGatewayRequest struct {
	Gateway              `protobuf:"bytes,1,opt,name=gateway,proto3,embedded=gateway" json:"gateway"`
	FieldMask            types.FieldMask `protobuf:"bytes,2,opt,name=field_mask,json=fieldMask,proto3" json:"field_mask"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *UpdateGatewayRequest) Reset()      { *m = UpdateGatewayRequest{} }
func (*UpdateGatewayRequest) ProtoMessage() {}
func (*UpdateGatewayRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_1df6bae1ac946b39, []int{11}
}
func (m *UpdateGatewayRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UpdateGatewayRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UpdateGatewayRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *UpdateGatewayRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UpdateGatewayRequest.Merge(m, src)
}
func (m *UpdateGatewayRequest) XXX_Size() int {
	return m.Size()
}
func (m *UpdateGatewayRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_UpdateGatewayRequest.DiscardUnknown(m)
}

var xxx_messageInfo_UpdateGatewayRequest proto.InternalMessageInfo

func (m *UpdateGatewayRequest) GetFieldMask() types.FieldMask {
	if m != nil {
		return m.FieldMask
	}
	return types.FieldMask{}
}

type ListGatewayAPIKeysRequest struct {
	GatewayIdentifiers `protobuf:"bytes,1,opt,name=gateway_ids,json=gatewayIds,proto3,embedded=gateway_ids" json:"gateway_ids"`
	// Limit the number of results per page.
	Limit uint32 `protobuf:"varint,2,opt,name=limit,proto3" json:"limit,omitempty"`
	// Page number for pagination. 0 is interpreted as 1.
	Page                 uint32   `protobuf:"varint,3,opt,name=page,proto3" json:"page,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ListGatewayAPIKeysRequest) Reset()      { *m = ListGatewayAPIKeysRequest{} }
func (*ListGatewayAPIKeysRequest) ProtoMessage() {}
func (*ListGatewayAPIKeysRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_1df6bae1ac946b39, []int{12}
}
func (m *ListGatewayAPIKeysRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ListGatewayAPIKeysRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ListGatewayAPIKeysRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ListGatewayAPIKeysRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListGatewayAPIKeysRequest.Merge(m, src)
}
func (m *ListGatewayAPIKeysRequest) XXX_Size() int {
	return m.Size()
}
func (m *ListGatewayAPIKeysRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ListGatewayAPIKeysRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ListGatewayAPIKeysRequest proto.InternalMessageInfo

func (m *ListGatewayAPIKeysRequest) GetLimit() uint32 {
	if m != nil {
		return m.Limit
	}
	return 0
}

func (m *ListGatewayAPIKeysRequest) GetPage() uint32 {
	if m != nil {
		return m.Page
	}
	return 0
}

type GetGatewayAPIKeyRequest struct {
	GatewayIdentifiers `protobuf:"bytes,1,opt,name=gateway_ids,json=gatewayIds,proto3,embedded=gateway_ids" json:"gateway_ids"`
	// Unique public identifier for the API key.
	KeyID                string   `protobuf:"bytes,2,opt,name=key_id,json=keyId,proto3" json:"key_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetGatewayAPIKeyRequest) Reset()      { *m = GetGatewayAPIKeyRequest{} }
func (*GetGatewayAPIKeyRequest) ProtoMessage() {}
func (*GetGatewayAPIKeyRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_1df6bae1ac946b39, []int{13}
}
func (m *GetGatewayAPIKeyRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetGatewayAPIKeyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetGatewayAPIKeyRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetGatewayAPIKeyRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetGatewayAPIKeyRequest.Merge(m, src)
}
func (m *GetGatewayAPIKeyRequest) XXX_Size() int {
	return m.Size()
}
func (m *GetGatewayAPIKeyRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetGatewayAPIKeyRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetGatewayAPIKeyRequest proto.InternalMessageInfo

func (m *GetGatewayAPIKeyRequest) GetKeyID() string {
	if m != nil {
		return m.KeyID
	}
	return ""
}

type CreateGatewayAPIKeyRequest struct {
	GatewayIdentifiers   `protobuf:"bytes,1,opt,name=gateway_ids,json=gatewayIds,proto3,embedded=gateway_ids" json:"gateway_ids"`
	Name                 string   `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	Rights               []Right  `protobuf:"varint,3,rep,packed,name=rights,proto3,enum=ttn.lorawan.v3.Right" json:"rights,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CreateGatewayAPIKeyRequest) Reset()      { *m = CreateGatewayAPIKeyRequest{} }
func (*CreateGatewayAPIKeyRequest) ProtoMessage() {}
func (*CreateGatewayAPIKeyRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_1df6bae1ac946b39, []int{14}
}
func (m *CreateGatewayAPIKeyRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CreateGatewayAPIKeyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CreateGatewayAPIKeyRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CreateGatewayAPIKeyRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CreateGatewayAPIKeyRequest.Merge(m, src)
}
func (m *CreateGatewayAPIKeyRequest) XXX_Size() int {
	return m.Size()
}
func (m *CreateGatewayAPIKeyRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_CreateGatewayAPIKeyRequest.DiscardUnknown(m)
}

var xxx_messageInfo_CreateGatewayAPIKeyRequest proto.InternalMessageInfo

func (m *CreateGatewayAPIKeyRequest) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *CreateGatewayAPIKeyRequest) GetRights() []Right {
	if m != nil {
		return m.Rights
	}
	return nil
}

type UpdateGatewayAPIKeyRequest struct {
	GatewayIdentifiers   `protobuf:"bytes,1,opt,name=gateway_ids,json=gatewayIds,proto3,embedded=gateway_ids" json:"gateway_ids"`
	APIKey               `protobuf:"bytes,2,opt,name=api_key,json=apiKey,proto3,embedded=api_key" json:"api_key"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *UpdateGatewayAPIKeyRequest) Reset()      { *m = UpdateGatewayAPIKeyRequest{} }
func (*UpdateGatewayAPIKeyRequest) ProtoMessage() {}
func (*UpdateGatewayAPIKeyRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_1df6bae1ac946b39, []int{15}
}
func (m *UpdateGatewayAPIKeyRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UpdateGatewayAPIKeyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UpdateGatewayAPIKeyRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *UpdateGatewayAPIKeyRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UpdateGatewayAPIKeyRequest.Merge(m, src)
}
func (m *UpdateGatewayAPIKeyRequest) XXX_Size() int {
	return m.Size()
}
func (m *UpdateGatewayAPIKeyRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_UpdateGatewayAPIKeyRequest.DiscardUnknown(m)
}

var xxx_messageInfo_UpdateGatewayAPIKeyRequest proto.InternalMessageInfo

type ListGatewayCollaboratorsRequest struct {
	GatewayIdentifiers `protobuf:"bytes,1,opt,name=gateway_ids,json=gatewayIds,proto3,embedded=gateway_ids" json:"gateway_ids"`
	// Limit the number of results per page.
	Limit uint32 `protobuf:"varint,2,opt,name=limit,proto3" json:"limit,omitempty"`
	// Page number for pagination. 0 is interpreted as 1.
	Page                 uint32   `protobuf:"varint,3,opt,name=page,proto3" json:"page,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ListGatewayCollaboratorsRequest) Reset()      { *m = ListGatewayCollaboratorsRequest{} }
func (*ListGatewayCollaboratorsRequest) ProtoMessage() {}
func (*ListGatewayCollaboratorsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_1df6bae1ac946b39, []int{16}
}
func (m *ListGatewayCollaboratorsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ListGatewayCollaboratorsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ListGatewayCollaboratorsRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ListGatewayCollaboratorsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListGatewayCollaboratorsRequest.Merge(m, src)
}
func (m *ListGatewayCollaboratorsRequest) XXX_Size() int {
	return m.Size()
}
func (m *ListGatewayCollaboratorsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ListGatewayCollaboratorsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ListGatewayCollaboratorsRequest proto.InternalMessageInfo

func (m *ListGatewayCollaboratorsRequest) GetLimit() uint32 {
	if m != nil {
		return m.Limit
	}
	return 0
}

func (m *ListGatewayCollaboratorsRequest) GetPage() uint32 {
	if m != nil {
		return m.Page
	}
	return 0
}

type GetGatewayCollaboratorRequest struct {
	GatewayIdentifiers            `protobuf:"bytes,1,opt,name=gateway_ids,json=gatewayIds,proto3,embedded=gateway_ids" json:"gateway_ids"`
	OrganizationOrUserIdentifiers `protobuf:"bytes,2,opt,name=collaborator,proto3,embedded=collaborator" json:"collaborator"`
	XXX_NoUnkeyedLiteral          struct{} `json:"-"`
	XXX_sizecache                 int32    `json:"-"`
}

func (m *GetGatewayCollaboratorRequest) Reset()      { *m = GetGatewayCollaboratorRequest{} }
func (*GetGatewayCollaboratorRequest) ProtoMessage() {}
func (*GetGatewayCollaboratorRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_1df6bae1ac946b39, []int{17}
}
func (m *GetGatewayCollaboratorRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetGatewayCollaboratorRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetGatewayCollaboratorRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetGatewayCollaboratorRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetGatewayCollaboratorRequest.Merge(m, src)
}
func (m *GetGatewayCollaboratorRequest) XXX_Size() int {
	return m.Size()
}
func (m *GetGatewayCollaboratorRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetGatewayCollaboratorRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetGatewayCollaboratorRequest proto.InternalMessageInfo

type SetGatewayCollaboratorRequest struct {
	GatewayIdentifiers   `protobuf:"bytes,1,opt,name=gateway_ids,json=gatewayIds,proto3,embedded=gateway_ids" json:"gateway_ids"`
	Collaborator         Collaborator `protobuf:"bytes,2,opt,name=collaborator,proto3" json:"collaborator"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *SetGatewayCollaboratorRequest) Reset()      { *m = SetGatewayCollaboratorRequest{} }
func (*SetGatewayCollaboratorRequest) ProtoMessage() {}
func (*SetGatewayCollaboratorRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_1df6bae1ac946b39, []int{18}
}
func (m *SetGatewayCollaboratorRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SetGatewayCollaboratorRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SetGatewayCollaboratorRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *SetGatewayCollaboratorRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SetGatewayCollaboratorRequest.Merge(m, src)
}
func (m *SetGatewayCollaboratorRequest) XXX_Size() int {
	return m.Size()
}
func (m *SetGatewayCollaboratorRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_SetGatewayCollaboratorRequest.DiscardUnknown(m)
}

var xxx_messageInfo_SetGatewayCollaboratorRequest proto.InternalMessageInfo

func (m *SetGatewayCollaboratorRequest) GetCollaborator() Collaborator {
	if m != nil {
		return m.Collaborator
	}
	return Collaborator{}
}

// GatewayAntenna is the message that defines a gateway antenna.
type GatewayAntenna struct {
	// gain is the antenna gain relative to this gateway, in dBi.
	Gain float32 `protobuf:"fixed32,1,opt,name=gain,proto3" json:"gain,omitempty"`
	// location is the antenna's location.
	Location             Location          `protobuf:"bytes,2,opt,name=location,proto3" json:"location"`
	Attributes           map[string]string `protobuf:"bytes,3,rep,name=attributes,proto3" json:"attributes,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *GatewayAntenna) Reset()      { *m = GatewayAntenna{} }
func (*GatewayAntenna) ProtoMessage() {}
func (*GatewayAntenna) Descriptor() ([]byte, []int) {
	return fileDescriptor_1df6bae1ac946b39, []int{19}
}
func (m *GatewayAntenna) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GatewayAntenna) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GatewayAntenna.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GatewayAntenna) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GatewayAntenna.Merge(m, src)
}
func (m *GatewayAntenna) XXX_Size() int {
	return m.Size()
}
func (m *GatewayAntenna) XXX_DiscardUnknown() {
	xxx_messageInfo_GatewayAntenna.DiscardUnknown(m)
}

var xxx_messageInfo_GatewayAntenna proto.InternalMessageInfo

func (m *GatewayAntenna) GetGain() float32 {
	if m != nil {
		return m.Gain
	}
	return 0
}

func (m *GatewayAntenna) GetLocation() Location {
	if m != nil {
		return m.Location
	}
	return Location{}
}

func (m *GatewayAntenna) GetAttributes() map[string]string {
	if m != nil {
		return m.Attributes
	}
	return nil
}

type GatewayStatus struct {
	// Current time of the gateway
	Time time.Time `protobuf:"bytes,1,opt,name=time,proto3,stdtime" json:"time"`
	// Boot time of the gateway
	// - can be left out to save bandwidth; old value will be kept
	BootTime time.Time `protobuf:"bytes,2,opt,name=boot_time,json=bootTime,proto3,stdtime" json:"boot_time"`
	// Versions of gateway subsystems
	// - each field can be left out to save bandwidth; old value will be kept
	// - map keys are written in snake_case
	// - for example:
	//     firmware: "2.0.4"
	//     forwarder: "v2-3.3.1"
	//     fpga: "48"
	//     dsp: "27"
	//     hal: "v2-3.5.0"
	Versions map[string]string `protobuf:"bytes,3,rep,name=versions,proto3" json:"versions,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	// Location of each gateway's antenna
	// - if left out, server uses registry-set location as fallback
	AntennaLocations []*Location `protobuf:"bytes,4,rep,name=antenna_locations,json=antennaLocations,proto3" json:"antenna_locations,omitempty"`
	// IP addresses of this gateway.
	// Repeated addresses can be used to communicate addresses of multiple interfaces (LAN, Public IP, ...).
	IP []string `protobuf:"bytes,5,rep,name=ip,proto3" json:"ip,omitempty"`
	// Metrics
	// - can be used for forwarding gateway metrics such as temperatures or performance metrics
	// - map keys are written in snake_case
	Metrics map[string]float32 `protobuf:"bytes,6,rep,name=metrics,proto3" json:"metrics,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"`
	// Advanced metadata fields
	// - can be used for advanced information or experimental features that are not yet formally defined in the API
	// - field names are written in snake_case
	Advanced             *types.Struct `protobuf:"bytes,99,opt,name=advanced,proto3" json:"advanced,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func (m *GatewayStatus) Reset()      { *m = GatewayStatus{} }
func (*GatewayStatus) ProtoMessage() {}
func (*GatewayStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_1df6bae1ac946b39, []int{20}
}
func (m *GatewayStatus) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GatewayStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GatewayStatus.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GatewayStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GatewayStatus.Merge(m, src)
}
func (m *GatewayStatus) XXX_Size() int {
	return m.Size()
}
func (m *GatewayStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_GatewayStatus.DiscardUnknown(m)
}

var xxx_messageInfo_GatewayStatus proto.InternalMessageInfo

func (m *GatewayStatus) GetTime() time.Time {
	if m != nil {
		return m.Time
	}
	return time.Time{}
}

func (m *GatewayStatus) GetBootTime() time.Time {
	if m != nil {
		return m.BootTime
	}
	return time.Time{}
}

func (m *GatewayStatus) GetVersions() map[string]string {
	if m != nil {
		return m.Versions
	}
	return nil
}

func (m *GatewayStatus) GetAntennaLocations() []*Location {
	if m != nil {
		return m.AntennaLocations
	}
	return nil
}

func (m *GatewayStatus) GetIP() []string {
	if m != nil {
		return m.IP
	}
	return nil
}

func (m *GatewayStatus) GetMetrics() map[string]float32 {
	if m != nil {
		return m.Metrics
	}
	return nil
}

func (m *GatewayStatus) GetAdvanced() *types.Struct {
	if m != nil {
		return m.Advanced
	}
	return nil
}

// Connection stats as monitored by the Gateway Server.
type GatewayConnectionStats struct {
	ConnectedAt            *time.Time                             `protobuf:"bytes,1,opt,name=connected_at,json=connectedAt,proto3,stdtime" json:"connected_at,omitempty"`
	Protocol               string                                 `protobuf:"bytes,2,opt,name=protocol,proto3" json:"protocol,omitempty"`
	LastStatusReceivedAt   *time.Time                             `protobuf:"bytes,3,opt,name=last_status_received_at,json=lastStatusReceivedAt,proto3,stdtime" json:"last_status_received_at,omitempty"`
	LastStatus             *GatewayStatus                         `protobuf:"bytes,4,opt,name=last_status,json=lastStatus,proto3" json:"last_status,omitempty"`
	LastUplinkReceivedAt   *time.Time                             `protobuf:"bytes,5,opt,name=last_uplink_received_at,json=lastUplinkReceivedAt,proto3,stdtime" json:"last_uplink_received_at,omitempty"`
	UplinkCount            uint64                                 `protobuf:"varint,6,opt,name=uplink_count,json=uplinkCount,proto3" json:"uplink_count,omitempty"`
	LastDownlinkReceivedAt *time.Time                             `protobuf:"bytes,7,opt,name=last_downlink_received_at,json=lastDownlinkReceivedAt,proto3,stdtime" json:"last_downlink_received_at,omitempty"`
	DownlinkCount          uint64                                 `protobuf:"varint,8,opt,name=downlink_count,json=downlinkCount,proto3" json:"downlink_count,omitempty"`
	RoundTripTimes         *GatewayConnectionStats_RoundTripTimes `protobuf:"bytes,9,opt,name=round_trip_times,json=roundTripTimes,proto3" json:"round_trip_times,omitempty"`
	XXX_NoUnkeyedLiteral   struct{}                               `json:"-"`
	XXX_sizecache          int32                                  `json:"-"`
}

func (m *GatewayConnectionStats) Reset()      { *m = GatewayConnectionStats{} }
func (*GatewayConnectionStats) ProtoMessage() {}
func (*GatewayConnectionStats) Descriptor() ([]byte, []int) {
	return fileDescriptor_1df6bae1ac946b39, []int{21}
}
func (m *GatewayConnectionStats) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GatewayConnectionStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GatewayConnectionStats.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GatewayConnectionStats) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GatewayConnectionStats.Merge(m, src)
}
func (m *GatewayConnectionStats) XXX_Size() int {
	return m.Size()
}
func (m *GatewayConnectionStats) XXX_DiscardUnknown() {
	xxx_messageInfo_GatewayConnectionStats.DiscardUnknown(m)
}

var xxx_messageInfo_GatewayConnectionStats proto.InternalMessageInfo

func (m *GatewayConnectionStats) GetConnectedAt() *time.Time {
	if m != nil {
		return m.ConnectedAt
	}
	return nil
}

func (m *GatewayConnectionStats) GetProtocol() string {
	if m != nil {
		return m.Protocol
	}
	return ""
}

func (m *GatewayConnectionStats) GetLastStatusReceivedAt() *time.Time {
	if m != nil {
		return m.LastStatusReceivedAt
	}
	return nil
}

func (m *GatewayConnectionStats) GetLastStatus() *GatewayStatus {
	if m != nil {
		return m.LastStatus
	}
	return nil
}

func (m *GatewayConnectionStats) GetLastUplinkReceivedAt() *time.Time {
	if m != nil {
		return m.LastUplinkReceivedAt
	}
	return nil
}

func (m *GatewayConnectionStats) GetUplinkCount() uint64 {
	if m != nil {
		return m.UplinkCount
	}
	return 0
}

func (m *GatewayConnectionStats) GetLastDownlinkReceivedAt() *time.Time {
	if m != nil {
		return m.LastDownlinkReceivedAt
	}
	return nil
}

func (m *GatewayConnectionStats) GetDownlinkCount() uint64 {
	if m != nil {
		return m.DownlinkCount
	}
	return 0
}

func (m *GatewayConnectionStats) GetRoundTripTimes() *GatewayConnectionStats_RoundTripTimes {
	if m != nil {
		return m.RoundTripTimes
	}
	return nil
}

type GatewayConnectionStats_RoundTripTimes struct {
	Min                  time.Duration `protobuf:"bytes,1,opt,name=min,proto3,stdduration" json:"min"`
	Max                  time.Duration `protobuf:"bytes,2,opt,name=max,proto3,stdduration" json:"max"`
	Median               time.Duration `protobuf:"bytes,3,opt,name=median,proto3,stdduration" json:"median"`
	Count                uint32        `protobuf:"varint,4,opt,name=count,proto3" json:"count,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func (m *GatewayConnectionStats_RoundTripTimes) Reset()      { *m = GatewayConnectionStats_RoundTripTimes{} }
func (*GatewayConnectionStats_RoundTripTimes) ProtoMessage() {}
func (*GatewayConnectionStats_RoundTripTimes) Descriptor() ([]byte, []int) {
	return fileDescriptor_1df6bae1ac946b39, []int{21, 0}
}
func (m *GatewayConnectionStats_RoundTripTimes) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GatewayConnectionStats_RoundTripTimes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GatewayConnectionStats_RoundTripTimes.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GatewayConnectionStats_RoundTripTimes) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GatewayConnectionStats_RoundTripTimes.Merge(m, src)
}
func (m *GatewayConnectionStats_RoundTripTimes) XXX_Size() int {
	return m.Size()
}
func (m *GatewayConnectionStats_RoundTripTimes) XXX_DiscardUnknown() {
	xxx_messageInfo_GatewayConnectionStats_RoundTripTimes.DiscardUnknown(m)
}

var xxx_messageInfo_GatewayConnectionStats_RoundTripTimes proto.InternalMessageInfo

func (m *GatewayConnectionStats_RoundTripTimes) GetMin() time.Duration {
	if m != nil {
		return m.Min
	}
	return 0
}

func (m *GatewayConnectionStats_RoundTripTimes) GetMax() time.Duration {
	if m != nil {
		return m.Max
	}
	return 0
}

func (m *GatewayConnectionStats_RoundTripTimes) GetMedian() time.Duration {
	if m != nil {
		return m.Median
	}
	return 0
}

func (m *GatewayConnectionStats_RoundTripTimes) GetCount() uint32 {
	if m != nil {
		return m.Count
	}
	return 0
}

func init() {
	proto.RegisterType((*GatewayBrand)(nil), "ttn.lorawan.v3.GatewayBrand")
	golang_proto.RegisterType((*GatewayBrand)(nil), "ttn.lorawan.v3.GatewayBrand")
	proto.RegisterType((*GatewayModel)(nil), "ttn.lorawan.v3.GatewayModel")
	golang_proto.RegisterType((*GatewayModel)(nil), "ttn.lorawan.v3.GatewayModel")
	proto.RegisterType((*GatewayVersionIdentifiers)(nil), "ttn.lorawan.v3.GatewayVersionIdentifiers")
	golang_proto.RegisterType((*GatewayVersionIdentifiers)(nil), "ttn.lorawan.v3.GatewayVersionIdentifiers")
	proto.RegisterType((*GatewayRadio)(nil), "ttn.lorawan.v3.GatewayRadio")
	golang_proto.RegisterType((*GatewayRadio)(nil), "ttn.lorawan.v3.GatewayRadio")
	proto.RegisterType((*GatewayRadio_TxConfiguration)(nil), "ttn.lorawan.v3.GatewayRadio.TxConfiguration")
	golang_proto.RegisterType((*GatewayRadio_TxConfiguration)(nil), "ttn.lorawan.v3.GatewayRadio.TxConfiguration")
	proto.RegisterType((*GatewayVersion)(nil), "ttn.lorawan.v3.GatewayVersion")
	golang_proto.RegisterType((*GatewayVersion)(nil), "ttn.lorawan.v3.GatewayVersion")
	proto.RegisterType((*Gateway)(nil), "ttn.lorawan.v3.Gateway")
	golang_proto.RegisterType((*Gateway)(nil), "ttn.lorawan.v3.Gateway")
	proto.RegisterMapType((map[string]string)(nil), "ttn.lorawan.v3.Gateway.AttributesEntry")
	golang_proto.RegisterMapType((map[string]string)(nil), "ttn.lorawan.v3.Gateway.AttributesEntry")
	proto.RegisterType((*Gateways)(nil), "ttn.lorawan.v3.Gateways")
	golang_proto.RegisterType((*Gateways)(nil), "ttn.lorawan.v3.Gateways")
	proto.RegisterType((*GetGatewayRequest)(nil), "ttn.lorawan.v3.GetGatewayRequest")
	golang_proto.RegisterType((*GetGatewayRequest)(nil), "ttn.lorawan.v3.GetGatewayRequest")
	proto.RegisterType((*GetGatewayIdentifiersForEUIRequest)(nil), "ttn.lorawan.v3.GetGatewayIdentifiersForEUIRequest")
	golang_proto.RegisterType((*GetGatewayIdentifiersForEUIRequest)(nil), "ttn.lorawan.v3.GetGatewayIdentifiersForEUIRequest")
	proto.RegisterType((*ListGatewaysRequest)(nil), "ttn.lorawan.v3.ListGatewaysRequest")
	golang_proto.RegisterType((*ListGatewaysRequest)(nil), "ttn.lorawan.v3.ListGatewaysRequest")
	proto.RegisterType((*CreateGatewayRequest)(nil), "ttn.lorawan.v3.CreateGatewayRequest")
	golang_proto.RegisterType((*CreateGatewayRequest)(nil), "ttn.lorawan.v3.CreateGatewayRequest")
	proto.RegisterType((*UpdateGatewayRequest)(nil), "ttn.lorawan.v3.UpdateGatewayRequest")
	golang_proto.RegisterType((*UpdateGatewayRequest)(nil), "ttn.lorawan.v3.UpdateGatewayRequest")
	proto.RegisterType((*ListGatewayAPIKeysRequest)(nil), "ttn.lorawan.v3.ListGatewayAPIKeysRequest")
	golang_proto.RegisterType((*ListGatewayAPIKeysRequest)(nil), "ttn.lorawan.v3.ListGatewayAPIKeysRequest")
	proto.RegisterType((*GetGatewayAPIKeyRequest)(nil), "ttn.lorawan.v3.GetGatewayAPIKeyRequest")
	golang_proto.RegisterType((*GetGatewayAPIKeyRequest)(nil), "ttn.lorawan.v3.GetGatewayAPIKeyRequest")
	proto.RegisterType((*CreateGatewayAPIKeyRequest)(nil), "ttn.lorawan.v3.CreateGatewayAPIKeyRequest")
	golang_proto.RegisterType((*CreateGatewayAPIKeyRequest)(nil), "ttn.lorawan.v3.CreateGatewayAPIKeyRequest")
	proto.RegisterType((*UpdateGatewayAPIKeyRequest)(nil), "ttn.lorawan.v3.UpdateGatewayAPIKeyRequest")
	golang_proto.RegisterType((*UpdateGatewayAPIKeyRequest)(nil), "ttn.lorawan.v3.UpdateGatewayAPIKeyRequest")
	proto.RegisterType((*ListGatewayCollaboratorsRequest)(nil), "ttn.lorawan.v3.ListGatewayCollaboratorsRequest")
	golang_proto.RegisterType((*ListGatewayCollaboratorsRequest)(nil), "ttn.lorawan.v3.ListGatewayCollaboratorsRequest")
	proto.RegisterType((*GetGatewayCollaboratorRequest)(nil), "ttn.lorawan.v3.GetGatewayCollaboratorRequest")
	golang_proto.RegisterType((*GetGatewayCollaboratorRequest)(nil), "ttn.lorawan.v3.GetGatewayCollaboratorRequest")
	proto.RegisterType((*SetGatewayCollaboratorRequest)(nil), "ttn.lorawan.v3.SetGatewayCollaboratorRequest")
	golang_proto.RegisterType((*SetGatewayCollaboratorRequest)(nil), "ttn.lorawan.v3.SetGatewayCollaboratorRequest")
	proto.RegisterType((*GatewayAntenna)(nil), "ttn.lorawan.v3.GatewayAntenna")
	golang_proto.RegisterType((*GatewayAntenna)(nil), "ttn.lorawan.v3.GatewayAntenna")
	proto.RegisterMapType((map[string]string)(nil), "ttn.lorawan.v3.GatewayAntenna.AttributesEntry")
	golang_proto.RegisterMapType((map[string]string)(nil), "ttn.lorawan.v3.GatewayAntenna.AttributesEntry")
	proto.RegisterType((*GatewayStatus)(nil), "ttn.lorawan.v3.GatewayStatus")
	golang_proto.RegisterType((*GatewayStatus)(nil), "ttn.lorawan.v3.GatewayStatus")
	proto.RegisterMapType((map[string]float32)(nil), "ttn.lorawan.v3.GatewayStatus.MetricsEntry")
	golang_proto.RegisterMapType((map[string]float32)(nil), "ttn.lorawan.v3.GatewayStatus.MetricsEntry")
	proto.RegisterMapType((map[string]string)(nil), "ttn.lorawan.v3.GatewayStatus.VersionsEntry")
	golang_proto.RegisterMapType((map[string]string)(nil), "ttn.lorawan.v3.GatewayStatus.VersionsEntry")
	proto.RegisterType((*GatewayConnectionStats)(nil), "ttn.lorawan.v3.GatewayConnectionStats")
	golang_proto.RegisterType((*GatewayConnectionStats)(nil), "ttn.lorawan.v3.GatewayConnectionStats")
	proto.RegisterType((*GatewayConnectionStats_RoundTripTimes)(nil), "ttn.lorawan.v3.GatewayConnectionStats.RoundTripTimes")
	golang_proto.RegisterType((*GatewayConnectionStats_RoundTripTimes)(nil), "ttn.lorawan.v3.GatewayConnectionStats.RoundTripTimes")
}

func init() { proto.RegisterFile("lorawan-stack/api/gateway.proto", fileDescriptor_1df6bae1ac946b39) }
func init() {
	golang_proto.RegisterFile("lorawan-stack/api/gateway.proto", fileDescriptor_1df6bae1ac946b39)
}

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

func (this *GatewayBrand) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GatewayBrand)
	if !ok {
		that2, ok := that.(GatewayBrand)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ID != that1.ID {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.URL != that1.URL {
		return false
	}
	if len(this.Logos) != len(that1.Logos) {
		return false
	}
	for i := range this.Logos {
		if this.Logos[i] != that1.Logos[i] {
			return false
		}
	}
	return true
}
func (this *GatewayModel) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GatewayModel)
	if !ok {
		that2, ok := that.(GatewayModel)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.BrandID != that1.BrandID {
		return false
	}
	if this.ID != that1.ID {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	return true
}
func (this *GatewayVersionIdentifiers) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GatewayVersionIdentifiers)
	if !ok {
		that2, ok := that.(GatewayVersionIdentifiers)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.BrandID != that1.BrandID {
		return false
	}
	if this.ModelID != that1.ModelID {
		return false
	}
	if this.HardwareVersion != that1.HardwareVersion {
		return false
	}
	if this.FirmwareVersion != that1.FirmwareVersion {
		return false
	}
	return true
}
func (this *GatewayRadio) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GatewayRadio)
	if !ok {
		that2, ok := that.(GatewayRadio)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Enable != that1.Enable {
		return false
	}
	if this.ChipType != that1.ChipType {
		return false
	}
	if this.Frequency != that1.Frequency {
		return false
	}
	if this.RSSIOffset != that1.RSSIOffset {
		return false
	}
	if !this.TxConfiguration.Equal(that1.TxConfiguration) {
		return false
	}
	return true
}
func (this *GatewayRadio_TxConfiguration) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GatewayRadio_TxConfiguration)
	if !ok {
		that2, ok := that.(GatewayRadio_TxConfiguration)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.MinFrequency != that1.MinFrequency {
		return false
	}
	if this.MaxFrequency != that1.MaxFrequency {
		return false
	}
	if this.NotchFrequency != that1.NotchFrequency {
		return false
	}
	return true
}
func (this *GatewayVersion) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GatewayVersion)
	if !ok {
		that2, ok := that.(GatewayVersion)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.GatewayVersionIdentifiers.Equal(&that1.GatewayVersionIdentifiers) {
		return false
	}
	if len(this.Photos) != len(that1.Photos) {
		return false
	}
	for i := range this.Photos {
		if this.Photos[i] != that1.Photos[i] {
			return false
		}
	}
	if len(this.Radios) != len(that1.Radios) {
		return false
	}
	for i := range this.Radios {
		if !this.Radios[i].Equal(that1.Radios[i]) {
			return false
		}
	}
	if this.ClockSource != that1.ClockSource {
		return false
	}
	return true
}
func (this *Gateway) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Gateway)
	if !ok {
		that2, ok := that.(Gateway)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.GatewayIdentifiers.Equal(&that1.GatewayIdentifiers) {
		return false
	}
	if !this.CreatedAt.Equal(that1.CreatedAt) {
		return false
	}
	if !this.UpdatedAt.Equal(that1.UpdatedAt) {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.Description != that1.Description {
		return false
	}
	if len(this.Attributes) != len(that1.Attributes) {
		return false
	}
	for i := range this.Attributes {
		if this.Attributes[i] != that1.Attributes[i] {
			return false
		}
	}
	if len(this.ContactInfo) != len(that1.ContactInfo) {
		return false
	}
	for i := range this.ContactInfo {
		if !this.ContactInfo[i].Equal(that1.ContactInfo[i]) {
			return false
		}
	}
	if !this.GatewayVersionIdentifiers.Equal(&that1.GatewayVersionIdentifiers) {
		return false
	}
	if this.GatewayServerAddress != that1.GatewayServerAddress {
		return false
	}
	if this.AutoUpdate != that1.AutoUpdate {
		return false
	}
	if this.UpdateChannel != that1.UpdateChannel {
		return false
	}
	if this.FrequencyPlanID != that1.FrequencyPlanID {
		return false
	}
	if len(this.FrequencyPlanIDs) != len(that1.FrequencyPlanIDs) {
		return false
	}
	for i := range this.FrequencyPlanIDs {
		if this.FrequencyPlanIDs[i] != that1.FrequencyPlanIDs[i] {
			return false
		}
	}
	if len(this.Antennas) != len(that1.Antennas) {
		return false
	}
	for i := range this.Antennas {
		if !this.Antennas[i].Equal(&that1.Antennas[i]) {
			return false
		}
	}
	if this.StatusPublic != that1.StatusPublic {
		return false
	}
	if this.LocationPublic != that1.LocationPublic {
		return false
	}
	if this.ScheduleDownlinkLate != that1.ScheduleDownlinkLate {
		return false
	}
	if this.EnforceDutyCycle != that1.EnforceDutyCycle {
		return false
	}
	if this.DownlinkPathConstraint != that1.DownlinkPathConstraint {
		return false
	}
	if this.ScheduleAnytimeDelay != nil && that1.ScheduleAnytimeDelay != nil {
		if *this.ScheduleAnytimeDelay != *that1.ScheduleAnytimeDelay {
			return false
		}
	} else if this.ScheduleAnytimeDelay != nil {
		return false
	} else if that1.ScheduleAnytimeDelay != nil {
		return false
	}
	if this.UpdateLocationFromStatus != that1.UpdateLocationFromStatus {
		return false
	}
	return true
}
func (this *Gateways) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Gateways)
	if !ok {
		that2, ok := that.(Gateways)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Gateways) != len(that1.Gateways) {
		return false
	}
	for i := range this.Gateways {
		if !this.Gateways[i].Equal(that1.Gateways[i]) {
			return false
		}
	}
	return true
}
func (this *GetGatewayRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GetGatewayRequest)
	if !ok {
		that2, ok := that.(GetGatewayRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.GatewayIdentifiers.Equal(&that1.GatewayIdentifiers) {
		return false
	}
	if !this.FieldMask.Equal(&that1.FieldMask) {
		return false
	}
	return true
}
func (this *GetGatewayIdentifiersForEUIRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

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

	that1, ok := that.(*ListGatewaysRequest)
	if !ok {
		that2, ok := that.(ListGatewaysRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Collaborator.Equal(that1.Collaborator) {
		return false
	}
	if !this.FieldMask.Equal(&that1.FieldMask) {
		return false
	}
	if this.Order != that1.Order {
		return false
	}
	if this.Limit != that1.Limit {
		return false
	}
	if this.Page != that1.Page {
		return false
	}
	return true
}
func (this *CreateGatewayRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*CreateGatewayRequest)
	if !ok {
		that2, ok := that.(CreateGatewayRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Gateway.Equal(&that1.Gateway) {
		return false
	}
	if !this.Collaborator.Equal(&that1.Collaborator) {
		return false
	}
	return true
}
func (this *UpdateGatewayRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*UpdateGatewayRequest)
	if !ok {
		that2, ok := that.(UpdateGatewayRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Gateway.Equal(&that1.Gateway) {
		return false
	}
	if !this.FieldMask.Equal(&that1.FieldMask) {
		return false
	}
	return true
}
func (this *ListGatewayAPIKeysRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ListGatewayAPIKeysRequest)
	if !ok {
		that2, ok := that.(ListGatewayAPIKeysRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.GatewayIdentifiers.Equal(&that1.GatewayIdentifiers) {
		return false
	}
	if this.Limit != that1.Limit {
		return false
	}
	if this.Page != that1.Page {
		return false
	}
	return true
}
func (this *GetGatewayAPIKeyRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GetGatewayAPIKeyRequest)
	if !ok {
		that2, ok := that.(GetGatewayAPIKeyRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.GatewayIdentifiers.Equal(&that1.GatewayIdentifiers) {
		return false
	}
	if this.KeyID != that1.KeyID {
		return false
	}
	return true
}
func (this *CreateGatewayAPIKeyRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*CreateGatewayAPIKeyRequest)
	if !ok {
		that2, ok := that.(CreateGatewayAPIKeyRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.GatewayIdentifiers.Equal(&that1.GatewayIdentifiers) {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if len(this.Rights) != len(that1.Rights) {
		return false
	}
	for i := range this.Rights {
		if this.Rights[i] != that1.Rights[i] {
			return false
		}
	}
	return true
}
func (this *UpdateGatewayAPIKeyRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*UpdateGatewayAPIKeyRequest)
	if !ok {
		that2, ok := that.(UpdateGatewayAPIKeyRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.GatewayIdentifiers.Equal(&that1.GatewayIdentifiers) {
		return false
	}
	if !this.APIKey.Equal(&that1.APIKey) {
		return false
	}
	return true
}
func (this *ListGatewayCollaboratorsRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ListGatewayCollaboratorsRequest)
	if !ok {
		that2, ok := that.(ListGatewayCollaboratorsRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.GatewayIdentifiers.Equal(&that1.GatewayIdentifiers) {
		return false
	}
	if this.Limit != that1.Limit {
		return false
	}
	if this.Page != that1.Page {
		return false
	}
	return true
}
func (this *GetGatewayCollaboratorRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GetGatewayCollaboratorRequest)
	if !ok {
		that2, ok := that.(GetGatewayCollaboratorRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.GatewayIdentifiers.Equal(&that1.GatewayIdentifiers) {
		return false
	}
	if !this.OrganizationOrUserIdentifiers.Equal(&that1.OrganizationOrUserIdentifiers) {
		return false
	}
	return true
}
func (this *SetGatewayCollaboratorRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*SetGatewayCollaboratorRequest)
	if !ok {
		that2, ok := that.(SetGatewayCollaboratorRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.GatewayIdentifiers.Equal(&that1.GatewayIdentifiers) {
		return false
	}
	if !this.Collaborator.Equal(&that1.Collaborator) {
		return false
	}
	return true
}
func (this *GatewayAntenna) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GatewayAntenna)
	if !ok {
		that2, ok := that.(GatewayAntenna)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Gain != that1.Gain {
		return false
	}
	if !this.Location.Equal(&that1.Location) {
		return false
	}
	if len(this.Attributes) != len(that1.Attributes) {
		return false
	}
	for i := range this.Attributes {
		if this.Attributes[i] != that1.Attributes[i] {
			return false
		}
	}
	return true
}
func (this *GatewayStatus) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GatewayStatus)
	if !ok {
		that2, ok := that.(GatewayStatus)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Time.Equal(that1.Time) {
		return false
	}
	if !this.BootTime.Equal(that1.BootTime) {
		return false
	}
	if len(this.Versions) != len(that1.Versions) {
		return false
	}
	for i := range this.Versions {
		if this.Versions[i] != that1.Versions[i] {
			return false
		}
	}
	if len(this.AntennaLocations) != len(that1.AntennaLocations) {
		return false
	}
	for i := range this.AntennaLocations {
		if !this.AntennaLocations[i].Equal(that1.AntennaLocations[i]) {
			return false
		}
	}
	if len(this.IP) != len(that1.IP) {
		return false
	}
	for i := range this.IP {
		if this.IP[i] != that1.IP[i] {
			return false
		}
	}
	if len(this.Metrics) != len(that1.Metrics) {
		return false
	}
	for i := range this.Metrics {
		if this.Metrics[i] != that1.Metrics[i] {
			return false
		}
	}
	if !this.Advanced.Equal(that1.Advanced) {
		return false
	}
	return true
}
func (this *GatewayConnectionStats) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GatewayConnectionStats)
	if !ok {
		that2, ok := that.(GatewayConnectionStats)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if that1.ConnectedAt == nil {
		if this.ConnectedAt != nil {
			return false
		}
	} else if !this.ConnectedAt.Equal(*that1.ConnectedAt) {
		return false
	}
	if this.Protocol != that1.Protocol {
		return false
	}
	if that1.LastStatusReceivedAt == nil {
		if this.LastStatusReceivedAt != nil {
			return false
		}
	} else if !this.LastStatusReceivedAt.Equal(*that1.LastStatusReceivedAt) {
		return false
	}
	if !this.LastStatus.Equal(that1.LastStatus) {
		return false
	}
	if that1.LastUplinkReceivedAt == nil {
		if this.LastUplinkReceivedAt != nil {
			return false
		}
	} else if !this.LastUplinkReceivedAt.Equal(*that1.LastUplinkReceivedAt) {
		return false
	}
	if this.UplinkCount != that1.UplinkCount {
		return false
	}
	if that1.LastDownlinkReceivedAt == nil {
		if this.LastDownlinkReceivedAt != nil {
			return false
		}
	} else if !this.LastDownlinkReceivedAt.Equal(*that1.LastDownlinkReceivedAt) {
		return false
	}
	if this.DownlinkCount != that1.DownlinkCount {
		return false
	}
	if !this.RoundTripTimes.Equal(that1.RoundTripTimes) {
		return false
	}
	return true
}
func (this *GatewayConnectionStats_RoundTripTimes) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GatewayConnectionStats_RoundTripTimes)
	if !ok {
		that2, ok := that.(GatewayConnectionStats_RoundTripTimes)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Min != that1.Min {
		return false
	}
	if this.Max != that1.Max {
		return false
	}
	if this.Median != that1.Median {
		return false
	}
	if this.Count != that1.Count {
		return false
	}
	return true
}
func (m *GatewayBrand) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GatewayBrand) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GatewayBrand) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Logos) > 0 {
		for iNdEx := len(m.Logos) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Logos[iNdEx])
			copy(dAtA[i:], m.Logos[iNdEx])
			i = encodeVarintGateway(dAtA, i, uint64(len(m.Logos[iNdEx])))
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.URL) > 0 {
		i -= len(m.URL)
		copy(dAtA[i:], m.URL)
		i = encodeVarintGateway(dAtA, i, uint64(len(m.URL)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintGateway(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ID) > 0 {
		i -= len(m.ID)
		copy(dAtA[i:], m.ID)
		i = encodeVarintGateway(dAtA, i, uint64(len(m.ID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *GatewayModel) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GatewayModel) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintGateway(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.ID) > 0 {
		i -= len(m.ID)
		copy(dAtA[i:], m.ID)
		i = encodeVarintGateway(dAtA, i, uint64(len(m.ID)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.BrandID) > 0 {
		i -= len(m.BrandID)
		copy(dAtA[i:], m.BrandID)
		i = encodeVarintGateway(dAtA, i, uint64(len(m.BrandID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *GatewayVersionIdentifiers) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GatewayVersionIdentifiers) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.FirmwareVersion) > 0 {
		i -= len(m.FirmwareVersion)
		copy(dAtA[i:], m.FirmwareVersion)
		i = encodeVarintGateway(dAtA, i, uint64(len(m.FirmwareVersion)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.HardwareVersion) > 0 {
		i -= len(m.HardwareVersion)
		copy(dAtA[i:], m.HardwareVersion)
		i = encodeVarintGateway(dAtA, i, uint64(len(m.HardwareVersion)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.ModelID) > 0 {
		i -= len(m.ModelID)
		copy(dAtA[i:], m.ModelID)
		i = encodeVarintGateway(dAtA, i, uint64(len(m.ModelID)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.BrandID) > 0 {
		i -= len(m.BrandID)
		copy(dAtA[i:], m.BrandID)
		i = encodeVarintGateway(dAtA, i, uint64(len(m.BrandID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *GatewayRadio) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GatewayRadio) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TxConfiguration != nil {
		{
			size, err := m.TxConfiguration.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGateway(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.RSSIOffset != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], math.Float32bits(float32(m.RSSIOffset)))
		i--
		dAtA[i] = 0x25
	}
	if m.Frequency != 0 {
		i = encodeVarintGateway(dAtA, i, m.Frequency)
		i--
		dAtA[i] = 0x18
	}
	if len(m.ChipType) > 0 {
		i -= len(m.ChipType)
		copy(dAtA[i:], m.ChipType)
		i = encodeVarintGateway(dAtA, i, uint64(len(m.ChipType)))
		i--
		dAtA[i] = 0x12
	}
	if m.Enable {
		i--
		if m.Enable {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *GatewayRadio_TxConfiguration) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GatewayRadio_TxConfiguration) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.NotchFrequency != 0 {
		i = encodeVarintGateway(dAtA, i, m.NotchFrequency)
		i--
		dAtA[i] = 0x18
	}
	if m.MaxFrequency != 0 {
		i = encodeVarintGateway(dAtA, i, m.MaxFrequency)
		i--
		dAtA[i] = 0x10
	}
	if m.MinFrequency != 0 {
		i = encodeVarintGateway(dAtA, i, m.MinFrequency)
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *GatewayVersion) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GatewayVersion) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ClockSource != 0 {
		i = encodeVarintGateway(dAtA, i, uint64(m.ClockSource))
		i--
		dAtA[i] = 0x38
	}
	if len(m.Radios) > 0 {
		for iNdEx := len(m.Radios) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Radios[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGateway(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Photos) > 0 {
		for iNdEx := len(m.Photos) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Photos[iNdEx])
			copy(dAtA[i:], m.Photos[iNdEx])
			i = encodeVarintGateway(dAtA, i, uint64(len(m.Photos[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	{
		size, err := m.GatewayVersionIdentifiers.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGateway(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *Gateway) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Gateway) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.UpdateLocationFromStatus {
		i--
		if m.UpdateLocationFromStatus {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xa8
	}
	if len(m.FrequencyPlanIDs) > 0 {
		for iNdEx := len(m.FrequencyPlanIDs) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.FrequencyPlanIDs[iNdEx])
			copy(dAtA[i:], m.FrequencyPlanIDs[iNdEx])
			i = encodeVarintGateway(dAtA, i, uint64(len(m.FrequencyPlanIDs[iNdEx])))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xa2
		}
	}
	if m.ScheduleAnytimeDelay != nil {
		n3, err3 := github_com_gogo_protobuf_types.StdDurationMarshalTo(*m.ScheduleAnytimeDelay, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(*m.ScheduleAnytimeDelay):])
		if err3 != nil {
			return 0, err3
		}
		i -= n3
		i = encodeVarintGateway(dAtA, i, uint64(n3))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x9a
	}
	if m.DownlinkPathConstraint != 0 {
		i = encodeVarintGateway(dAtA, i, uint64(m.DownlinkPathConstraint))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x90
	}
	if m.EnforceDutyCycle {
		i--
		if m.EnforceDutyCycle {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x88
	}
	if m.ScheduleDownlinkLate {
		i--
		if m.ScheduleDownlinkLate {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x80
	}
	if m.LocationPublic {
		i--
		if m.LocationPublic {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x78
	}
	if m.StatusPublic {
		i--
		if m.StatusPublic {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x70
	}
	if len(m.Antennas) > 0 {
		for iNdEx := len(m.Antennas) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Antennas[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGateway(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x6a
		}
	}
	if len(m.FrequencyPlanID) > 0 {
		i -= len(m.FrequencyPlanID)
		copy(dAtA[i:], m.FrequencyPlanID)
		i = encodeVarintGateway(dAtA, i, uint64(len(m.FrequencyPlanID)))
		i--
		dAtA[i] = 0x62
	}
	if len(m.UpdateChannel) > 0 {
		i -= len(m.UpdateChannel)
		copy(dAtA[i:], m.UpdateChannel)
		i = encodeVarintGateway(dAtA, i, uint64(len(m.UpdateChannel)))
		i--
		dAtA[i] = 0x5a
	}
	if m.AutoUpdate {
		i--
		if m.AutoUpdate {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x50
	}
	if len(m.GatewayServerAddress) > 0 {
		i -= len(m.GatewayServerAddress)
		copy(dAtA[i:], m.GatewayServerAddress)
		i = encodeVarintGateway(dAtA, i, uint64(len(m.GatewayServerAddress)))
		i--
		dAtA[i] = 0x4a
	}
	{
		size, err := m.GatewayVersionIdentifiers.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGateway(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x42
	if len(m.ContactInfo) > 0 {
		for iNdEx := len(m.ContactInfo) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ContactInfo[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGateway(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3a
		}
	}
	if len(m.Attributes) > 0 {
		for k := range m.Attributes {
			v := m.Attributes[k]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintGateway(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintGateway(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintGateway(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x32
		}
	}
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintGateway(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintGateway(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x22
	}
	n5, err5 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.UpdatedAt, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdatedAt):])
	if err5 != nil {
		return 0, err5
	}
	i -= n5
	i = encodeVarintGateway(dAtA, i, uint64(n5))
	i--
	dAtA[i] = 0x1a
	n6, err6 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.CreatedAt, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.CreatedAt):])
	if err6 != nil {
		return 0, err6
	}
	i -= n6
	i = encodeVarintGateway(dAtA, i, uint64(n6))
	i--
	dAtA[i] = 0x12
	{
		size, err := m.GatewayIdentifiers.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGateway(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *Gateways) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Gateways) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Gateways) > 0 {
		for iNdEx := len(m.Gateways) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Gateways[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGateway(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *GetGatewayRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetGatewayRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.FieldMask.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGateway(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.GatewayIdentifiers.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGateway(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *GetGatewayIdentifiersForEUIRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetGatewayIdentifiersForEUIRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.EUI.Size()
		i -= size
		if _, err := m.EUI.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintGateway(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *ListGatewaysRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ListGatewaysRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Page != 0 {
		i = encodeVarintGateway(dAtA, i, uint64(m.Page))
		i--
		dAtA[i] = 0x28
	}
	if m.Limit != 0 {
		i = encodeVarintGateway(dAtA, i, uint64(m.Limit))
		i--
		dAtA[i] = 0x20
	}
	if len(m.Order) > 0 {
		i -= len(m.Order)
		copy(dAtA[i:], m.Order)
		i = encodeVarintGateway(dAtA, i, uint64(len(m.Order)))
		i--
		dAtA[i] = 0x1a
	}
	{
		size, err := m.FieldMask.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGateway(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.Collaborator != nil {
		{
			size, err := m.Collaborator.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGateway(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *CreateGatewayRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CreateGatewayRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Collaborator.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGateway(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.Gateway.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGateway(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *UpdateGatewayRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *UpdateGatewayRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.FieldMask.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGateway(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.Gateway.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGateway(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *ListGatewayAPIKeysRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ListGatewayAPIKeysRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Page != 0 {
		i = encodeVarintGateway(dAtA, i, uint64(m.Page))
		i--
		dAtA[i] = 0x18
	}
	if m.Limit != 0 {
		i = encodeVarintGateway(dAtA, i, uint64(m.Limit))
		i--
		dAtA[i] = 0x10
	}
	{
		size, err := m.GatewayIdentifiers.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGateway(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *GetGatewayAPIKeyRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetGatewayAPIKeyRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.KeyID) > 0 {
		i -= len(m.KeyID)
		copy(dAtA[i:], m.KeyID)
		i = encodeVarintGateway(dAtA, i, uint64(len(m.KeyID)))
		i--
		dAtA[i] = 0x12
	}
	{
		size, err := m.GatewayIdentifiers.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGateway(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *CreateGatewayAPIKeyRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CreateGatewayAPIKeyRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Rights) > 0 {
		dAtA19 := make([]byte, len(m.Rights)*10)
		var j18 int
		for _, num := range m.Rights {
			for num >= 1<<7 {
				dAtA19[j18] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j18++
			}
			dAtA19[j18] = uint8(num)
			j18++
		}
		i -= j18
		copy(dAtA[i:], dAtA19[:j18])
		i = encodeVarintGateway(dAtA, i, uint64(j18))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintGateway(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	{
		size, err := m.GatewayIdentifiers.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGateway(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *UpdateGatewayAPIKeyRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *UpdateGatewayAPIKeyRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.APIKey.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGateway(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.GatewayIdentifiers.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGateway(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *ListGatewayCollaboratorsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ListGatewayCollaboratorsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Page != 0 {
		i = encodeVarintGateway(dAtA, i, uint64(m.Page))
		i--
		dAtA[i] = 0x18
	}
	if m.Limit != 0 {
		i = encodeVarintGateway(dAtA, i, uint64(m.Limit))
		i--
		dAtA[i] = 0x10
	}
	{
		size, err := m.GatewayIdentifiers.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGateway(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *GetGatewayCollaboratorRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetGatewayCollaboratorRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.OrganizationOrUserIdentifiers.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGateway(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.GatewayIdentifiers.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGateway(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *SetGatewayCollaboratorRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SetGatewayCollaboratorRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Collaborator.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGateway(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.GatewayIdentifiers.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGateway(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *GatewayAntenna) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GatewayAntenna) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Attributes) > 0 {
		for k := range m.Attributes {
			v := m.Attributes[k]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintGateway(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintGateway(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintGateway(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1a
		}
	}
	{
		size, err := m.Location.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGateway(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.Gain != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], math.Float32bits(float32(m.Gain)))
		i--
		dAtA[i] = 0xd
	}
	return len(dAtA) - i, nil
}

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

func (m *GatewayStatus) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GatewayStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Advanced != nil {
		{
			size, err := m.Advanced.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGateway(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x6
		i--
		dAtA[i] = 0x9a
	}
	if len(m.Metrics) > 0 {
		for k := range m.Metrics {
			v := m.Metrics[k]
			baseI := i
			i -= 4
			encoding_binary.LittleEndian.PutUint32(dAtA[i:], math.Float32bits(float32(v)))
			i--
			dAtA[i] = 0x15
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintGateway(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintGateway(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x32
		}
	}
	if len(m.IP) > 0 {
		for iNdEx := len(m.IP) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.IP[iNdEx])
			copy(dAtA[i:], m.IP[iNdEx])
			i = encodeVarintGateway(dAtA, i, uint64(len(m.IP[iNdEx])))
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.AntennaLocations) > 0 {
		for iNdEx := len(m.AntennaLocations) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.AntennaLocations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGateway(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.Versions) > 0 {
		for k := range m.Versions {
			v := m.Versions[k]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintGateway(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintGateway(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintGateway(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1a
		}
	}
	n30, err30 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.BootTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.BootTime):])
	if err30 != nil {
		return 0, err30
	}
	i -= n30
	i = encodeVarintGateway(dAtA, i, uint64(n30))
	i--
	dAtA[i] = 0x12
	n31, err31 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Time, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Time):])
	if err31 != nil {
		return 0, err31
	}
	i -= n31
	i = encodeVarintGateway(dAtA, i, uint64(n31))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *GatewayConnectionStats) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GatewayConnectionStats) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.RoundTripTimes != nil {
		{
			size, err := m.RoundTripTimes.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGateway(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	if m.DownlinkCount != 0 {
		i = encodeVarintGateway(dAtA, i, m.DownlinkCount)
		i--
		dAtA[i] = 0x40
	}
	if m.LastDownlinkReceivedAt != nil {
		n33, err33 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.LastDownlinkReceivedAt, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.LastDownlinkReceivedAt):])
		if err33 != nil {
			return 0, err33
		}
		i -= n33
		i = encodeVarintGateway(dAtA, i, uint64(n33))
		i--
		dAtA[i] = 0x3a
	}
	if m.UplinkCount != 0 {
		i = encodeVarintGateway(dAtA, i, m.UplinkCount)
		i--
		dAtA[i] = 0x30
	}
	if m.LastUplinkReceivedAt != nil {
		n34, err34 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.LastUplinkReceivedAt, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.LastUplinkReceivedAt):])
		if err34 != nil {
			return 0, err34
		}
		i -= n34
		i = encodeVarintGateway(dAtA, i, uint64(n34))
		i--
		dAtA[i] = 0x2a
	}
	if m.LastStatus != nil {
		{
			size, err := m.LastStatus.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGateway(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.LastStatusReceivedAt != nil {
		n36, err36 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.LastStatusReceivedAt, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.LastStatusReceivedAt):])
		if err36 != nil {
			return 0, err36
		}
		i -= n36
		i = encodeVarintGateway(dAtA, i, uint64(n36))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Protocol) > 0 {
		i -= len(m.Protocol)
		copy(dAtA[i:], m.Protocol)
		i = encodeVarintGateway(dAtA, i, uint64(len(m.Protocol)))
		i--
		dAtA[i] = 0x12
	}
	if m.ConnectedAt != nil {
		n37, err37 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.ConnectedAt, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.ConnectedAt):])
		if err37 != nil {
			return 0, err37
		}
		i -= n37
		i = encodeVarintGateway(dAtA, i, uint64(n37))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *GatewayConnectionStats_RoundTripTimes) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GatewayConnectionStats_RoundTripTimes) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Count != 0 {
		i = encodeVarintGateway(dAtA, i, uint64(m.Count))
		i--
		dAtA[i] = 0x20
	}
	n38, err38 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.Median, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.Median):])
	if err38 != nil {
		return 0, err38
	}
	i -= n38
	i = encodeVarintGateway(dAtA, i, uint64(n38))
	i--
	dAtA[i] = 0x1a
	n39, err39 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.Max, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.Max):])
	if err39 != nil {
		return 0, err39
	}
	i -= n39
	i = encodeVarintGateway(dAtA, i, uint64(n39))
	i--
	dAtA[i] = 0x12
	n40, err40 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.Min, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.Min):])
	if err40 != nil {
		return 0, err40
	}
	i -= n40
	i = encodeVarintGateway(dAtA, i, uint64(n40))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func encodeVarintGateway(dAtA []byte, offset int, v uint64) int {
	offset -= sovGateway(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func NewPopulatedGatewayBrand(r randyGateway, easy bool) *GatewayBrand {
	this := &GatewayBrand{}
	this.ID = randStringGateway(r)
	this.Name = randStringGateway(r)
	this.URL = randStringGateway(r)
	v1 := r.Intn(10)
	this.Logos = make([]string, v1)
	for i := 0; i < v1; i++ {
		this.Logos[i] = randStringGateway(r)
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedGatewayModel(r randyGateway, easy bool) *GatewayModel {
	this := &GatewayModel{}
	this.BrandID = randStringGateway(r)
	this.ID = randStringGateway(r)
	this.Name = randStringGateway(r)
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedGatewayVersionIdentifiers(r randyGateway, easy bool) *GatewayVersionIdentifiers {
	this := &GatewayVersionIdentifiers{}
	this.BrandID = randStringGateway(r)
	this.ModelID = randStringGateway(r)
	this.HardwareVersion = randStringGateway(r)
	this.FirmwareVersion = randStringGateway(r)
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedGatewayRadio(r randyGateway, easy bool) *GatewayRadio {
	this := &GatewayRadio{}
	this.Enable = bool(r.Intn(2) == 0)
	this.ChipType = randStringGateway(r)
	this.Frequency = uint64(r.Uint32())
	this.RSSIOffset = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.RSSIOffset *= -1
	}
	if r.Intn(5) != 0 {
		this.TxConfiguration = NewPopulatedGatewayRadio_TxConfiguration(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedGatewayRadio_TxConfiguration(r randyGateway, easy bool) *GatewayRadio_TxConfiguration {
	this := &GatewayRadio_TxConfiguration{}
	this.MinFrequency = uint64(r.Uint32())
	this.MaxFrequency = uint64(r.Uint32())
	this.NotchFrequency = uint64(r.Uint32())
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedGateway(r randyGateway, easy bool) *Gateway {
	this := &Gateway{}
	v2 := NewPopulatedGatewayIdentifiers(r, easy)
	this.GatewayIdentifiers = *v2
	v3 := github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy)
	this.CreatedAt = *v3
	v4 := github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy)
	this.UpdatedAt = *v4
	this.Name = randStringGateway(r)
	this.Description = randStringGateway(r)
	if r.Intn(5) != 0 {
		v5 := r.Intn(10)
		this.Attributes = make(map[string]string)
		for i := 0; i < v5; i++ {
			this.Attributes[randStringGateway(r)] = randStringGateway(r)
		}
	}
	if r.Intn(5) != 0 {
		v6 := r.Intn(5)
		this.ContactInfo = make([]*ContactInfo, v6)
		for i := 0; i < v6; i++ {
			this.ContactInfo[i] = NewPopulatedContactInfo(r, easy)
		}
	}
	v7 := NewPopulatedGatewayVersionIdentifiers(r, easy)
	this.GatewayVersionIdentifiers = *v7
	this.GatewayServerAddress = randStringGateway(r)
	this.AutoUpdate = bool(r.Intn(2) == 0)
	this.UpdateChannel = randStringGateway(r)
	this.FrequencyPlanID = randStringGateway(r)
	if r.Intn(5) != 0 {
		v8 := r.Intn(5)
		this.Antennas = make([]GatewayAntenna, v8)
		for i := 0; i < v8; i++ {
			v9 := NewPopulatedGatewayAntenna(r, easy)
			this.Antennas[i] = *v9
		}
	}
	this.StatusPublic = bool(r.Intn(2) == 0)
	this.LocationPublic = bool(r.Intn(2) == 0)
	this.ScheduleDownlinkLate = bool(r.Intn(2) == 0)
	this.EnforceDutyCycle = bool(r.Intn(2) == 0)
	this.DownlinkPathConstraint = DownlinkPathConstraint([]int32{0, 1, 2}[r.Intn(3)])
	if r.Intn(5) != 0 {
		this.ScheduleAnytimeDelay = github_com_gogo_protobuf_types.NewPopulatedStdDuration(r, easy)
	}
	v10 := r.Intn(10)
	this.FrequencyPlanIDs = make([]string, v10)
	for i := 0; i < v10; i++ {
		this.FrequencyPlanIDs[i] = randStringGateway(r)
	}
	this.UpdateLocationFromStatus = bool(r.Intn(2) == 0)
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedGateways(r randyGateway, easy bool) *Gateways {
	this := &Gateways{}
	if r.Intn(5) != 0 {
		v11 := r.Intn(5)
		this.Gateways = make([]*Gateway, v11)
		for i := 0; i < v11; i++ {
			this.Gateways[i] = NewPopulatedGateway(r, easy)
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedGetGatewayRequest(r randyGateway, easy bool) *GetGatewayRequest {
	this := &GetGatewayRequest{}
	v12 := NewPopulatedGatewayIdentifiers(r, easy)
	this.GatewayIdentifiers = *v12
	v13 := types.NewPopulatedFieldMask(r, easy)
	this.FieldMask = *v13
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedGetGatewayIdentifiersForEUIRequest(r randyGateway, easy bool) *GetGatewayIdentifiersForEUIRequest {
	this := &GetGatewayIdentifiersForEUIRequest{}
	v14 := go_thethings_network_lorawan_stack_v3_pkg_types.NewPopulatedEUI64(r)
	this.EUI = *v14
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedListGatewaysRequest(r randyGateway, easy bool) *ListGatewaysRequest {
	this := &ListGatewaysRequest{}
	if r.Intn(5) != 0 {
		this.Collaborator = NewPopulatedOrganizationOrUserIdentifiers(r, easy)
	}
	v15 := types.NewPopulatedFieldMask(r, easy)
	this.FieldMask = *v15
	this.Order = randStringGateway(r)
	this.Limit = r.Uint32()
	this.Page = r.Uint32()
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedCreateGatewayRequest(r randyGateway, easy bool) *CreateGatewayRequest {
	this := &CreateGatewayRequest{}
	v16 := NewPopulatedGateway(r, easy)
	this.Gateway = *v16
	v17 := NewPopulatedOrganizationOrUserIdentifiers(r, easy)
	this.Collaborator = *v17
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedUpdateGatewayRequest(r randyGateway, easy bool) *UpdateGatewayRequest {
	this := &UpdateGatewayRequest{}
	v18 := NewPopulatedGateway(r, easy)
	this.Gateway = *v18
	v19 := types.NewPopulatedFieldMask(r, easy)
	this.FieldMask = *v19
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedListGatewayAPIKeysRequest(r randyGateway, easy bool) *ListGatewayAPIKeysRequest {
	this := &ListGatewayAPIKeysRequest{}
	v20 := NewPopulatedGatewayIdentifiers(r, easy)
	this.GatewayIdentifiers = *v20
	this.Limit = r.Uint32()
	this.Page = r.Uint32()
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedGetGatewayAPIKeyRequest(r randyGateway, easy bool) *GetGatewayAPIKeyRequest {
	this := &GetGatewayAPIKeyRequest{}
	v21 := NewPopulatedGatewayIdentifiers(r, easy)
	this.GatewayIdentifiers = *v21
	this.KeyID = randStringGateway(r)
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedCreateGatewayAPIKeyRequest(r randyGateway, easy bool) *CreateGatewayAPIKeyRequest {
	this := &CreateGatewayAPIKeyRequest{}
	v22 := NewPopulatedGatewayIdentifiers(r, easy)
	this.GatewayIdentifiers = *v22
	this.Name = randStringGateway(r)
	v23 := r.Intn(10)
	this.Rights = make([]Right, v23)
	for i := 0; i < v23; i++ {
		this.Rights[i] = Right([]int32{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 56, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55}[r.Intn(57)])
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedUpdateGatewayAPIKeyRequest(r randyGateway, easy bool) *UpdateGatewayAPIKeyRequest {
	this := &UpdateGatewayAPIKeyRequest{}
	v24 := NewPopulatedGatewayIdentifiers(r, easy)
	this.GatewayIdentifiers = *v24
	v25 := NewPopulatedAPIKey(r, easy)
	this.APIKey = *v25
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedListGatewayCollaboratorsRequest(r randyGateway, easy bool) *ListGatewayCollaboratorsRequest {
	this := &ListGatewayCollaboratorsRequest{}
	v26 := NewPopulatedGatewayIdentifiers(r, easy)
	this.GatewayIdentifiers = *v26
	this.Limit = r.Uint32()
	this.Page = r.Uint32()
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedGetGatewayCollaboratorRequest(r randyGateway, easy bool) *GetGatewayCollaboratorRequest {
	this := &GetGatewayCollaboratorRequest{}
	v27 := NewPopulatedGatewayIdentifiers(r, easy)
	this.GatewayIdentifiers = *v27
	v28 := NewPopulatedOrganizationOrUserIdentifiers(r, easy)
	this.OrganizationOrUserIdentifiers = *v28
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedSetGatewayCollaboratorRequest(r randyGateway, easy bool) *SetGatewayCollaboratorRequest {
	this := &SetGatewayCollaboratorRequest{}
	v29 := NewPopulatedGatewayIdentifiers(r, easy)
	this.GatewayIdentifiers = *v29
	v30 := NewPopulatedCollaborator(r, easy)
	this.Collaborator = *v30
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedGatewayAntenna(r randyGateway, easy bool) *GatewayAntenna {
	this := &GatewayAntenna{}
	this.Gain = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.Gain *= -1
	}
	v31 := NewPopulatedLocation(r, easy)
	this.Location = *v31
	if r.Intn(5) != 0 {
		v32 := r.Intn(10)
		this.Attributes = make(map[string]string)
		for i := 0; i < v32; i++ {
			this.Attributes[randStringGateway(r)] = randStringGateway(r)
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedGatewayStatus(r randyGateway, easy bool) *GatewayStatus {
	this := &GatewayStatus{}
	v33 := github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy)
	this.Time = *v33
	v34 := github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy)
	this.BootTime = *v34
	if r.Intn(5) != 0 {
		v35 := r.Intn(10)
		this.Versions = make(map[string]string)
		for i := 0; i < v35; i++ {
			this.Versions[randStringGateway(r)] = randStringGateway(r)
		}
	}
	if r.Intn(5) != 0 {
		v36 := r.Intn(5)
		this.AntennaLocations = make([]*Location, v36)
		for i := 0; i < v36; i++ {
			this.AntennaLocations[i] = NewPopulatedLocation(r, easy)
		}
	}
	v37 := r.Intn(10)
	this.IP = make([]string, v37)
	for i := 0; i < v37; i++ {
		this.IP[i] = randStringGateway(r)
	}
	if r.Intn(5) != 0 {
		v38 := r.Intn(10)
		this.Metrics = make(map[string]float32)
		for i := 0; i < v38; i++ {
			v39 := randStringGateway(r)
			this.Metrics[v39] = float32(r.Float32())
			if r.Intn(2) == 0 {
				this.Metrics[v39] *= -1
			}
		}
	}
	if r.Intn(5) != 0 {
		this.Advanced = types.NewPopulatedStruct(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedGatewayConnectionStats(r randyGateway, easy bool) *GatewayConnectionStats {
	this := &GatewayConnectionStats{}
	if r.Intn(5) != 0 {
		this.ConnectedAt = github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy)
	}
	this.Protocol = randStringGateway(r)
	if r.Intn(5) != 0 {
		this.LastStatusReceivedAt = github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy)
	}
	if r.Intn(5) != 0 {
		this.LastStatus = NewPopulatedGatewayStatus(r, easy)
	}
	if r.Intn(5) != 0 {
		this.LastUplinkReceivedAt = github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy)
	}
	this.UplinkCount = uint64(r.Uint32())
	if r.Intn(5) != 0 {
		this.LastDownlinkReceivedAt = github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy)
	}
	this.DownlinkCount = uint64(r.Uint32())
	if r.Intn(5) != 0 {
		this.RoundTripTimes = NewPopulatedGatewayConnectionStats_RoundTripTimes(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedGatewayConnectionStats_RoundTripTimes(r randyGateway, easy bool) *GatewayConnectionStats_RoundTripTimes {
	this := &GatewayConnectionStats_RoundTripTimes{}
	v40 := github_com_gogo_protobuf_types.NewPopulatedStdDuration(r, easy)
	this.Min = *v40
	v41 := github_com_gogo_protobuf_types.NewPopulatedStdDuration(r, easy)
	this.Max = *v41
	v42 := github_com_gogo_protobuf_types.NewPopulatedStdDuration(r, easy)
	this.Median = *v42
	this.Count = r.Uint32()
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

type randyGateway interface {
	Float32() float32
	Float64() float64
	Int63() int64
	Int31() int32
	Uint32() uint32
	Intn(n int) int
}

func randUTF8RuneGateway(r randyGateway) rune {
	ru := r.Intn(62)
	if ru < 10 {
		return rune(ru + 48)
	} else if ru < 36 {
		return rune(ru + 55)
	}
	return rune(ru + 61)
}
func randStringGateway(r randyGateway) string {
	v43 := r.Intn(100)
	tmps := make([]rune, v43)
	for i := 0; i < v43; i++ {
		tmps[i] = randUTF8RuneGateway(r)
	}
	return string(tmps)
}
func randUnrecognizedGateway(r randyGateway, maxFieldNumber int) (dAtA []byte) {
	l := r.Intn(5)
	for i := 0; i < l; i++ {
		wire := r.Intn(4)
		if wire == 3 {
			wire = 5
		}
		fieldNumber := maxFieldNumber + r.Intn(100)
		dAtA = randFieldGateway(dAtA, r, fieldNumber, wire)
	}
	return dAtA
}
func randFieldGateway(dAtA []byte, r randyGateway, fieldNumber int, wire int) []byte {
	key := uint32(fieldNumber)<<3 | uint32(wire)
	switch wire {
	case 0:
		dAtA = encodeVarintPopulateGateway(dAtA, uint64(key))
		v44 := r.Int63()
		if r.Intn(2) == 0 {
			v44 *= -1
		}
		dAtA = encodeVarintPopulateGateway(dAtA, uint64(v44))
	case 1:
		dAtA = encodeVarintPopulateGateway(dAtA, uint64(key))
		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
	case 2:
		dAtA = encodeVarintPopulateGateway(dAtA, uint64(key))
		ll := r.Intn(100)
		dAtA = encodeVarintPopulateGateway(dAtA, uint64(ll))
		for j := 0; j < ll; j++ {
			dAtA = append(dAtA, byte(r.Intn(256)))
		}
	default:
		dAtA = encodeVarintPopulateGateway(dAtA, uint64(key))
		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
	}
	return dAtA
}
func encodeVarintPopulateGateway(dAtA []byte, v uint64) []byte {
	for v >= 1<<7 {
		dAtA = append(dAtA, uint8(v&0x7f|0x80))
		v >>= 7
	}
	dAtA = append(dAtA, uint8(v))
	return dAtA
}
func (m *GatewayBrand) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovGateway(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovGateway(uint64(l))
	}
	l = len(m.URL)
	if l > 0 {
		n += 1 + l + sovGateway(uint64(l))
	}
	if len(m.Logos) > 0 {
		for _, s := range m.Logos {
			l = len(s)
			n += 1 + l + sovGateway(uint64(l))
		}
	}
	return n
}

func (m *GatewayModel) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.BrandID)
	if l > 0 {
		n += 1 + l + sovGateway(uint64(l))
	}
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovGateway(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovGateway(uint64(l))
	}
	return n
}

func (m *GatewayVersionIdentifiers) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.BrandID)
	if l > 0 {
		n += 1 + l + sovGateway(uint64(l))
	}
	l = len(m.ModelID)
	if l > 0 {
		n += 1 + l + sovGateway(uint64(l))
	}
	l = len(m.HardwareVersion)
	if l > 0 {
		n += 1 + l + sovGateway(uint64(l))
	}
	l = len(m.FirmwareVersion)
	if l > 0 {
		n += 1 + l + sovGateway(uint64(l))
	}
	return n
}

func (m *GatewayRadio) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Enable {
		n += 2
	}
	l = len(m.ChipType)
	if l > 0 {
		n += 1 + l + sovGateway(uint64(l))
	}
	if m.Frequency != 0 {
		n += 1 + sovGateway(m.Frequency)
	}
	if m.RSSIOffset != 0 {
		n += 5
	}
	if m.TxConfiguration != nil {
		l = m.TxConfiguration.Size()
		n += 1 + l + sovGateway(uint64(l))
	}
	return n
}

func (m *GatewayRadio_TxConfiguration) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MinFrequency != 0 {
		n += 1 + sovGateway(m.MinFrequency)
	}
	if m.MaxFrequency != 0 {
		n += 1 + sovGateway(m.MaxFrequency)
	}
	if m.NotchFrequency != 0 {
		n += 1 + sovGateway(m.NotchFrequency)
	}
	return n
}

func (m *GatewayVersion) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.GatewayVersionIdentifiers.Size()
	n += 1 + l + sovGateway(uint64(l))
	if len(m.Photos) > 0 {
		for _, s := range m.Photos {
			l = len(s)
			n += 1 + l + sovGateway(uint64(l))
		}
	}
	if len(m.Radios) > 0 {
		for _, e := range m.Radios {
			l = e.Size()
			n += 1 + l + sovGateway(uint64(l))
		}
	}
	if m.ClockSource != 0 {
		n += 1 + sovGateway(uint64(m.ClockSource))
	}
	return n
}

func (m *Gateway) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.GatewayIdentifiers.Size()
	n += 1 + l + sovGateway(uint64(l))
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.CreatedAt)
	n += 1 + l + sovGateway(uint64(l))
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdatedAt)
	n += 1 + l + sovGateway(uint64(l))
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovGateway(uint64(l))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovGateway(uint64(l))
	}
	if len(m.Attributes) > 0 {
		for k, v := range m.Attributes {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovGateway(uint64(len(k))) + 1 + len(v) + sovGateway(uint64(len(v)))
			n += mapEntrySize + 1 + sovGateway(uint64(mapEntrySize))
		}
	}
	if len(m.ContactInfo) > 0 {
		for _, e := range m.ContactInfo {
			l = e.Size()
			n += 1 + l + sovGateway(uint64(l))
		}
	}
	l = m.GatewayVersionIdentifiers.Size()
	n += 1 + l + sovGateway(uint64(l))
	l = len(m.GatewayServerAddress)
	if l > 0 {
		n += 1 + l + sovGateway(uint64(l))
	}
	if m.AutoUpdate {
		n += 2
	}
	l = len(m.UpdateChannel)
	if l > 0 {
		n += 1 + l + sovGateway(uint64(l))
	}
	l = len(m.FrequencyPlanID)
	if l > 0 {
		n += 1 + l + sovGateway(uint64(l))
	}
	if len(m.Antennas) > 0 {
		for _, e := range m.Antennas {
			l = e.Size()
			n += 1 + l + sovGateway(uint64(l))
		}
	}
	if m.StatusPublic {
		n += 2
	}
	if m.LocationPublic {
		n += 2
	}
	if m.ScheduleDownlinkLate {
		n += 3
	}
	if m.EnforceDutyCycle {
		n += 3
	}
	if m.DownlinkPathConstraint != 0 {
		n += 2 + sovGateway(uint64(m.DownlinkPathConstraint))
	}
	if m.ScheduleAnytimeDelay != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdDuration(*m.ScheduleAnytimeDelay)
		n += 2 + l + sovGateway(uint64(l))
	}
	if len(m.FrequencyPlanIDs) > 0 {
		for _, s := range m.FrequencyPlanIDs {
			l = len(s)
			n += 2 + l + sovGateway(uint64(l))
		}
	}
	if m.UpdateLocationFromStatus {
		n += 3
	}
	return n
}

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

func (m *GetGatewayRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.GatewayIdentifiers.Size()
	n += 1 + l + sovGateway(uint64(l))
	l = m.FieldMask.Size()
	n += 1 + l + sovGateway(uint64(l))
	return n
}

func (m *GetGatewayIdentifiersForEUIRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.EUI.Size()
	n += 1 + l + sovGateway(uint64(l))
	return n
}

func (m *ListGatewaysRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Collaborator != nil {
		l = m.Collaborator.Size()
		n += 1 + l + sovGateway(uint64(l))
	}
	l = m.FieldMask.Size()
	n += 1 + l + sovGateway(uint64(l))
	l = len(m.Order)
	if l > 0 {
		n += 1 + l + sovGateway(uint64(l))
	}
	if m.Limit != 0 {
		n += 1 + sovGateway(uint64(m.Limit))
	}
	if m.Page != 0 {
		n += 1 + sovGateway(uint64(m.Page))
	}
	return n
}

func (m *CreateGatewayRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Gateway.Size()
	n += 1 + l + sovGateway(uint64(l))
	l = m.Collaborator.Size()
	n += 1 + l + sovGateway(uint64(l))
	return n
}

func (m *UpdateGatewayRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Gateway.Size()
	n += 1 + l + sovGateway(uint64(l))
	l = m.FieldMask.Size()
	n += 1 + l + sovGateway(uint64(l))
	return n
}

func (m *ListGatewayAPIKeysRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.GatewayIdentifiers.Size()
	n += 1 + l + sovGateway(uint64(l))
	if m.Limit != 0 {
		n += 1 + sovGateway(uint64(m.Limit))
	}
	if m.Page != 0 {
		n += 1 + sovGateway(uint64(m.Page))
	}
	return n
}

func (m *GetGatewayAPIKeyRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.GatewayIdentifiers.Size()
	n += 1 + l + sovGateway(uint64(l))
	l = len(m.KeyID)
	if l > 0 {
		n += 1 + l + sovGateway(uint64(l))
	}
	return n
}

func (m *CreateGatewayAPIKeyRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.GatewayIdentifiers.Size()
	n += 1 + l + sovGateway(uint64(l))
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovGateway(uint64(l))
	}
	if len(m.Rights) > 0 {
		l = 0
		for _, e := range m.Rights {
			l += sovGateway(uint64(e))
		}
		n += 1 + sovGateway(uint64(l)) + l
	}
	return n
}

func (m *UpdateGatewayAPIKeyRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.GatewayIdentifiers.Size()
	n += 1 + l + sovGateway(uint64(l))
	l = m.APIKey.Size()
	n += 1 + l + sovGateway(uint64(l))
	return n
}

func (m *ListGatewayCollaboratorsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.GatewayIdentifiers.Size()
	n += 1 + l + sovGateway(uint64(l))
	if m.Limit != 0 {
		n += 1 + sovGateway(uint64(m.Limit))
	}
	if m.Page != 0 {
		n += 1 + sovGateway(uint64(m.Page))
	}
	return n
}

func (m *GetGatewayCollaboratorRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.GatewayIdentifiers.Size()
	n += 1 + l + sovGateway(uint64(l))
	l = m.OrganizationOrUserIdentifiers.Size()
	n += 1 + l + sovGateway(uint64(l))
	return n
}

func (m *SetGatewayCollaboratorRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.GatewayIdentifiers.Size()
	n += 1 + l + sovGateway(uint64(l))
	l = m.Collaborator.Size()
	n += 1 + l + sovGateway(uint64(l))
	return n
}

func (m *GatewayAntenna) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Gain != 0 {
		n += 5
	}
	l = m.Location.Size()
	n += 1 + l + sovGateway(uint64(l))
	if len(m.Attributes) > 0 {
		for k, v := range m.Attributes {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovGateway(uint64(len(k))) + 1 + len(v) + sovGateway(uint64(len(v)))
			n += mapEntrySize + 1 + sovGateway(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *GatewayStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.Time)
	n += 1 + l + sovGateway(uint64(l))
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.BootTime)
	n += 1 + l + sovGateway(uint64(l))
	if len(m.Versions) > 0 {
		for k, v := range m.Versions {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovGateway(uint64(len(k))) + 1 + len(v) + sovGateway(uint64(len(v)))
			n += mapEntrySize + 1 + sovGateway(uint64(mapEntrySize))
		}
	}
	if len(m.AntennaLocations) > 0 {
		for _, e := range m.AntennaLocations {
			l = e.Size()
			n += 1 + l + sovGateway(uint64(l))
		}
	}
	if len(m.IP) > 0 {
		for _, s := range m.IP {
			l = len(s)
			n += 1 + l + sovGateway(uint64(l))
		}
	}
	if len(m.Metrics) > 0 {
		for k, v := range m.Metrics {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovGateway(uint64(len(k))) + 1 + 4
			n += mapEntrySize + 1 + sovGateway(uint64(mapEntrySize))
		}
	}
	if m.Advanced != nil {
		l = m.Advanced.Size()
		n += 2 + l + sovGateway(uint64(l))
	}
	return n
}

func (m *GatewayConnectionStats) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ConnectedAt != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.ConnectedAt)
		n += 1 + l + sovGateway(uint64(l))
	}
	l = len(m.Protocol)
	if l > 0 {
		n += 1 + l + sovGateway(uint64(l))
	}
	if m.LastStatusReceivedAt != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.LastStatusReceivedAt)
		n += 1 + l + sovGateway(uint64(l))
	}
	if m.LastStatus != nil {
		l = m.LastStatus.Size()
		n += 1 + l + sovGateway(uint64(l))
	}
	if m.LastUplinkReceivedAt != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.LastUplinkReceivedAt)
		n += 1 + l + sovGateway(uint64(l))
	}
	if m.UplinkCount != 0 {
		n += 1 + sovGateway(m.UplinkCount)
	}
	if m.LastDownlinkReceivedAt != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.LastDownlinkReceivedAt)
		n += 1 + l + sovGateway(uint64(l))
	}
	if m.DownlinkCount != 0 {
		n += 1 + sovGateway(m.DownlinkCount)
	}
	if m.RoundTripTimes != nil {
		l = m.RoundTripTimes.Size()
		n += 1 + l + sovGateway(uint64(l))
	}
	return n
}

func (m *GatewayConnectionStats_RoundTripTimes) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.Min)
	n += 1 + l + sovGateway(uint64(l))
	l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.Max)
	n += 1 + l + sovGateway(uint64(l))
	l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.Median)
	n += 1 + l + sovGateway(uint64(l))
	if m.Count != 0 {
		n += 1 + sovGateway(uint64(m.Count))
	}
	return n
}

func sovGateway(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozGateway(x uint64) (n int) {
	return sovGateway((x << 1) ^ uint64((int64(x) >> 63)))
}
func (this *GatewayBrand) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GatewayBrand{`,
		`ID:` + fmt.Sprintf("%v", this.ID) + `,`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`URL:` + fmt.Sprintf("%v", this.URL) + `,`,
		`Logos:` + fmt.Sprintf("%v", this.Logos) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GatewayModel) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GatewayModel{`,
		`BrandID:` + fmt.Sprintf("%v", this.BrandID) + `,`,
		`ID:` + fmt.Sprintf("%v", this.ID) + `,`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GatewayVersionIdentifiers) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GatewayVersionIdentifiers{`,
		`BrandID:` + fmt.Sprintf("%v", this.BrandID) + `,`,
		`ModelID:` + fmt.Sprintf("%v", this.ModelID) + `,`,
		`HardwareVersion:` + fmt.Sprintf("%v", this.HardwareVersion) + `,`,
		`FirmwareVersion:` + fmt.Sprintf("%v", this.FirmwareVersion) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GatewayRadio) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GatewayRadio{`,
		`Enable:` + fmt.Sprintf("%v", this.Enable) + `,`,
		`ChipType:` + fmt.Sprintf("%v", this.ChipType) + `,`,
		`Frequency:` + fmt.Sprintf("%v", this.Frequency) + `,`,
		`RSSIOffset:` + fmt.Sprintf("%v", this.RSSIOffset) + `,`,
		`TxConfiguration:` + strings.Replace(fmt.Sprintf("%v", this.TxConfiguration), "GatewayRadio_TxConfiguration", "GatewayRadio_TxConfiguration", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GatewayRadio_TxConfiguration) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GatewayRadio_TxConfiguration{`,
		`MinFrequency:` + fmt.Sprintf("%v", this.MinFrequency) + `,`,
		`MaxFrequency:` + fmt.Sprintf("%v", this.MaxFrequency) + `,`,
		`NotchFrequency:` + fmt.Sprintf("%v", this.NotchFrequency) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GatewayVersion) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForRadios := "[]*GatewayRadio{"
	for _, f := range this.Radios {
		repeatedStringForRadios += strings.Replace(f.String(), "GatewayRadio", "GatewayRadio", 1) + ","
	}
	repeatedStringForRadios += "}"
	s := strings.Join([]string{`&GatewayVersion{`,
		`GatewayVersionIdentifiers:` + strings.Replace(strings.Replace(this.GatewayVersionIdentifiers.String(), "GatewayVersionIdentifiers", "GatewayVersionIdentifiers", 1), `&`, ``, 1) + `,`,
		`Photos:` + fmt.Sprintf("%v", this.Photos) + `,`,
		`Radios:` + repeatedStringForRadios + `,`,
		`ClockSource:` + fmt.Sprintf("%v", this.ClockSource) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Gateway) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForContactInfo := "[]*ContactInfo{"
	for _, f := range this.ContactInfo {
		repeatedStringForContactInfo += strings.Replace(fmt.Sprintf("%v", f), "ContactInfo", "ContactInfo", 1) + ","
	}
	repeatedStringForContactInfo += "}"
	repeatedStringForAntennas := "[]GatewayAntenna{"
	for _, f := range this.Antennas {
		repeatedStringForAntennas += strings.Replace(strings.Replace(f.String(), "GatewayAntenna", "GatewayAntenna", 1), `&`, ``, 1) + ","
	}
	repeatedStringForAntennas += "}"
	keysForAttributes := make([]string, 0, len(this.Attributes))
	for k := range this.Attributes {
		keysForAttributes = append(keysForAttributes, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForAttributes)
	mapStringForAttributes := "map[string]string{"
	for _, k := range keysForAttributes {
		mapStringForAttributes += fmt.Sprintf("%v: %v,", k, this.Attributes[k])
	}
	mapStringForAttributes += "}"
	s := strings.Join([]string{`&Gateway{`,
		`GatewayIdentifiers:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.GatewayIdentifiers), "GatewayIdentifiers", "GatewayIdentifiers", 1), `&`, ``, 1) + `,`,
		`CreatedAt:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.CreatedAt), "Timestamp", "types.Timestamp", 1), `&`, ``, 1) + `,`,
		`UpdatedAt:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.UpdatedAt), "Timestamp", "types.Timestamp", 1), `&`, ``, 1) + `,`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Description:` + fmt.Sprintf("%v", this.Description) + `,`,
		`Attributes:` + mapStringForAttributes + `,`,
		`ContactInfo:` + repeatedStringForContactInfo + `,`,
		`GatewayVersionIdentifiers:` + strings.Replace(strings.Replace(this.GatewayVersionIdentifiers.String(), "GatewayVersionIdentifiers", "GatewayVersionIdentifiers", 1), `&`, ``, 1) + `,`,
		`GatewayServerAddress:` + fmt.Sprintf("%v", this.GatewayServerAddress) + `,`,
		`AutoUpdate:` + fmt.Sprintf("%v", this.AutoUpdate) + `,`,
		`UpdateChannel:` + fmt.Sprintf("%v", this.UpdateChannel) + `,`,
		`FrequencyPlanID:` + fmt.Sprintf("%v", this.FrequencyPlanID) + `,`,
		`Antennas:` + repeatedStringForAntennas + `,`,
		`StatusPublic:` + fmt.Sprintf("%v", this.StatusPublic) + `,`,
		`LocationPublic:` + fmt.Sprintf("%v", this.LocationPublic) + `,`,
		`ScheduleDownlinkLate:` + fmt.Sprintf("%v", this.ScheduleDownlinkLate) + `,`,
		`EnforceDutyCycle:` + fmt.Sprintf("%v", this.EnforceDutyCycle) + `,`,
		`DownlinkPathConstraint:` + fmt.Sprintf("%v", this.DownlinkPathConstraint) + `,`,
		`ScheduleAnytimeDelay:` + strings.Replace(fmt.Sprintf("%v", this.ScheduleAnytimeDelay), "Duration", "types.Duration", 1) + `,`,
		`FrequencyPlanIDs:` + fmt.Sprintf("%v", this.FrequencyPlanIDs) + `,`,
		`UpdateLocationFromStatus:` + fmt.Sprintf("%v", this.UpdateLocationFromStatus) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Gateways) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForGateways := "[]*Gateway{"
	for _, f := range this.Gateways {
		repeatedStringForGateways += strings.Replace(f.String(), "Gateway", "Gateway", 1) + ","
	}
	repeatedStringForGateways += "}"
	s := strings.Join([]string{`&Gateways{`,
		`Gateways:` + repeatedStringForGateways + `,`,
		`}`,
	}, "")
	return s
}
func (this *GetGatewayRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GetGatewayRequest{`,
		`GatewayIdentifiers:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.GatewayIdentifiers), "GatewayIdentifiers", "GatewayIdentifiers", 1), `&`, ``, 1) + `,`,
		`FieldMask:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.FieldMask), "FieldMask", "types.FieldMask", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GetGatewayIdentifiersForEUIRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GetGatewayIdentifiersForEUIRequest{`,
		`EUI:` + fmt.Sprintf("%v", this.EUI) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ListGatewaysRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ListGatewaysRequest{`,
		`Collaborator:` + strings.Replace(fmt.Sprintf("%v", this.Collaborator), "OrganizationOrUserIdentifiers", "OrganizationOrUserIdentifiers", 1) + `,`,
		`FieldMask:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.FieldMask), "FieldMask", "types.FieldMask", 1), `&`, ``, 1) + `,`,
		`Order:` + fmt.Sprintf("%v", this.Order) + `,`,
		`Limit:` + fmt.Sprintf("%v", this.Limit) + `,`,
		`Page:` + fmt.Sprintf("%v", this.Page) + `,`,
		`}`,
	}, "")
	return s
}
func (this *CreateGatewayRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&CreateGatewayRequest{`,
		`Gateway:` + strings.Replace(strings.Replace(this.Gateway.String(), "Gateway", "Gateway", 1), `&`, ``, 1) + `,`,
		`Collaborator:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Collaborator), "OrganizationOrUserIdentifiers", "OrganizationOrUserIdentifiers", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *UpdateGatewayRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&UpdateGatewayRequest{`,
		`Gateway:` + strings.Replace(strings.Replace(this.Gateway.String(), "Gateway", "Gateway", 1), `&`, ``, 1) + `,`,
		`FieldMask:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.FieldMask), "FieldMask", "types.FieldMask", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ListGatewayAPIKeysRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ListGatewayAPIKeysRequest{`,
		`GatewayIdentifiers:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.GatewayIdentifiers), "GatewayIdentifiers", "GatewayIdentifiers", 1), `&`, ``, 1) + `,`,
		`Limit:` + fmt.Sprintf("%v", this.Limit) + `,`,
		`Page:` + fmt.Sprintf("%v", this.Page) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GetGatewayAPIKeyRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GetGatewayAPIKeyRequest{`,
		`GatewayIdentifiers:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.GatewayIdentifiers), "GatewayIdentifiers", "GatewayIdentifiers", 1), `&`, ``, 1) + `,`,
		`KeyID:` + fmt.Sprintf("%v", this.KeyID) + `,`,
		`}`,
	}, "")
	return s
}
func (this *CreateGatewayAPIKeyRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&CreateGatewayAPIKeyRequest{`,
		`GatewayIdentifiers:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.GatewayIdentifiers), "GatewayIdentifiers", "GatewayIdentifiers", 1), `&`, ``, 1) + `,`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Rights:` + fmt.Sprintf("%v", this.Rights) + `,`,
		`}`,
	}, "")
	return s
}
func (this *UpdateGatewayAPIKeyRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&UpdateGatewayAPIKeyRequest{`,
		`GatewayIdentifiers:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.GatewayIdentifiers), "GatewayIdentifiers", "GatewayIdentifiers", 1), `&`, ``, 1) + `,`,
		`APIKey:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.APIKey), "APIKey", "APIKey", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ListGatewayCollaboratorsRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ListGatewayCollaboratorsRequest{`,
		`GatewayIdentifiers:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.GatewayIdentifiers), "GatewayIdentifiers", "GatewayIdentifiers", 1), `&`, ``, 1) + `,`,
		`Limit:` + fmt.Sprintf("%v", this.Limit) + `,`,
		`Page:` + fmt.Sprintf("%v", this.Page) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GetGatewayCollaboratorRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GetGatewayCollaboratorRequest{`,
		`GatewayIdentifiers:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.GatewayIdentifiers), "GatewayIdentifiers", "GatewayIdentifiers", 1), `&`, ``, 1) + `,`,
		`OrganizationOrUserIdentifiers:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.OrganizationOrUserIdentifiers), "OrganizationOrUserIdentifiers", "OrganizationOrUserIdentifiers", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *SetGatewayCollaboratorRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&SetGatewayCollaboratorRequest{`,
		`GatewayIdentifiers:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.GatewayIdentifiers), "GatewayIdentifiers", "GatewayIdentifiers", 1), `&`, ``, 1) + `,`,
		`Collaborator:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Collaborator), "Collaborator", "Collaborator", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GatewayAntenna) String() string {
	if this == nil {
		return "nil"
	}
	keysForAttributes := make([]string, 0, len(this.Attributes))
	for k := range this.Attributes {
		keysForAttributes = append(keysForAttributes, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForAttributes)
	mapStringForAttributes := "map[string]string{"
	for _, k := range keysForAttributes {
		mapStringForAttributes += fmt.Sprintf("%v: %v,", k, this.Attributes[k])
	}
	mapStringForAttributes += "}"
	s := strings.Join([]string{`&GatewayAntenna{`,
		`Gain:` + fmt.Sprintf("%v", this.Gain) + `,`,
		`Location:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Location), "Location", "Location", 1), `&`, ``, 1) + `,`,
		`Attributes:` + mapStringForAttributes + `,`,
		`}`,
	}, "")
	return s
}
func (this *GatewayStatus) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForAntennaLocations := "[]*Location{"
	for _, f := range this.AntennaLocations {
		repeatedStringForAntennaLocations += strings.Replace(fmt.Sprintf("%v", f), "Location", "Location", 1) + ","
	}
	repeatedStringForAntennaLocations += "}"
	keysForVersions := make([]string, 0, len(this.Versions))
	for k := range this.Versions {
		keysForVersions = append(keysForVersions, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForVersions)
	mapStringForVersions := "map[string]string{"
	for _, k := range keysForVersions {
		mapStringForVersions += fmt.Sprintf("%v: %v,", k, this.Versions[k])
	}
	mapStringForVersions += "}"
	keysForMetrics := make([]string, 0, len(this.Metrics))
	for k := range this.Metrics {
		keysForMetrics = append(keysForMetrics, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMetrics)
	mapStringForMetrics := "map[string]float32{"
	for _, k := range keysForMetrics {
		mapStringForMetrics += fmt.Sprintf("%v: %v,", k, this.Metrics[k])
	}
	mapStringForMetrics += "}"
	s := strings.Join([]string{`&GatewayStatus{`,
		`Time:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Time), "Timestamp", "types.Timestamp", 1), `&`, ``, 1) + `,`,
		`BootTime:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.BootTime), "Timestamp", "types.Timestamp", 1), `&`, ``, 1) + `,`,
		`Versions:` + mapStringForVersions + `,`,
		`AntennaLocations:` + repeatedStringForAntennaLocations + `,`,
		`IP:` + fmt.Sprintf("%v", this.IP) + `,`,
		`Metrics:` + mapStringForMetrics + `,`,
		`Advanced:` + strings.Replace(fmt.Sprintf("%v", this.Advanced), "Struct", "types.Struct", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GatewayConnectionStats) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GatewayConnectionStats{`,
		`ConnectedAt:` + strings.Replace(fmt.Sprintf("%v", this.ConnectedAt), "Timestamp", "types.Timestamp", 1) + `,`,
		`Protocol:` + fmt.Sprintf("%v", this.Protocol) + `,`,
		`LastStatusReceivedAt:` + strings.Replace(fmt.Sprintf("%v", this.LastStatusReceivedAt), "Timestamp", "types.Timestamp", 1) + `,`,
		`LastStatus:` + strings.Replace(this.LastStatus.String(), "GatewayStatus", "GatewayStatus", 1) + `,`,
		`LastUplinkReceivedAt:` + strings.Replace(fmt.Sprintf("%v", this.LastUplinkReceivedAt), "Timestamp", "types.Timestamp", 1) + `,`,
		`UplinkCount:` + fmt.Sprintf("%v", this.UplinkCount) + `,`,
		`LastDownlinkReceivedAt:` + strings.Replace(fmt.Sprintf("%v", this.LastDownlinkReceivedAt), "Timestamp", "types.Timestamp", 1) + `,`,
		`DownlinkCount:` + fmt.Sprintf("%v", this.DownlinkCount) + `,`,
		`RoundTripTimes:` + strings.Replace(fmt.Sprintf("%v", this.RoundTripTimes), "GatewayConnectionStats_RoundTripTimes", "GatewayConnectionStats_RoundTripTimes", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GatewayConnectionStats_RoundTripTimes) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GatewayConnectionStats_RoundTripTimes{`,
		`Min:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Min), "Duration", "types.Duration", 1), `&`, ``, 1) + `,`,
		`Max:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Max), "Duration", "types.Duration", 1), `&`, ``, 1) + `,`,
		`Median:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Median), "Duration", "types.Duration", 1), `&`, ``, 1) + `,`,
		`Count:` + fmt.Sprintf("%v", this.Count) + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringGateway(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *GatewayBrand) 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 ErrIntOverflowGateway
			}
			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: GatewayBrand: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GatewayBrand: 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 ErrIntOverflowGateway
				}
				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 ErrInvalidLengthGateway
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			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 Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				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 ErrInvalidLengthGateway
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field URL", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				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 ErrInvalidLengthGateway
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.URL = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Logos", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				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 ErrInvalidLengthGateway
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Logos = append(m.Logos, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGateway(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGateway
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGateway
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GatewayRadio) 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 ErrIntOverflowGateway
			}
			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: GatewayRadio: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GatewayRadio: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowGateway
				}
				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 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChipType", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				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 ErrInvalidLengthGateway
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ChipType = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Frequency", wireType)
			}
			m.Frequency = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Frequency |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field RSSIOffset", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:])
			iNdEx += 4
			m.RSSIOffset = float32(math.Float32frombits(v))
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TxConfiguration", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGateway
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TxConfiguration == nil {
				m.TxConfiguration = &GatewayRadio_TxConfiguration{}
			}
			if err := m.TxConfiguration.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGateway(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGateway
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGateway
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GatewayRadio_TxConfiguration) 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 ErrIntOverflowGateway
			}
			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: TxConfiguration: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TxConfiguration: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinFrequency", wireType)
			}
			m.MinFrequency = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MinFrequency |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxFrequency", wireType)
			}
			m.MaxFrequency = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxFrequency |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NotchFrequency", wireType)
			}
			m.NotchFrequency = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NotchFrequency |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipGateway(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGateway
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGateway
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GatewayVersion) 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 ErrIntOverflowGateway
			}
			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: GatewayVersion: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GatewayVersion: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GatewayVersionIdentifiers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGateway
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.GatewayVersionIdentifiers.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Photos", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				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 ErrInvalidLengthGateway
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Photos = append(m.Photos, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Radios", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGateway
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Radios = append(m.Radios, &GatewayRadio{})
			if err := m.Radios[len(m.Radios)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClockSource", wireType)
			}
			m.ClockSource = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ClockSource |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipGateway(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGateway
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGateway
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Gateway) 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 ErrIntOverflowGateway
			}
			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: Gateway: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Gateway: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GatewayIdentifiers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGateway
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.GatewayIdentifiers.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreatedAt", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGateway
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.CreatedAt, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpdatedAt", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGateway
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.UpdatedAt, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				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 ErrInvalidLengthGateway
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				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 ErrInvalidLengthGateway
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Attributes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGateway
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Attributes == nil {
				m.Attributes = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowGateway
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGateway
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthGateway
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthGateway
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGateway
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthGateway
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthGateway
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipGateway(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthGateway
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Attributes[mapkey] = mapvalue
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContactInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGateway
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContactInfo = append(m.ContactInfo, &ContactInfo{})
			if err := m.ContactInfo[len(m.ContactInfo)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GatewayVersionIdentifiers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGateway
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.GatewayVersionIdentifiers.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GatewayServerAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				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 ErrInvalidLengthGateway
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.GatewayServerAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AutoUpdate", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.AutoUpdate = bool(v != 0)
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpdateChannel", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				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 ErrInvalidLengthGateway
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UpdateChannel = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FrequencyPlanID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				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 ErrInvalidLengthGateway
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FrequencyPlanID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Antennas", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGateway
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Antennas = append(m.Antennas, GatewayAntenna{})
			if err := m.Antennas[len(m.Antennas)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 14:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StatusPublic", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.StatusPublic = bool(v != 0)
		case 15:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LocationPublic", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.LocationPublic = bool(v != 0)
		case 16:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScheduleDownlinkLate", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ScheduleDownlinkLate = bool(v != 0)
		case 17:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EnforceDutyCycle", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.EnforceDutyCycle = bool(v != 0)
		case 18:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DownlinkPathConstraint", wireType)
			}
			m.DownlinkPathConstraint = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DownlinkPathConstraint |= DownlinkPathConstraint(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 19:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScheduleAnytimeDelay", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGateway
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ScheduleAnytimeDelay == nil {
				m.ScheduleAnytimeDelay = new(time.Duration)
			}
			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(m.ScheduleAnytimeDelay, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 20:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FrequencyPlanIDs", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				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 ErrInvalidLengthGateway
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FrequencyPlanIDs = append(m.FrequencyPlanIDs, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 21:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpdateLocationFromStatus", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.UpdateLocationFromStatus = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipGateway(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGateway
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGateway
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Gateways) 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 ErrIntOverflowGateway
			}
			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: Gateways: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Gateways: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Gateways", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGateway
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Gateways = append(m.Gateways, &Gateway{})
			if err := m.Gateways[len(m.Gateways)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGateway(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGateway
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGateway
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetGatewayRequest) 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 ErrIntOverflowGateway
			}
			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: GetGatewayRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetGatewayRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GatewayIdentifiers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGateway
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.GatewayIdentifiers.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FieldMask", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGateway
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.FieldMask.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGateway(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGateway
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGateway
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetGatewayIdentifiersForEUIRequest) 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 ErrIntOverflowGateway
			}
			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: GetGatewayIdentifiersForEUIRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetGatewayIdentifiersForEUIRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EUI", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthGateway
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.EUI.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGateway(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGateway
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGateway
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ListGatewaysRequest) 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 ErrIntOverflowGateway
			}
			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: ListGatewaysRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListGatewaysRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Collaborator", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGateway
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Collaborator == nil {
				m.Collaborator = &OrganizationOrUserIdentifiers{}
			}
			if err := m.Collaborator.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FieldMask", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGateway
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.FieldMask.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Order", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				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 ErrInvalidLengthGateway
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Order = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType)
			}
			m.Limit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Limit |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Page", wireType)
			}
			m.Page = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Page |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipGateway(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGateway
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGateway
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CreateGatewayRequest) 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 ErrIntOverflowGateway
			}
			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: CreateGatewayRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreateGatewayRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Gateway", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGateway
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Gateway.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Collaborator", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGateway
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Collaborator.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGateway(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGateway
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGateway
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UpdateGatewayRequest) 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 ErrIntOverflowGateway
			}
			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: UpdateGatewayRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UpdateGatewayRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Gateway", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGateway
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Gateway.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FieldMask", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGateway
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.FieldMask.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGateway(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGateway
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGateway
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ListGatewayAPIKeysRequest) 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 ErrIntOverflowGateway
			}
			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: ListGatewayAPIKeysRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListGatewayAPIKeysRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GatewayIdentifiers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGateway
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.GatewayIdentifiers.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType)
			}
			m.Limit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Limit |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Page", wireType)
			}
			m.Page = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Page |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipGateway(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGateway
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGateway
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CreateGatewayAPIKeyRequest) 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 ErrIntOverflowGateway
			}
			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: CreateGatewayAPIKeyRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreateGatewayAPIKeyRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GatewayIdentifiers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGateway
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.GatewayIdentifiers.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				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 ErrInvalidLengthGateway
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType == 0 {
				var v Right
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowGateway
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= Right(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Rights = append(m.Rights, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowGateway
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthGateway
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthGateway
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				if elementCount != 0 && len(m.Rights) == 0 {
					m.Rights = make([]Right, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v Right
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGateway
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= Right(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Rights = append(m.Rights, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Rights", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipGateway(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGateway
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGateway
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UpdateGatewayAPIKeyRequest) 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 ErrIntOverflowGateway
			}
			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: UpdateGatewayAPIKeyRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UpdateGatewayAPIKeyRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GatewayIdentifiers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGateway
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.GatewayIdentifiers.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field APIKey", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGateway
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.APIKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGateway(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGateway
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGateway
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ListGatewayCollaboratorsRequest) 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 ErrIntOverflowGateway
			}
			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: ListGatewayCollaboratorsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListGatewayCollaboratorsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GatewayIdentifiers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGateway
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.GatewayIdentifiers.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType)
			}
			m.Limit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Limit |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Page", wireType)
			}
			m.Page = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Page |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipGateway(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGateway
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGateway
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetGatewayCollaboratorRequest) 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 ErrIntOverflowGateway
			}
			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: GetGatewayCollaboratorRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetGatewayCollaboratorRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GatewayIdentifiers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGateway
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.GatewayIdentifiers.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrganizationOrUserIdentifiers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGateway
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.OrganizationOrUserIdentifiers.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGateway(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGateway
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGateway
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SetGatewayCollaboratorRequest) 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 ErrIntOverflowGateway
			}
			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: SetGatewayCollaboratorRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetGatewayCollaboratorRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GatewayIdentifiers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGateway
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.GatewayIdentifiers.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Collaborator", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGateway
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Collaborator.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGateway(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGateway
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGateway
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GatewayAntenna) 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 ErrIntOverflowGateway
			}
			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: GatewayAntenna: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GatewayAntenna: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Gain", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:])
			iNdEx += 4
			m.Gain = float32(math.Float32frombits(v))
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Location", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGateway
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Location.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Attributes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGateway
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Attributes == nil {
				m.Attributes = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowGateway
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGateway
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthGateway
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthGateway
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGateway
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthGateway
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthGateway
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipGateway(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthGateway
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Attributes[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGateway(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGateway
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGateway
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GatewayStatus) 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 ErrIntOverflowGateway
			}
			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: GatewayStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GatewayStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGateway
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.Time, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BootTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGateway
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.BootTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Versions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGateway
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Versions == nil {
				m.Versions = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowGateway
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGateway
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthGateway
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthGateway
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGateway
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthGateway
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthGateway
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipGateway(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthGateway
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Versions[mapkey] = mapvalue
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AntennaLocations", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGateway
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AntennaLocations = append(m.AntennaLocations, &Location{})
			if err := m.AntennaLocations[len(m.AntennaLocations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IP", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				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 ErrInvalidLengthGateway
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IP = append(m.IP, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metrics", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGateway
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Metrics == nil {
				m.Metrics = make(map[string]float32)
			}
			var mapkey string
			var mapvalue float32
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowGateway
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGateway
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthGateway
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthGateway
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapvaluetemp uint32
					if (iNdEx + 4) > l {
						return io.ErrUnexpectedEOF
					}
					mapvaluetemp = encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:])
					iNdEx += 4
					mapvalue = math.Float32frombits(mapvaluetemp)
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipGateway(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthGateway
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Metrics[mapkey] = mapvalue
			iNdEx = postIndex
		case 99:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Advanced", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGateway
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Advanced == nil {
				m.Advanced = &types.Struct{}
			}
			if err := m.Advanced.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGateway(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGateway
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGateway
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GatewayConnectionStats) 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 ErrIntOverflowGateway
			}
			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: GatewayConnectionStats: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GatewayConnectionStats: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConnectedAt", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGateway
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ConnectedAt == nil {
				m.ConnectedAt = new(time.Time)
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.ConnectedAt, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Protocol", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				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 ErrInvalidLengthGateway
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Protocol = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastStatusReceivedAt", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGateway
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.LastStatusReceivedAt == nil {
				m.LastStatusReceivedAt = new(time.Time)
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.LastStatusReceivedAt, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastStatus", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGateway
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.LastStatus == nil {
				m.LastStatus = &GatewayStatus{}
			}
			if err := m.LastStatus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastUplinkReceivedAt", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGateway
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.LastUplinkReceivedAt == nil {
				m.LastUplinkReceivedAt = new(time.Time)
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.LastUplinkReceivedAt, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UplinkCount", wireType)
			}
			m.UplinkCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UplinkCount |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastDownlinkReceivedAt", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGateway
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.LastDownlinkReceivedAt == nil {
				m.LastDownlinkReceivedAt = new(time.Time)
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.LastDownlinkReceivedAt, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DownlinkCount", wireType)
			}
			m.DownlinkCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DownlinkCount |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RoundTripTimes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGateway
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RoundTripTimes == nil {
				m.RoundTripTimes = &GatewayConnectionStats_RoundTripTimes{}
			}
			if err := m.RoundTripTimes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGateway(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGateway
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGateway
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GatewayConnectionStats_RoundTripTimes) 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 ErrIntOverflowGateway
			}
			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: RoundTripTimes: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RoundTripTimes: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Min", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGateway
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.Min, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Max", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGateway
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.Max, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Median", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGateway
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGateway
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.Median, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Count", wireType)
			}
			m.Count = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Count |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipGateway(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGateway
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGateway
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipGateway(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowGateway
			}
			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, ErrIntOverflowGateway
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowGateway
				}
				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, ErrInvalidLengthGateway
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupGateway
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthGateway
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthGateway        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowGateway          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupGateway = fmt.Errorf("proto: unexpected end of group")
)