models_app_links.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: desmos/profiles/v3/models_app_links.proto

package types

import (
	fmt "fmt"
	_ "github.com/cosmos/cosmos-proto"
	_ "github.com/cosmos/cosmos-sdk/types/tx/amino"
	_ "github.com/cosmos/gogoproto/gogoproto"
	proto "github.com/cosmos/gogoproto/proto"
	github_com_cosmos_gogoproto_types "github.com/cosmos/gogoproto/types"
	_ "google.golang.org/protobuf/types/known/timestamppb"
	io "io"
	math "math"
	math_bits "math/bits"
	time "time"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = 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

// ApplicationLinkState defines if an application link is in the following
// states: STARTED, ERRORED, SUCCESSFUL, TIMED_OUT
type ApplicationLinkState int32

const (
	// A link has just been initialized
	ApplicationLinkStateInitialized ApplicationLinkState = 0
	// A link has just started being verified
	AppLinkStateVerificationStarted ApplicationLinkState = 1
	// A link has errored during the verification process
	AppLinkStateVerificationError ApplicationLinkState = 2
	// A link has being verified successfully
	AppLinkStateVerificationSuccess ApplicationLinkState = 3
	// A link has timed out while waiting for the verification
	AppLinkStateVerificationTimedOut ApplicationLinkState = 4
)

var ApplicationLinkState_name = map[int32]string{
	0: "APPLICATION_LINK_STATE_INITIALIZED_UNSPECIFIED",
	1: "APPLICATION_LINK_STATE_VERIFICATION_STARTED",
	2: "APPLICATION_LINK_STATE_VERIFICATION_ERROR",
	3: "APPLICATION_LINK_STATE_VERIFICATION_SUCCESS",
	4: "APPLICATION_LINK_STATE_TIMED_OUT",
}

var ApplicationLinkState_value = map[string]int32{
	"APPLICATION_LINK_STATE_INITIALIZED_UNSPECIFIED": 0,
	"APPLICATION_LINK_STATE_VERIFICATION_STARTED":    1,
	"APPLICATION_LINK_STATE_VERIFICATION_ERROR":      2,
	"APPLICATION_LINK_STATE_VERIFICATION_SUCCESS":    3,
	"APPLICATION_LINK_STATE_TIMED_OUT":               4,
}

func (x ApplicationLinkState) String() string {
	return proto.EnumName(ApplicationLinkState_name, int32(x))
}

func (ApplicationLinkState) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_e02d86ea3253bfd9, []int{0}
}

// ApplicationLink contains the data of a link to a centralized application
type ApplicationLink struct {
	//  User to which the link is associated
	User string `protobuf:"bytes,1,opt,name=user,proto3" json:"user,omitempty" yaml:"user"`
	// Data contains the details of this specific link
	Data Data `protobuf:"bytes,2,opt,name=data,proto3" json:"data" yaml:"data"`
	// State of the link
	State ApplicationLinkState `protobuf:"varint,3,opt,name=state,proto3,enum=desmos.profiles.v3.ApplicationLinkState" json:"state,omitempty" yaml:"state"`
	// OracleRequest represents the request that has been made to the oracle
	OracleRequest OracleRequest `protobuf:"bytes,4,opt,name=oracle_request,json=oracleRequest,proto3" json:"oracle_request" yaml:"oracle_request"`
	// Data coming from the result of the verification.
	// Only available when the state is STATE_SUCCESS
	Result *Result `protobuf:"bytes,5,opt,name=result,proto3" json:"result,omitempty" yaml:"result"`
	// CreationTime represents the time in which the link was created
	CreationTime time.Time `protobuf:"bytes,6,opt,name=creation_time,json=creationTime,proto3,stdtime" json:"creation_time" yaml:"creation_time"`
	// ExpirationTime represents the time in which the link will expire
	ExpirationTime time.Time `protobuf:"bytes,7,opt,name=expiration_time,json=expirationTime,proto3,stdtime" json:"expiration_time" yaml:"expiration_time"`
}

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

