// Code generated by protoc-gen-go-vtproto. DO NOT EDIT.

// protoc-gen-go-vtproto version: v0.6.1-0.20240409071808-615f978279ca

// source: storage/cloud_source.proto

package storage

import (

fmt "fmt"

protohelpers "github.com/planetscale/vtprotobuf/protohelpers"

proto "google.golang.org/protobuf/proto"

protoimpl "google.golang.org/protobuf/runtime/protoimpl"

io "io"

unsafe "unsafe"

)

const (

// Verify that this generated code is sufficiently up-to-date.

_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)

// Verify that runtime/protoimpl is sufficiently up-to-date.

_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)

)

func (m *CloudSource_Credentials) CloneVT() *CloudSource_Credentials {

if m == nil {

return (*CloudSource_Credentials)(nil)

}

r := new(CloudSource_Credentials)

r.Secret = m.Secret

r.ClientId = m.ClientId

r.ClientSecret = m.ClientSecret

if len(m.unknownFields) > 0 {

r.unknownFields = make([]byte, len(m.unknownFields))

copy(r.unknownFields, m.unknownFields)

}

return r

}

func (m *CloudSource_Credentials) CloneMessageVT() proto.Message {

return m.CloneVT()

}

func (m *CloudSource) CloneVT() *CloudSource {

if m == nil {

return (*CloudSource)(nil)

}

r := new(CloudSource)

r.Id = m.Id

r.Name = m.Name

r.Type = m.Type

r.Credentials = m.Credentials.CloneVT()

r.SkipTestIntegration = m.SkipTestIntegration

if m.Config != nil {

r.Config = m.Config.(interface{ CloneVT() isCloudSource_Config }).CloneVT()

}

if len(m.unknownFields) > 0 {

r.unknownFields = make([]byte, len(m.unknownFields))

copy(r.unknownFields, m.unknownFields)

}

return r

}

func (m *CloudSource) CloneMessageVT() proto.Message {

return m.CloneVT()

}

func (m *CloudSource_PaladinCloud) CloneVT() isCloudSource_Config {

if m == nil {

return (*CloudSource_PaladinCloud)(nil)

}

r := new(CloudSource_PaladinCloud)

r.PaladinCloud = m.PaladinCloud.CloneVT()

return r

}

func (m *CloudSource_Ocm) CloneVT() isCloudSource_Config {

if m == nil {

return (*CloudSource_Ocm)(nil)

}

r := new(CloudSource_Ocm)

r.Ocm = m.Ocm.CloneVT()

return r

}

func (m *PaladinCloudConfig) CloneVT() *PaladinCloudConfig {

if m == nil {

return (*PaladinCloudConfig)(nil)

}

r := new(PaladinCloudConfig)

r.Endpoint = m.Endpoint

if len(m.unknownFields) > 0 {

r.unknownFields = make([]byte, len(m.unknownFields))

copy(r.unknownFields, m.unknownFields)

}

return r

}

func (m *PaladinCloudConfig) CloneMessageVT() proto.Message {

return m.CloneVT()

}

func (m *OCMConfig) CloneVT() *OCMConfig {

if m == nil {

return (*OCMConfig)(nil)

}

r := new(OCMConfig)

r.Endpoint = m.Endpoint

if len(m.unknownFields) > 0 {

r.unknownFields = make([]byte, len(m.unknownFields))

copy(r.unknownFields, m.unknownFields)

}

return r

}

func (m *OCMConfig) CloneMessageVT() proto.Message {

return m.CloneVT()

}

func (this *CloudSource_Credentials) EqualVT(that *CloudSource_Credentials) bool {

if this == that {

return true

} else if this == nil || that == nil {

return false

}

if this.Secret != that.Secret {

return false

}

if this.ClientId != that.ClientId {

return false

}

if this.ClientSecret != that.ClientSecret {

return false

}

return string(this.unknownFields) == string(that.unknownFields)

}