var xxx_messageInfo_ApplicationLink proto.InternalMessageInfo

// Data contains the data associated to a specific user of a
// generic centralized application
type Data struct {
	// The application name (eg. Twitter, GitHub, etc)
	Application string `protobuf:"bytes,1,opt,name=application,proto3" json:"application,omitempty" yaml:"application"`
	// Username on the application (eg. Twitter tag, GitHub profile, etc)
	Username string `protobuf:"bytes,2,opt,name=username,proto3" json:"username,omitempty" yaml:"username"`
}

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

var xxx_messageInfo_Data proto.InternalMessageInfo

// OracleRequest represents a generic oracle request used to
// verify the ownership of a centralized application account
type OracleRequest struct {
	// ID is the ID of the request
	ID uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty" yaml:"id"`
	// OracleScriptID is ID of an oracle script
	OracleScriptID uint64 `protobuf:"varint,2,opt,name=oracle_script_id,json=oracleScriptId,proto3" json:"oracle_script_id,omitempty" yaml:"oracle_script_id"`
	// CallData contains the data used to perform the oracle request
	CallData OracleRequest_CallData `protobuf:"bytes,3,opt,name=call_data,json=callData,proto3" json:"call_data" yaml:"call_data"`
	// ClientID represents the ID of the client that has called the oracle script
	ClientID string `protobuf:"bytes,4,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty" yaml:"client_id"`
}

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

var xxx_messageInfo_OracleRequest proto.InternalMessageInfo

// CallData contains the data sent to a single oracle request in order to
// verify the ownership of a centralized application by a Desmos profile
type OracleRequest_CallData struct {
	// The application for which the ownership should be verified
	Application string `protobuf:"bytes,1,opt,name=application,proto3" json:"application,omitempty" yaml:"application"`
	// The hex encoded call data that should be used to verify the application
	// account ownership
	CallData string `protobuf:"bytes,2,opt,name=call_data,json=callData,proto3" json:"call_data,omitempty" yaml:"call_data"`
}

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

var xxx_messageInfo_OracleRequest_CallData proto.InternalMessageInfo

func (m *OracleRequest_CallData) GetApplication() string {
	if m != nil {
		return m.Application
	}
	return ""
}

func (m *OracleRequest_CallData) GetCallData() string {
	if m != nil {
		return m.CallData
	}
	return ""
}

// Result represents a verification result
type Result struct {
	// sum is the oneof that specifies whether this represents a success or
	// failure result
	//
	// Types that are valid to be assigned to Sum:
	//
	//	*Result_Success_
	//	*Result_Failed_
	Sum isResult_Sum `protobuf_oneof:"sum"`
}

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

var xxx_messageInfo_Result proto.InternalMessageInfo

type isResult_Sum interface {
	isResult_Sum()
	Equal(interface{}) bool
	MarshalTo([]byte) (int, error)
	Size() int
}

type Result_Success_ struct {
	Success *Result_Success `protobuf:"bytes,1,opt,name=success,proto3,oneof" json:"success,omitempty"`
}
type Result_Failed_ struct {
	Failed *Result_Failed `protobuf:"bytes,2,opt,name=failed,proto3,oneof" json:"failed,omitempty"`
}

func (*Result_Success_) isResult_Sum() {}
func (*Result_Failed_) isResult_Sum()  {}

func (m *Result) GetSum() isResult_Sum {
	if m != nil {
		return m.Sum
	}
	return nil
}

func (m *Result) GetSuccess() *Result_Success {
	if x, ok := m.GetSum().(*Result_Success_); ok {
		return x.Success
	}
	return nil
}

func (m *Result) GetFailed() *Result_Failed {
	if x, ok := m.GetSum().(*Result_Failed_); ok {
		return x.Failed
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*Result) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*Result_Success_)(nil),
		(*Result_Failed_)(nil),
	}
}

// Success is the result of an application link that has been successfully
// verified
type Result_Success struct {
	// Hex-encoded value that has be signed by the profile
	Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty" yaml:"value"`
	// Hex-encoded signature that has been produced by signing the value
	Signature string `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty" yaml:"signature"`
}

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

var xxx_messageInfo_Result_Success proto.InternalMessageInfo

// Failed is the result of an application link that has not been verified
// successfully
type Result_Failed struct {
	// Error that is associated with the failure
	Error string `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty" yaml:"error"`
}

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

var xxx_messageInfo_Result_Failed proto.InternalMessageInfo

func init() {
	proto.RegisterEnum("desmos.profiles.v3.ApplicationLinkState", ApplicationLinkState_name, ApplicationLinkState_value)
	proto.RegisterType((*ApplicationLink)(nil), "desmos.profiles.v3.ApplicationLink")
	proto.RegisterType((*Data)(nil), "desmos.profiles.v3.Data")
	proto.RegisterType((*OracleRequest)(nil), "desmos.profiles.v3.OracleRequest")
	proto.RegisterType((*OracleRequest_CallData)(nil), "desmos.profiles.v3.OracleRequest.CallData")
	proto.RegisterType((*Result)(nil), "desmos.profiles.v3.Result")
	proto.RegisterType((*Result_Success)(nil), "desmos.profiles.v3.Result.Success")
	proto.RegisterType((*Result_Failed)(nil), "desmos.profiles.v3.Result.Failed")
}