func (this *CloudSource_Credentials) EqualMessageVT(thatMsg proto.Message) bool {

that, ok := thatMsg.(*CloudSource_Credentials)

if !ok {

return false

}

return this.EqualVT(that)

}

func (this *CloudSource) EqualVT(that *CloudSource) bool {

if this == that {

return true

} else if this == nil || that == nil {

return false

}

if this.Config == nil && that.Config != nil {

return false

} else if this.Config != nil {

if that.Config == nil {

return false

}

if !this.Config.(interface {

EqualVT(isCloudSource_Config) bool

}).EqualVT(that.Config) {

return false

}

}

if this.Id != that.Id {

return false

}

if this.Name != that.Name {

return false

}

if this.Type != that.Type {

return false

}

if !this.Credentials.EqualVT(that.Credentials) {

return false

}

if this.SkipTestIntegration != that.SkipTestIntegration {

return false

}

return string(this.unknownFields) == string(that.unknownFields)

}

func (this *CloudSource) EqualMessageVT(thatMsg proto.Message) bool {

that, ok := thatMsg.(*CloudSource)

if !ok {

return false

}

return this.EqualVT(that)

}

func (this *CloudSource_PaladinCloud) EqualVT(thatIface isCloudSource_Config) bool {

that, ok := thatIface.(*CloudSource_PaladinCloud)

if !ok {

return false

}

if this == that {

return true

}

if this == nil && that != nil || this != nil && that == nil {

return false

}

if p, q := this.PaladinCloud, that.PaladinCloud; p != q {

if p == nil {

p = &PaladinCloudConfig{}

}

if q == nil {

q = &PaladinCloudConfig{}

}

if !p.EqualVT(q) {

return false

}

}

return true

}

func (this *CloudSource_Ocm) EqualVT(thatIface isCloudSource_Config) bool {

that, ok := thatIface.(*CloudSource_Ocm)

if !ok {

return false

}

if this == that {

return true

}

if this == nil && that != nil || this != nil && that == nil {

return false

}

if p, q := this.Ocm, that.Ocm; p != q {

if p == nil {

p = &OCMConfig{}

}

if q == nil {

q = &OCMConfig{}

}

if !p.EqualVT(q) {

return false

}

}

return true

}

func (this *PaladinCloudConfig) EqualVT(that *PaladinCloudConfig) bool {

if this == that {

return true

} else if this == nil || that == nil {

return false

}

if this.Endpoint != that.Endpoint {

return false

}

return string(this.unknownFields) == string(that.unknownFields)

}

func (this *PaladinCloudConfig) EqualMessageVT(thatMsg proto.Message) bool {

that, ok := thatMsg.(*PaladinCloudConfig)

if !ok {

return false

}

return this.EqualVT(that)

}

func (this *OCMConfig) EqualVT(that *OCMConfig) bool {

if this == that {

return true

} else if this == nil || that == nil {

return false

}

if this.Endpoint != that.Endpoint {

return false

}

return string(this.unknownFields) == string(that.unknownFields)

}

func (this *OCMConfig) EqualMessageVT(thatMsg proto.Message) bool {

that, ok := thatMsg.(*OCMConfig)

if !ok {

return false

}

return this.EqualVT(that)

}

func (m *CloudSource_Credentials) MarshalVT() (dAtA []byte, err error) {

if m == nil {

return nil, nil

}

size := m.SizeVT()

dAtA = make([]byte, size)

n, err := m.MarshalToSizedBufferVT(dAtA[:size])

if err != nil {

return nil, err

}

return dAtA[:n], nil

}

func (m *CloudSource_Credentials) MarshalToVT(dAtA []byte) (int, error) {

size := m.SizeVT()

return m.MarshalToSizedBufferVT(dAtA[:size])

}

func (m *CloudSource_Credentials) MarshalToSizedBufferVT(dAtA []byte) (int, error) {

if m == nil {

return 0, nil

}

i := len(dAtA)

_ = i

var l int

_ = l

if m.unknownFields != nil {

i -= len(m.unknownFields)

copy(dAtA[i:], m.unknownFields)

}

if len(m.ClientSecret) > 0 {

i -= len(m.ClientSecret)

copy(dAtA[i:], m.ClientSecret)

i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ClientSecret)))

i--

dAtA[i] = 0x1a

}

if len(m.ClientId) > 0 {

i -= len(m.ClientId)

copy(dAtA[i:], m.ClientId)

i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ClientId)))

i--

dAtA[i] = 0x12

}

if len(m.Secret) > 0 {

i -= len(m.Secret)

copy(dAtA[i:], m.Secret)

i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Secret)))

i--

dAtA[i] = 0xa

}

return len(dAtA) - i, nil

}

func (m *CloudSource) MarshalVT() (dAtA []byte, err error) {

if m == nil {

return nil, nil

}

size := m.SizeVT()

dAtA = make([]byte, size)

n, err := m.MarshalToSizedBufferVT(dAtA[:size])

if err != nil {

return nil, err

}

return dAtA[:n], nil

}

func (m *CloudSource) MarshalToVT(dAtA []byte) (int, error) {

size := m.SizeVT()

return m.MarshalToSizedBufferVT(dAtA[:size])

}

func (m *CloudSource) MarshalToSizedBufferVT(dAtA []byte) (int, error) {

if m == nil {

return 0, nil

}

i := len(dAtA)

_ = i

var l int

_ = l

if m.unknownFields != nil {

i -= len(m.unknownFields)

copy(dAtA[i:], m.unknownFields)

}

if vtmsg, ok := m.Config.(interface {

MarshalToSizedBufferVT([]byte) (int, error)

}); ok {

size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i])

if err != nil {

return 0, err

}

i -= size

}

if m.SkipTestIntegration {

i--

if m.SkipTestIntegration {

dAtA[i] = 1

} else {

dAtA[i] = 0

}

i--

dAtA[i] = 0x28

}

if m.Credentials != nil {

size, err := m.Credentials.MarshalToSizedBufferVT(dAtA[:i])

if err != nil {

return 0, err

}

i -= size

i = protohelpers.EncodeVarint(dAtA, i, uint64(size))

i--

dAtA[i] = 0x22

}

if m.Type != 0 {

i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Type))

i--

dAtA[i] = 0x18

}

if len(m.Name) > 0 {

i -= len(m.Name)

copy(dAtA[i:], m.Name)

i = protohelpers.EncodeVarint(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 = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Id)))

i--

dAtA[i] = 0xa

}

return len(dAtA) - i, nil

}

func (m *CloudSource_PaladinCloud) MarshalToVT(dAtA []byte) (int, error) {

size := m.SizeVT()

return m.MarshalToSizedBufferVT(dAtA[:size])

}

func (m *CloudSource_PaladinCloud) MarshalToSizedBufferVT(dAtA []byte) (int, error) {

i := len(dAtA)

if m.PaladinCloud != nil {

size, err := m.PaladinCloud.MarshalToSizedBufferVT(dAtA[:i])

if err != nil {

return 0, err

}

i -= size

i = protohelpers.EncodeVarint(dAtA, i, uint64(size))

i--

dAtA[i] = 0x32

} else {

i = protohelpers.EncodeVarint(dAtA, i, 0)

i--

dAtA[i] = 0x32

}

return len(dAtA) - i, nil

}

func (m *CloudSource_Ocm) MarshalToVT(dAtA []byte) (int, error) {

size := m.SizeVT()

return m.MarshalToSizedBufferVT(dAtA[:size])

}