func init() {
	proto.RegisterFile("desmos/profiles/v3/models_app_links.proto", fileDescriptor_e02d86ea3253bfd9)
}

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

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

	that1, ok := that.(*ApplicationLink)
	if !ok {
		that2, ok := that.(ApplicationLink)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.User != that1.User {
		return false
	}
	if !this.Data.Equal(&that1.Data) {
		return false
	}
	if this.State != that1.State {
		return false
	}
	if !this.OracleRequest.Equal(&that1.OracleRequest) {
		return false
	}
	if !this.Result.Equal(that1.Result) {
		return false
	}
	if !this.CreationTime.Equal(that1.CreationTime) {
		return false
	}
	if !this.ExpirationTime.Equal(that1.ExpirationTime) {
		return false
	}
	return true
}
func (this *Data) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Data)
	if !ok {
		that2, ok := that.(Data)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Application != that1.Application {
		return false
	}
	if this.Username != that1.Username {
		return false
	}
	return true
}
func (this *OracleRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*OracleRequest)
	if !ok {
		that2, ok := that.(OracleRequest)
		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.OracleScriptID != that1.OracleScriptID {
		return false
	}
	if !this.CallData.Equal(&that1.CallData) {
		return false
	}
	if this.ClientID != that1.ClientID {
		return false
	}
	return true
}
func (this *OracleRequest_CallData) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*OracleRequest_CallData)
	if !ok {
		that2, ok := that.(OracleRequest_CallData)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Application != that1.Application {
		return false
	}
	if this.CallData != that1.CallData {
		return false
	}
	return true
}
func (this *Result) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

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

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

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

	that1, ok := that.(*Result_Success)
	if !ok {
		that2, ok := that.(Result_Success)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Value != that1.Value {
		return false
	}
	if this.Signature != that1.Signature {
		return false
	}
	return true
}
func (this *Result_Failed) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Result_Failed)
	if !ok {
		that2, ok := that.(Result_Failed)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Error != that1.Error {
		return false
	}
	return true
}
func (m *ApplicationLink) 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 *ApplicationLink) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ApplicationLink) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	n1, err1 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.ExpirationTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.ExpirationTime):])
	if err1 != nil {
		return 0, err1
	}
	i -= n1
	i = encodeVarintModelsAppLinks(dAtA, i, uint64(n1))
	i--
	dAtA[i] = 0x3a
	n2, err2 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.CreationTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.CreationTime):])
	if err2 != nil {
		return 0, err2
	}
	i -= n2
	i = encodeVarintModelsAppLinks(dAtA, i, uint64(n2))
	i--
	dAtA[i] = 0x32
	if m.Result != nil {
		{
			size, err := m.Result.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModelsAppLinks(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	{
		size, err := m.OracleRequest.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintModelsAppLinks(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if m.State != 0 {
		i = encodeVarintModelsAppLinks(dAtA, i, uint64(m.State))
		i--
		dAtA[i] = 0x18
	}
	{
		size, err := m.Data.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintModelsAppLinks(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.User) > 0 {
		i -= len(m.User)
		copy(dAtA[i:], m.User)
		i = encodeVarintModelsAppLinks(dAtA, i, uint64(len(m.User)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Data) 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 *Data) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Data) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Username) > 0 {
		i -= len(m.Username)
		copy(dAtA[i:], m.Username)
		i = encodeVarintModelsAppLinks(dAtA, i, uint64(len(m.Username)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Application) > 0 {
		i -= len(m.Application)
		copy(dAtA[i:], m.Application)
		i = encodeVarintModelsAppLinks(dAtA, i, uint64(len(m.Application)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *OracleRequest) 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 *OracleRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *OracleRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ClientID) > 0 {
		i -= len(m.ClientID)
		copy(dAtA[i:], m.ClientID)
		i = encodeVarintModelsAppLinks(dAtA, i, uint64(len(m.ClientID)))
		i--
		dAtA[i] = 0x22
	}
	{
		size, err := m.CallData.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintModelsAppLinks(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if m.OracleScriptID != 0 {
		i = encodeVarintModelsAppLinks(dAtA, i, uint64(m.OracleScriptID))
		i--
		dAtA[i] = 0x10
	}
	if m.ID != 0 {
		i = encodeVarintModelsAppLinks(dAtA, i, uint64(m.ID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *OracleRequest_CallData) 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 *OracleRequest_CallData) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *OracleRequest_CallData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.CallData) > 0 {
		i -= len(m.CallData)
		copy(dAtA[i:], m.CallData)
		i = encodeVarintModelsAppLinks(dAtA, i, uint64(len(m.CallData)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Application) > 0 {
		i -= len(m.Application)
		copy(dAtA[i:], m.Application)
		i = encodeVarintModelsAppLinks(dAtA, i, uint64(len(m.Application)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Result) 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 *Result) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *Result_Success_) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Success != nil {
		{
			size, err := m.Success.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModelsAppLinks(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *Result_Failed_) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Result_Failed_) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Failed != nil {
		{
			size, err := m.Failed.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModelsAppLinks(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *Result_Success) 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 *Result_Success) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Result_Success) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Signature) > 0 {
		i -= len(m.Signature)
		copy(dAtA[i:], m.Signature)
		i = encodeVarintModelsAppLinks(dAtA, i, uint64(len(m.Signature)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Value) > 0 {
		i -= len(m.Value)
		copy(dAtA[i:], m.Value)
		i = encodeVarintModelsAppLinks(dAtA, i, uint64(len(m.Value)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Result_Failed) 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 *Result_Failed) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Result_Failed) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Error) > 0 {
		i -= len(m.Error)
		copy(dAtA[i:], m.Error)
		i = encodeVarintModelsAppLinks(dAtA, i, uint64(len(m.Error)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintModelsAppLinks(dAtA []byte, offset int, v uint64) int {
	offset -= sovModelsAppLinks(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *ApplicationLink) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.User)
	if l > 0 {
		n += 1 + l + sovModelsAppLinks(uint64(l))
	}
	l = m.Data.Size()
	n += 1 + l + sovModelsAppLinks(uint64(l))
	if m.State != 0 {
		n += 1 + sovModelsAppLinks(uint64(m.State))
	}
	l = m.OracleRequest.Size()
	n += 1 + l + sovModelsAppLinks(uint64(l))
	if m.Result != nil {
		l = m.Result.Size()
		n += 1 + l + sovModelsAppLinks(uint64(l))
	}
	l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.CreationTime)
	n += 1 + l + sovModelsAppLinks(uint64(l))
	l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.ExpirationTime)
	n += 1 + l + sovModelsAppLinks(uint64(l))
	return n
}

func (m *Data) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Application)
	if l > 0 {
		n += 1 + l + sovModelsAppLinks(uint64(l))
	}
	l = len(m.Username)
	if l > 0 {
		n += 1 + l + sovModelsAppLinks(uint64(l))
	}
	return n
}

func (m *OracleRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ID != 0 {
		n += 1 + sovModelsAppLinks(uint64(m.ID))
	}
	if m.OracleScriptID != 0 {
		n += 1 + sovModelsAppLinks(uint64(m.OracleScriptID))
	}
	l = m.CallData.Size()
	n += 1 + l + sovModelsAppLinks(uint64(l))
	l = len(m.ClientID)
	if l > 0 {
		n += 1 + l + sovModelsAppLinks(uint64(l))
	}
	return n
}

func (m *OracleRequest_CallData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Application)
	if l > 0 {
		n += 1 + l + sovModelsAppLinks(uint64(l))
	}
	l = len(m.CallData)
	if l > 0 {
		n += 1 + l + sovModelsAppLinks(uint64(l))
	}
	return n
}

func (m *Result) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Sum != nil {
		n += m.Sum.Size()
	}
	return n
}

func (m *Result_Success_) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Success != nil {
		l = m.Success.Size()
		n += 1 + l + sovModelsAppLinks(uint64(l))
	}
	return n
}
func (m *Result_Failed_) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Failed != nil {
		l = m.Failed.Size()
		n += 1 + l + sovModelsAppLinks(uint64(l))
	}
	return n
}
func (m *Result_Success) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovModelsAppLinks(uint64(l))
	}
	l = len(m.Signature)
	if l > 0 {
		n += 1 + l + sovModelsAppLinks(uint64(l))
	}
	return n
}

func (m *Result_Failed) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Error)
	if l > 0 {
		n += 1 + l + sovModelsAppLinks(uint64(l))
	}
	return n
}

func sovModelsAppLinks(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozModelsAppLinks(x uint64) (n int) {
	return sovModelsAppLinks(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *ApplicationLink) 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 ErrIntOverflowModelsAppLinks
			}
			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: ApplicationLink: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ApplicationLink: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field User", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModelsAppLinks
				}
				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 ErrInvalidLengthModelsAppLinks
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModelsAppLinks
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.User = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModelsAppLinks
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModelsAppLinks
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModelsAppLinks
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			m.State = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModelsAppLinks
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.State |= ApplicationLinkState(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OracleRequest", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModelsAppLinks
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModelsAppLinks
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModelsAppLinks
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.OracleRequest.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModelsAppLinks
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModelsAppLinks
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModelsAppLinks
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Result == nil {
				m.Result = &Result{}
			}
			if err := m.Result.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreationTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModelsAppLinks
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModelsAppLinks
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModelsAppLinks
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.CreationTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExpirationTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModelsAppLinks
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModelsAppLinks
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModelsAppLinks
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.ExpirationTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModelsAppLinks(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModelsAppLinks
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipModelsAppLinks(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, ErrIntOverflowModelsAppLinks
			}
			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, ErrIntOverflowModelsAppLinks
				}
				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, ErrIntOverflowModelsAppLinks
				}
				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, ErrInvalidLengthModelsAppLinks
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupModelsAppLinks
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthModelsAppLinks
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthModelsAppLinks        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowModelsAppLinks          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupModelsAppLinks = fmt.Errorf("proto: unexpected end of group")
)