func (m *CloudSource_Ocm) MarshalToSizedBufferVT(dAtA []byte) (int, error) {

i := len(dAtA)

if m.Ocm != nil {

size, err := m.Ocm.MarshalToSizedBufferVT(dAtA[:i])

if err != nil {

return 0, err

}

i -= size

i = protohelpers.EncodeVarint(dAtA, i, uint64(size))

i--

dAtA[i] = 0x3a

} else {

i = protohelpers.EncodeVarint(dAtA, i, 0)

i--

dAtA[i] = 0x3a

}

return len(dAtA) - i, nil

}

func (m *PaladinCloudConfig) MarshalVT() (dAtA []byte, err error) {

if m == nil {

return nil, nil

}

size := m.SizeVT()

dAtA = make([]byte, size)

n, err := m.MarshalToSizedBufferVT(dAtA[:size])

if err != nil {

return nil, err

}

return dAtA[:n], nil

}

func (m *PaladinCloudConfig) MarshalToVT(dAtA []byte) (int, error) {

size := m.SizeVT()

return m.MarshalToSizedBufferVT(dAtA[:size])

}

func (m *PaladinCloudConfig) MarshalToSizedBufferVT(dAtA []byte) (int, error) {

if m == nil {

return 0, nil

}

i := len(dAtA)

_ = i

var l int

_ = l

if m.unknownFields != nil {

i -= len(m.unknownFields)

copy(dAtA[i:], m.unknownFields)

}

if len(m.Endpoint) > 0 {

i -= len(m.Endpoint)

copy(dAtA[i:], m.Endpoint)

i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Endpoint)))

i--

dAtA[i] = 0xa

}

return len(dAtA) - i, nil

}

func (m *OCMConfig) MarshalVT() (dAtA []byte, err error) {

if m == nil {

return nil, nil

}

size := m.SizeVT()

dAtA = make([]byte, size)

n, err := m.MarshalToSizedBufferVT(dAtA[:size])

if err != nil {

return nil, err

}

return dAtA[:n], nil

}

func (m *OCMConfig) MarshalToVT(dAtA []byte) (int, error) {

size := m.SizeVT()

return m.MarshalToSizedBufferVT(dAtA[:size])

}

func (m *OCMConfig) MarshalToSizedBufferVT(dAtA []byte) (int, error) {

if m == nil {

return 0, nil

}

i := len(dAtA)

_ = i

var l int

_ = l

if m.unknownFields != nil {

i -= len(m.unknownFields)

copy(dAtA[i:], m.unknownFields)

}

if len(m.Endpoint) > 0 {

i -= len(m.Endpoint)

copy(dAtA[i:], m.Endpoint)

i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Endpoint)))

i--

dAtA[i] = 0xa

}

return len(dAtA) - i, nil

}

func (m *CloudSource_Credentials) SizeVT() (n int) {

if m == nil {

return 0

}

var l int

_ = l

l = len(m.Secret)

if l > 0 {

n += 1 + l + protohelpers.SizeOfVarint(uint64(l))

}

l = len(m.ClientId)

if l > 0 {

n += 1 + l + protohelpers.SizeOfVarint(uint64(l))

}

l = len(m.ClientSecret)

if l > 0 {

n += 1 + l + protohelpers.SizeOfVarint(uint64(l))

}

n += len(m.unknownFields)

return n

}

func (m *CloudSource) SizeVT() (n int) {

if m == nil {

return 0

}

var l int

_ = l

l = len(m.Id)

if l > 0 {

n += 1 + l + protohelpers.SizeOfVarint(uint64(l))

}

l = len(m.Name)

if l > 0 {

n += 1 + l + protohelpers.SizeOfVarint(uint64(l))

}

if m.Type != 0 {

n += 1 + protohelpers.SizeOfVarint(uint64(m.Type))

}

if m.Credentials != nil {

l = m.Credentials.SizeVT()

n += 1 + l + protohelpers.SizeOfVarint(uint64(l))

}

if m.SkipTestIntegration {

n += 2

}

if vtmsg, ok := m.Config.(interface{ SizeVT() int }); ok {

n += vtmsg.SizeVT()

}

n += len(m.unknownFields)

return n

}

func (m *CloudSource_PaladinCloud) SizeVT() (n int) {

if m == nil {

return 0

}

var l int

_ = l

if m.PaladinCloud != nil {

l = m.PaladinCloud.SizeVT()

n += 1 + l + protohelpers.SizeOfVarint(uint64(l))

} else {

n += 2

}

return n

}

func (m *CloudSource_Ocm) SizeVT() (n int) {

if m == nil {

return 0

}

var l int

_ = l

if m.Ocm != nil {

l = m.Ocm.SizeVT()

n += 1 + l + protohelpers.SizeOfVarint(uint64(l))

} else {

n += 2

}

return n

}

func (m *PaladinCloudConfig) SizeVT() (n int) {

if m == nil {

return 0

}

var l int

_ = l

l = len(m.Endpoint)

if l > 0 {

n += 1 + l + protohelpers.SizeOfVarint(uint64(l))

}

n += len(m.unknownFields)

return n

}

func (m *OCMConfig) SizeVT() (n int) {

if m == nil {

return 0

}

var l int

_ = l

l = len(m.Endpoint)

if l > 0 {

n += 1 + l + protohelpers.SizeOfVarint(uint64(l))

}

n += len(m.unknownFields)

return n

}

func (m *CloudSource_Credentials) UnmarshalVT(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 protohelpers.ErrIntOverflow

}

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: CloudSource_Credentials: wiretype end group for non-group")

}

if fieldNum <= 0 {

return fmt.Errorf("proto: CloudSource_Credentials: illegal tag %d (wire type %d)", fieldNum, wire)

}

switch fieldNum {

case 1:

if wireType != 2 {

return fmt.Errorf("proto: wrong wireType = %d for field Secret", wireType)

}

var stringLen uint64

for shift := uint(0); ; shift += 7 {

if shift >= 64 {

return protohelpers.ErrIntOverflow

}

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 protohelpers.ErrInvalidLength

}

postIndex := iNdEx + intStringLen

if postIndex < 0 {

return protohelpers.ErrInvalidLength

}

if postIndex > l {

return io.ErrUnexpectedEOF

}

m.Secret = string(dAtA[iNdEx:postIndex])

iNdEx = postIndex

case 2:

if wireType != 2 {

return fmt.Errorf("proto: wrong wireType = %d for field ClientId", wireType)

}

var stringLen uint64

for shift := uint(0); ; shift += 7 {

if shift >= 64 {

return protohelpers.ErrIntOverflow

}

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 protohelpers.ErrInvalidLength

}

postIndex := iNdEx + intStringLen

if postIndex < 0 {

return protohelpers.ErrInvalidLength

}

if postIndex > l {

return io.ErrUnexpectedEOF

}

m.ClientId = string(dAtA[iNdEx:postIndex])

iNdEx = postIndex

case 3:

if wireType != 2 {

return fmt.Errorf("proto: wrong wireType = %d for field ClientSecret", wireType)

}

var stringLen uint64

for shift := uint(0); ; shift += 7 {

if shift >= 64 {

return protohelpers.ErrIntOverflow

}

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 protohelpers.ErrInvalidLength

}

postIndex := iNdEx + intStringLen

if postIndex < 0 {

return protohelpers.ErrInvalidLength

}

if postIndex > l {

return io.ErrUnexpectedEOF

}

m.ClientSecret = string(dAtA[iNdEx:postIndex])

iNdEx = postIndex

default:

iNdEx = preIndex

skippy, err := protohelpers.Skip(dAtA[iNdEx:])

if err != nil {

return err

}

if (skippy < 0) || (iNdEx+skippy) < 0 {

return protohelpers.ErrInvalidLength

}

if (iNdEx + skippy) > l {

return io.ErrUnexpectedEOF

}

m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)

iNdEx += skippy

}

}

if iNdEx > l {

return io.ErrUnexpectedEOF

}

return nil

}

func (m *CloudSource) UnmarshalVT(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 protohelpers.ErrIntOverflow

}

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: CloudSource: wiretype end group for non-group")

}

if fieldNum <= 0 {

return fmt.Errorf("proto: CloudSource: 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 protohelpers.ErrIntOverflow

}

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 protohelpers.ErrInvalidLength

}

postIndex := iNdEx + intStringLen

if postIndex < 0 {

return protohelpers.ErrInvalidLength

}

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 protohelpers.ErrIntOverflow

}

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 protohelpers.ErrInvalidLength

}

postIndex := iNdEx + intStringLen

if postIndex < 0 {

return protohelpers.ErrInvalidLength

}

if postIndex > l {

return io.ErrUnexpectedEOF

}

m.Name = string(dAtA[iNdEx:postIndex])

iNdEx = postIndex

case 3:

if wireType != 0 {

return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)

}

m.Type = 0

for shift := uint(0); ; shift += 7 {

if shift >= 64 {

return protohelpers.ErrIntOverflow

}

if iNdEx >= l {

return io.ErrUnexpectedEOF

}

b := dAtA[iNdEx]

iNdEx++

m.Type |= CloudSource_Type(b&0x7F) << shift

if b < 0x80 {

break

}

}

case 4:

if wireType != 2 {

return fmt.Errorf("proto: wrong wireType = %d for field Credentials", wireType)

}

var msglen int

for shift := uint(0); ; shift += 7 {

if shift >= 64 {

return protohelpers.ErrIntOverflow

}

if iNdEx >= l {

return io.ErrUnexpectedEOF

}

b := dAtA[iNdEx]

iNdEx++

msglen |= int(b&0x7F) << shift

if b < 0x80 {

break

}

}

if msglen < 0 {

return protohelpers.ErrInvalidLength

}

postIndex := iNdEx + msglen

if postIndex < 0 {

return protohelpers.ErrInvalidLength

}

if postIndex > l {

return io.ErrUnexpectedEOF

}

if m.Credentials == nil {

m.Credentials = &CloudSource_Credentials{}

}

if err := m.Credentials.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {

return err

}

iNdEx = postIndex

case 5:

if wireType != 0 {

return fmt.Errorf("proto: wrong wireType = %d for field SkipTestIntegration", wireType)

}

var v int

for shift := uint(0); ; shift += 7 {

if shift >= 64 {

return protohelpers.ErrIntOverflow

}

if iNdEx >= l {

return io.ErrUnexpectedEOF

}

b := dAtA[iNdEx]

iNdEx++

v |= int(b&0x7F) << shift

if b < 0x80 {

break

}

}

m.SkipTestIntegration = bool(v != 0)

case 6:

if wireType != 2 {

return fmt.Errorf("proto: wrong wireType = %d for field PaladinCloud", wireType)

}

var msglen int

for shift := uint(0); ; shift += 7 {

if shift >= 64 {

return protohelpers.ErrIntOverflow

}

if iNdEx >= l {

return io.ErrUnexpectedEOF

}

b := dAtA[iNdEx]

iNdEx++

msglen |= int(b&0x7F) << shift

if b < 0x80 {

break

}

}

if msglen < 0 {

return protohelpers.ErrInvalidLength

}

postIndex := iNdEx + msglen

if postIndex < 0 {

return protohelpers.ErrInvalidLength

}

if postIndex > l {

return io.ErrUnexpectedEOF

}

if oneof, ok := m.Config.(*CloudSource_PaladinCloud); ok {

if err := oneof.PaladinCloud.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {

return err

}

} else {

v := &PaladinCloudConfig{}

if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {

return err

}

m.Config = &CloudSource_PaladinCloud{PaladinCloud: v}

}

iNdEx = postIndex

case 7: