From b41fd3fbf55d1c516a1f5f695a8e782ce154b494 Mon Sep 17 00:00:00 2001 From: Aaron Craelius Date: Mon, 12 Sep 2022 11:51:08 -0400 Subject: [PATCH] feat: add auto-cli customization options (#11763) * feat(cli/v2): add command & flag proto options * WIP * docs * update * change name to use * update use * rename to autocli * updates * switch to (hopefully) more intuitive design * docs * updates * updates * add flag_options example --- api/cosmos/autocli/v1/options.pulsar.go | 4971 ++++++++++++++++++++++ client/v2/cli/testdata/bank_example.yaml | 28 + proto/cosmos/autocli/v1/options.proto | 129 + scripts/protocgen.sh | 2 +- 4 files changed, 5129 insertions(+), 1 deletion(-) create mode 100644 api/cosmos/autocli/v1/options.pulsar.go create mode 100644 client/v2/cli/testdata/bank_example.yaml create mode 100644 proto/cosmos/autocli/v1/options.proto diff --git a/api/cosmos/autocli/v1/options.pulsar.go b/api/cosmos/autocli/v1/options.pulsar.go new file mode 100644 index 000000000..227c194d0 --- /dev/null +++ b/api/cosmos/autocli/v1/options.pulsar.go @@ -0,0 +1,4971 @@ +// Code generated by protoc-gen-go-pulsar. DO NOT EDIT. +package autocliv1 + +import ( + fmt "fmt" + runtime "github.com/cosmos/cosmos-proto/runtime" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoiface "google.golang.org/protobuf/runtime/protoiface" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + _ "google.golang.org/protobuf/types/descriptorpb" + io "io" + reflect "reflect" + sort "sort" + sync "sync" +) + +var ( + md_ModuleOptions protoreflect.MessageDescriptor + fd_ModuleOptions_tx protoreflect.FieldDescriptor + fd_ModuleOptions_query protoreflect.FieldDescriptor +) + +func init() { + file_cosmos_autocli_v1_options_proto_init() + md_ModuleOptions = File_cosmos_autocli_v1_options_proto.Messages().ByName("ModuleOptions") + fd_ModuleOptions_tx = md_ModuleOptions.Fields().ByName("tx") + fd_ModuleOptions_query = md_ModuleOptions.Fields().ByName("query") +} + +var _ protoreflect.Message = (*fastReflection_ModuleOptions)(nil) + +type fastReflection_ModuleOptions ModuleOptions + +func (x *ModuleOptions) ProtoReflect() protoreflect.Message { + return (*fastReflection_ModuleOptions)(x) +} + +func (x *ModuleOptions) slowProtoReflect() protoreflect.Message { + mi := &file_cosmos_autocli_v1_options_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_ModuleOptions_messageType fastReflection_ModuleOptions_messageType +var _ protoreflect.MessageType = fastReflection_ModuleOptions_messageType{} + +type fastReflection_ModuleOptions_messageType struct{} + +func (x fastReflection_ModuleOptions_messageType) Zero() protoreflect.Message { + return (*fastReflection_ModuleOptions)(nil) +} +func (x fastReflection_ModuleOptions_messageType) New() protoreflect.Message { + return new(fastReflection_ModuleOptions) +} +func (x fastReflection_ModuleOptions_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_ModuleOptions +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_ModuleOptions) Descriptor() protoreflect.MessageDescriptor { + return md_ModuleOptions +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_ModuleOptions) Type() protoreflect.MessageType { + return _fastReflection_ModuleOptions_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_ModuleOptions) New() protoreflect.Message { + return new(fastReflection_ModuleOptions) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_ModuleOptions) Interface() protoreflect.ProtoMessage { + return (*ModuleOptions)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_ModuleOptions) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Tx != nil { + value := protoreflect.ValueOfMessage(x.Tx.ProtoReflect()) + if !f(fd_ModuleOptions_tx, value) { + return + } + } + if x.Query != nil { + value := protoreflect.ValueOfMessage(x.Query.ProtoReflect()) + if !f(fd_ModuleOptions_query, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_ModuleOptions) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "cosmos.autocli.v1.ModuleOptions.tx": + return x.Tx != nil + case "cosmos.autocli.v1.ModuleOptions.query": + return x.Query != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.autocli.v1.ModuleOptions")) + } + panic(fmt.Errorf("message cosmos.autocli.v1.ModuleOptions does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_ModuleOptions) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "cosmos.autocli.v1.ModuleOptions.tx": + x.Tx = nil + case "cosmos.autocli.v1.ModuleOptions.query": + x.Query = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.autocli.v1.ModuleOptions")) + } + panic(fmt.Errorf("message cosmos.autocli.v1.ModuleOptions does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_ModuleOptions) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "cosmos.autocli.v1.ModuleOptions.tx": + value := x.Tx + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "cosmos.autocli.v1.ModuleOptions.query": + value := x.Query + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.autocli.v1.ModuleOptions")) + } + panic(fmt.Errorf("message cosmos.autocli.v1.ModuleOptions does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_ModuleOptions) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "cosmos.autocli.v1.ModuleOptions.tx": + x.Tx = value.Message().Interface().(*ServiceCommandDescriptor) + case "cosmos.autocli.v1.ModuleOptions.query": + x.Query = value.Message().Interface().(*ServiceCommandDescriptor) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.autocli.v1.ModuleOptions")) + } + panic(fmt.Errorf("message cosmos.autocli.v1.ModuleOptions does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_ModuleOptions) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.autocli.v1.ModuleOptions.tx": + if x.Tx == nil { + x.Tx = new(ServiceCommandDescriptor) + } + return protoreflect.ValueOfMessage(x.Tx.ProtoReflect()) + case "cosmos.autocli.v1.ModuleOptions.query": + if x.Query == nil { + x.Query = new(ServiceCommandDescriptor) + } + return protoreflect.ValueOfMessage(x.Query.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.autocli.v1.ModuleOptions")) + } + panic(fmt.Errorf("message cosmos.autocli.v1.ModuleOptions does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_ModuleOptions) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.autocli.v1.ModuleOptions.tx": + m := new(ServiceCommandDescriptor) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "cosmos.autocli.v1.ModuleOptions.query": + m := new(ServiceCommandDescriptor) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.autocli.v1.ModuleOptions")) + } + panic(fmt.Errorf("message cosmos.autocli.v1.ModuleOptions does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_ModuleOptions) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in cosmos.autocli.v1.ModuleOptions", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_ModuleOptions) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_ModuleOptions) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_ModuleOptions) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_ModuleOptions) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*ModuleOptions) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + if x.Tx != nil { + l = options.Size(x.Tx) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.Query != nil { + l = options.Size(x.Query) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*ModuleOptions) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if x.Query != nil { + encoded, err := options.Marshal(x.Query) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x12 + } + if x.Tx != nil { + encoded, err := options.Marshal(x.Tx) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0xa + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*ModuleOptions) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ModuleOptions: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ModuleOptions: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Tx", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.Tx == nil { + x.Tx = &ServiceCommandDescriptor{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Tx); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Query", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.Query == nil { + x.Query = &ServiceCommandDescriptor{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Query); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var _ protoreflect.List = (*_ServiceCommandDescriptor_2_list)(nil) + +type _ServiceCommandDescriptor_2_list struct { + list *[]*RpcCommandOptions +} + +func (x *_ServiceCommandDescriptor_2_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_ServiceCommandDescriptor_2_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_ServiceCommandDescriptor_2_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*RpcCommandOptions) + (*x.list)[i] = concreteValue +} + +func (x *_ServiceCommandDescriptor_2_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*RpcCommandOptions) + *x.list = append(*x.list, concreteValue) +} + +func (x *_ServiceCommandDescriptor_2_list) AppendMutable() protoreflect.Value { + v := new(RpcCommandOptions) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_ServiceCommandDescriptor_2_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_ServiceCommandDescriptor_2_list) NewElement() protoreflect.Value { + v := new(RpcCommandOptions) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_ServiceCommandDescriptor_2_list) IsValid() bool { + return x.list != nil +} + +var _ protoreflect.Map = (*_ServiceCommandDescriptor_3_map)(nil) + +type _ServiceCommandDescriptor_3_map struct { + m *map[string]*ServiceCommandDescriptor +} + +func (x *_ServiceCommandDescriptor_3_map) Len() int { + if x.m == nil { + return 0 + } + return len(*x.m) +} + +func (x *_ServiceCommandDescriptor_3_map) Range(f func(protoreflect.MapKey, protoreflect.Value) bool) { + if x.m == nil { + return + } + for k, v := range *x.m { + mapKey := (protoreflect.MapKey)(protoreflect.ValueOfString(k)) + mapValue := protoreflect.ValueOfMessage(v.ProtoReflect()) + if !f(mapKey, mapValue) { + break + } + } +} + +func (x *_ServiceCommandDescriptor_3_map) Has(key protoreflect.MapKey) bool { + if x.m == nil { + return false + } + keyUnwrapped := key.String() + concreteValue := keyUnwrapped + _, ok := (*x.m)[concreteValue] + return ok +} + +func (x *_ServiceCommandDescriptor_3_map) Clear(key protoreflect.MapKey) { + if x.m == nil { + return + } + keyUnwrapped := key.String() + concreteKey := keyUnwrapped + delete(*x.m, concreteKey) +} + +func (x *_ServiceCommandDescriptor_3_map) Get(key protoreflect.MapKey) protoreflect.Value { + if x.m == nil { + return protoreflect.Value{} + } + keyUnwrapped := key.String() + concreteKey := keyUnwrapped + v, ok := (*x.m)[concreteKey] + if !ok { + return protoreflect.Value{} + } + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_ServiceCommandDescriptor_3_map) Set(key protoreflect.MapKey, value protoreflect.Value) { + if !key.IsValid() || !value.IsValid() { + panic("invalid key or value provided") + } + keyUnwrapped := key.String() + concreteKey := keyUnwrapped + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*ServiceCommandDescriptor) + (*x.m)[concreteKey] = concreteValue +} + +func (x *_ServiceCommandDescriptor_3_map) Mutable(key protoreflect.MapKey) protoreflect.Value { + keyUnwrapped := key.String() + concreteKey := keyUnwrapped + v, ok := (*x.m)[concreteKey] + if ok { + return protoreflect.ValueOfMessage(v.ProtoReflect()) + } + newValue := new(ServiceCommandDescriptor) + (*x.m)[concreteKey] = newValue + return protoreflect.ValueOfMessage(newValue.ProtoReflect()) +} + +func (x *_ServiceCommandDescriptor_3_map) NewValue() protoreflect.Value { + v := new(ServiceCommandDescriptor) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_ServiceCommandDescriptor_3_map) IsValid() bool { + return x.m != nil +} + +var ( + md_ServiceCommandDescriptor protoreflect.MessageDescriptor + fd_ServiceCommandDescriptor_service protoreflect.FieldDescriptor + fd_ServiceCommandDescriptor_rpc_command_options protoreflect.FieldDescriptor + fd_ServiceCommandDescriptor_sub_commands protoreflect.FieldDescriptor +) + +func init() { + file_cosmos_autocli_v1_options_proto_init() + md_ServiceCommandDescriptor = File_cosmos_autocli_v1_options_proto.Messages().ByName("ServiceCommandDescriptor") + fd_ServiceCommandDescriptor_service = md_ServiceCommandDescriptor.Fields().ByName("service") + fd_ServiceCommandDescriptor_rpc_command_options = md_ServiceCommandDescriptor.Fields().ByName("rpc_command_options") + fd_ServiceCommandDescriptor_sub_commands = md_ServiceCommandDescriptor.Fields().ByName("sub_commands") +} + +var _ protoreflect.Message = (*fastReflection_ServiceCommandDescriptor)(nil) + +type fastReflection_ServiceCommandDescriptor ServiceCommandDescriptor + +func (x *ServiceCommandDescriptor) ProtoReflect() protoreflect.Message { + return (*fastReflection_ServiceCommandDescriptor)(x) +} + +func (x *ServiceCommandDescriptor) slowProtoReflect() protoreflect.Message { + mi := &file_cosmos_autocli_v1_options_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_ServiceCommandDescriptor_messageType fastReflection_ServiceCommandDescriptor_messageType +var _ protoreflect.MessageType = fastReflection_ServiceCommandDescriptor_messageType{} + +type fastReflection_ServiceCommandDescriptor_messageType struct{} + +func (x fastReflection_ServiceCommandDescriptor_messageType) Zero() protoreflect.Message { + return (*fastReflection_ServiceCommandDescriptor)(nil) +} +func (x fastReflection_ServiceCommandDescriptor_messageType) New() protoreflect.Message { + return new(fastReflection_ServiceCommandDescriptor) +} +func (x fastReflection_ServiceCommandDescriptor_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_ServiceCommandDescriptor +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_ServiceCommandDescriptor) Descriptor() protoreflect.MessageDescriptor { + return md_ServiceCommandDescriptor +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_ServiceCommandDescriptor) Type() protoreflect.MessageType { + return _fastReflection_ServiceCommandDescriptor_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_ServiceCommandDescriptor) New() protoreflect.Message { + return new(fastReflection_ServiceCommandDescriptor) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_ServiceCommandDescriptor) Interface() protoreflect.ProtoMessage { + return (*ServiceCommandDescriptor)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_ServiceCommandDescriptor) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Service != "" { + value := protoreflect.ValueOfString(x.Service) + if !f(fd_ServiceCommandDescriptor_service, value) { + return + } + } + if len(x.RpcCommandOptions) != 0 { + value := protoreflect.ValueOfList(&_ServiceCommandDescriptor_2_list{list: &x.RpcCommandOptions}) + if !f(fd_ServiceCommandDescriptor_rpc_command_options, value) { + return + } + } + if len(x.SubCommands) != 0 { + value := protoreflect.ValueOfMap(&_ServiceCommandDescriptor_3_map{m: &x.SubCommands}) + if !f(fd_ServiceCommandDescriptor_sub_commands, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_ServiceCommandDescriptor) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "cosmos.autocli.v1.ServiceCommandDescriptor.service": + return x.Service != "" + case "cosmos.autocli.v1.ServiceCommandDescriptor.rpc_command_options": + return len(x.RpcCommandOptions) != 0 + case "cosmos.autocli.v1.ServiceCommandDescriptor.sub_commands": + return len(x.SubCommands) != 0 + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.autocli.v1.ServiceCommandDescriptor")) + } + panic(fmt.Errorf("message cosmos.autocli.v1.ServiceCommandDescriptor does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_ServiceCommandDescriptor) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "cosmos.autocli.v1.ServiceCommandDescriptor.service": + x.Service = "" + case "cosmos.autocli.v1.ServiceCommandDescriptor.rpc_command_options": + x.RpcCommandOptions = nil + case "cosmos.autocli.v1.ServiceCommandDescriptor.sub_commands": + x.SubCommands = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.autocli.v1.ServiceCommandDescriptor")) + } + panic(fmt.Errorf("message cosmos.autocli.v1.ServiceCommandDescriptor does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_ServiceCommandDescriptor) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "cosmos.autocli.v1.ServiceCommandDescriptor.service": + value := x.Service + return protoreflect.ValueOfString(value) + case "cosmos.autocli.v1.ServiceCommandDescriptor.rpc_command_options": + if len(x.RpcCommandOptions) == 0 { + return protoreflect.ValueOfList(&_ServiceCommandDescriptor_2_list{}) + } + listValue := &_ServiceCommandDescriptor_2_list{list: &x.RpcCommandOptions} + return protoreflect.ValueOfList(listValue) + case "cosmos.autocli.v1.ServiceCommandDescriptor.sub_commands": + if len(x.SubCommands) == 0 { + return protoreflect.ValueOfMap(&_ServiceCommandDescriptor_3_map{}) + } + mapValue := &_ServiceCommandDescriptor_3_map{m: &x.SubCommands} + return protoreflect.ValueOfMap(mapValue) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.autocli.v1.ServiceCommandDescriptor")) + } + panic(fmt.Errorf("message cosmos.autocli.v1.ServiceCommandDescriptor does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_ServiceCommandDescriptor) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "cosmos.autocli.v1.ServiceCommandDescriptor.service": + x.Service = value.Interface().(string) + case "cosmos.autocli.v1.ServiceCommandDescriptor.rpc_command_options": + lv := value.List() + clv := lv.(*_ServiceCommandDescriptor_2_list) + x.RpcCommandOptions = *clv.list + case "cosmos.autocli.v1.ServiceCommandDescriptor.sub_commands": + mv := value.Map() + cmv := mv.(*_ServiceCommandDescriptor_3_map) + x.SubCommands = *cmv.m + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.autocli.v1.ServiceCommandDescriptor")) + } + panic(fmt.Errorf("message cosmos.autocli.v1.ServiceCommandDescriptor does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_ServiceCommandDescriptor) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.autocli.v1.ServiceCommandDescriptor.rpc_command_options": + if x.RpcCommandOptions == nil { + x.RpcCommandOptions = []*RpcCommandOptions{} + } + value := &_ServiceCommandDescriptor_2_list{list: &x.RpcCommandOptions} + return protoreflect.ValueOfList(value) + case "cosmos.autocli.v1.ServiceCommandDescriptor.sub_commands": + if x.SubCommands == nil { + x.SubCommands = make(map[string]*ServiceCommandDescriptor) + } + value := &_ServiceCommandDescriptor_3_map{m: &x.SubCommands} + return protoreflect.ValueOfMap(value) + case "cosmos.autocli.v1.ServiceCommandDescriptor.service": + panic(fmt.Errorf("field service of message cosmos.autocli.v1.ServiceCommandDescriptor is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.autocli.v1.ServiceCommandDescriptor")) + } + panic(fmt.Errorf("message cosmos.autocli.v1.ServiceCommandDescriptor does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_ServiceCommandDescriptor) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.autocli.v1.ServiceCommandDescriptor.service": + return protoreflect.ValueOfString("") + case "cosmos.autocli.v1.ServiceCommandDescriptor.rpc_command_options": + list := []*RpcCommandOptions{} + return protoreflect.ValueOfList(&_ServiceCommandDescriptor_2_list{list: &list}) + case "cosmos.autocli.v1.ServiceCommandDescriptor.sub_commands": + m := make(map[string]*ServiceCommandDescriptor) + return protoreflect.ValueOfMap(&_ServiceCommandDescriptor_3_map{m: &m}) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.autocli.v1.ServiceCommandDescriptor")) + } + panic(fmt.Errorf("message cosmos.autocli.v1.ServiceCommandDescriptor does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_ServiceCommandDescriptor) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in cosmos.autocli.v1.ServiceCommandDescriptor", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_ServiceCommandDescriptor) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_ServiceCommandDescriptor) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_ServiceCommandDescriptor) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_ServiceCommandDescriptor) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*ServiceCommandDescriptor) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + l = len(x.Service) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if len(x.RpcCommandOptions) > 0 { + for _, e := range x.RpcCommandOptions { + l = options.Size(e) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + if len(x.SubCommands) > 0 { + SiZeMaP := func(k string, v *ServiceCommandDescriptor) { + l := 0 + if v != nil { + l = options.Size(v) + } + l += 1 + runtime.Sov(uint64(l)) + mapEntrySize := 1 + len(k) + runtime.Sov(uint64(len(k))) + l + n += mapEntrySize + 1 + runtime.Sov(uint64(mapEntrySize)) + } + if options.Deterministic { + sortme := make([]string, 0, len(x.SubCommands)) + for k := range x.SubCommands { + sortme = append(sortme, k) + } + sort.Strings(sortme) + for _, k := range sortme { + v := x.SubCommands[k] + SiZeMaP(k, v) + } + } else { + for k, v := range x.SubCommands { + SiZeMaP(k, v) + } + } + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*ServiceCommandDescriptor) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if len(x.SubCommands) > 0 { + MaRsHaLmAp := func(k string, v *ServiceCommandDescriptor) (protoiface.MarshalOutput, error) { + baseI := i + encoded, err := options.Marshal(v) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x12 + i -= len(k) + copy(dAtA[i:], k) + i = runtime.EncodeVarint(dAtA, i, uint64(len(k))) + i-- + dAtA[i] = 0xa + i = runtime.EncodeVarint(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x1a + return protoiface.MarshalOutput{}, nil + } + if options.Deterministic { + keysForSubCommands := make([]string, 0, len(x.SubCommands)) + for k := range x.SubCommands { + keysForSubCommands = append(keysForSubCommands, string(k)) + } + sort.Slice(keysForSubCommands, func(i, j int) bool { + return keysForSubCommands[i] < keysForSubCommands[j] + }) + for iNdEx := len(keysForSubCommands) - 1; iNdEx >= 0; iNdEx-- { + v := x.SubCommands[string(keysForSubCommands[iNdEx])] + out, err := MaRsHaLmAp(keysForSubCommands[iNdEx], v) + if err != nil { + return out, err + } + } + } else { + for k := range x.SubCommands { + v := x.SubCommands[k] + out, err := MaRsHaLmAp(k, v) + if err != nil { + return out, err + } + } + } + } + if len(x.RpcCommandOptions) > 0 { + for iNdEx := len(x.RpcCommandOptions) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.RpcCommandOptions[iNdEx]) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x12 + } + } + if len(x.Service) > 0 { + i -= len(x.Service) + copy(dAtA[i:], x.Service) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Service))) + i-- + dAtA[i] = 0xa + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*ServiceCommandDescriptor) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ServiceCommandDescriptor: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ServiceCommandDescriptor: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Service", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Service = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RpcCommandOptions", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.RpcCommandOptions = append(x.RpcCommandOptions, &RpcCommandOptions{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.RpcCommandOptions[len(x.RpcCommandOptions)-1]); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field SubCommands", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.SubCommands == nil { + x.SubCommands = make(map[string]*ServiceCommandDescriptor) + } + var mapkey string + var mapvalue *ServiceCommandDescriptor + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postStringIndexmapkey > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + } else if fieldNum == 2 { + var mapmsglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapmsglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if mapmsglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postmsgIndex := iNdEx + mapmsglen + if postmsgIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postmsgIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + mapvalue = &ServiceCommandDescriptor{} + if err := options.Unmarshal(dAtA[iNdEx:postmsgIndex], mapvalue); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postmsgIndex + } else { + iNdEx = entryPreIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > postIndex { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + x.SubCommands[mapkey] = mapvalue + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var _ protoreflect.List = (*_RpcCommandOptions_6_list)(nil) + +type _RpcCommandOptions_6_list struct { + list *[]string +} + +func (x *_RpcCommandOptions_6_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_RpcCommandOptions_6_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfString((*x.list)[i]) +} + +func (x *_RpcCommandOptions_6_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.String() + concreteValue := valueUnwrapped + (*x.list)[i] = concreteValue +} + +func (x *_RpcCommandOptions_6_list) Append(value protoreflect.Value) { + valueUnwrapped := value.String() + concreteValue := valueUnwrapped + *x.list = append(*x.list, concreteValue) +} + +func (x *_RpcCommandOptions_6_list) AppendMutable() protoreflect.Value { + panic(fmt.Errorf("AppendMutable can not be called on message RpcCommandOptions at list field Alias as it is not of Message kind")) +} + +func (x *_RpcCommandOptions_6_list) Truncate(n int) { + *x.list = (*x.list)[:n] +} + +func (x *_RpcCommandOptions_6_list) NewElement() protoreflect.Value { + v := "" + return protoreflect.ValueOfString(v) +} + +func (x *_RpcCommandOptions_6_list) IsValid() bool { + return x.list != nil +} + +var _ protoreflect.List = (*_RpcCommandOptions_7_list)(nil) + +type _RpcCommandOptions_7_list struct { + list *[]string +} + +func (x *_RpcCommandOptions_7_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_RpcCommandOptions_7_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfString((*x.list)[i]) +} + +func (x *_RpcCommandOptions_7_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.String() + concreteValue := valueUnwrapped + (*x.list)[i] = concreteValue +} + +func (x *_RpcCommandOptions_7_list) Append(value protoreflect.Value) { + valueUnwrapped := value.String() + concreteValue := valueUnwrapped + *x.list = append(*x.list, concreteValue) +} + +func (x *_RpcCommandOptions_7_list) AppendMutable() protoreflect.Value { + panic(fmt.Errorf("AppendMutable can not be called on message RpcCommandOptions at list field SuggestFor as it is not of Message kind")) +} + +func (x *_RpcCommandOptions_7_list) Truncate(n int) { + *x.list = (*x.list)[:n] +} + +func (x *_RpcCommandOptions_7_list) NewElement() protoreflect.Value { + v := "" + return protoreflect.ValueOfString(v) +} + +func (x *_RpcCommandOptions_7_list) IsValid() bool { + return x.list != nil +} + +var _ protoreflect.Map = (*_RpcCommandOptions_10_map)(nil) + +type _RpcCommandOptions_10_map struct { + m *map[string]*FlagOptions +} + +func (x *_RpcCommandOptions_10_map) Len() int { + if x.m == nil { + return 0 + } + return len(*x.m) +} + +func (x *_RpcCommandOptions_10_map) Range(f func(protoreflect.MapKey, protoreflect.Value) bool) { + if x.m == nil { + return + } + for k, v := range *x.m { + mapKey := (protoreflect.MapKey)(protoreflect.ValueOfString(k)) + mapValue := protoreflect.ValueOfMessage(v.ProtoReflect()) + if !f(mapKey, mapValue) { + break + } + } +} + +func (x *_RpcCommandOptions_10_map) Has(key protoreflect.MapKey) bool { + if x.m == nil { + return false + } + keyUnwrapped := key.String() + concreteValue := keyUnwrapped + _, ok := (*x.m)[concreteValue] + return ok +} + +func (x *_RpcCommandOptions_10_map) Clear(key protoreflect.MapKey) { + if x.m == nil { + return + } + keyUnwrapped := key.String() + concreteKey := keyUnwrapped + delete(*x.m, concreteKey) +} + +func (x *_RpcCommandOptions_10_map) Get(key protoreflect.MapKey) protoreflect.Value { + if x.m == nil { + return protoreflect.Value{} + } + keyUnwrapped := key.String() + concreteKey := keyUnwrapped + v, ok := (*x.m)[concreteKey] + if !ok { + return protoreflect.Value{} + } + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_RpcCommandOptions_10_map) Set(key protoreflect.MapKey, value protoreflect.Value) { + if !key.IsValid() || !value.IsValid() { + panic("invalid key or value provided") + } + keyUnwrapped := key.String() + concreteKey := keyUnwrapped + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*FlagOptions) + (*x.m)[concreteKey] = concreteValue +} + +func (x *_RpcCommandOptions_10_map) Mutable(key protoreflect.MapKey) protoreflect.Value { + keyUnwrapped := key.String() + concreteKey := keyUnwrapped + v, ok := (*x.m)[concreteKey] + if ok { + return protoreflect.ValueOfMessage(v.ProtoReflect()) + } + newValue := new(FlagOptions) + (*x.m)[concreteKey] = newValue + return protoreflect.ValueOfMessage(newValue.ProtoReflect()) +} + +func (x *_RpcCommandOptions_10_map) NewValue() protoreflect.Value { + v := new(FlagOptions) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_RpcCommandOptions_10_map) IsValid() bool { + return x.m != nil +} + +var _ protoreflect.List = (*_RpcCommandOptions_11_list)(nil) + +type _RpcCommandOptions_11_list struct { + list *[]*PositionalArgDescriptor +} + +func (x *_RpcCommandOptions_11_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_RpcCommandOptions_11_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_RpcCommandOptions_11_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*PositionalArgDescriptor) + (*x.list)[i] = concreteValue +} + +func (x *_RpcCommandOptions_11_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*PositionalArgDescriptor) + *x.list = append(*x.list, concreteValue) +} + +func (x *_RpcCommandOptions_11_list) AppendMutable() protoreflect.Value { + v := new(PositionalArgDescriptor) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_RpcCommandOptions_11_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_RpcCommandOptions_11_list) NewElement() protoreflect.Value { + v := new(PositionalArgDescriptor) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_RpcCommandOptions_11_list) IsValid() bool { + return x.list != nil +} + +var ( + md_RpcCommandOptions protoreflect.MessageDescriptor + fd_RpcCommandOptions_rpc_method protoreflect.FieldDescriptor + fd_RpcCommandOptions_use protoreflect.FieldDescriptor + fd_RpcCommandOptions_long protoreflect.FieldDescriptor + fd_RpcCommandOptions_short protoreflect.FieldDescriptor + fd_RpcCommandOptions_example protoreflect.FieldDescriptor + fd_RpcCommandOptions_alias protoreflect.FieldDescriptor + fd_RpcCommandOptions_suggest_for protoreflect.FieldDescriptor + fd_RpcCommandOptions_deprecated protoreflect.FieldDescriptor + fd_RpcCommandOptions_version protoreflect.FieldDescriptor + fd_RpcCommandOptions_flag_options protoreflect.FieldDescriptor + fd_RpcCommandOptions_positional_args protoreflect.FieldDescriptor + fd_RpcCommandOptions_skip protoreflect.FieldDescriptor +) + +func init() { + file_cosmos_autocli_v1_options_proto_init() + md_RpcCommandOptions = File_cosmos_autocli_v1_options_proto.Messages().ByName("RpcCommandOptions") + fd_RpcCommandOptions_rpc_method = md_RpcCommandOptions.Fields().ByName("rpc_method") + fd_RpcCommandOptions_use = md_RpcCommandOptions.Fields().ByName("use") + fd_RpcCommandOptions_long = md_RpcCommandOptions.Fields().ByName("long") + fd_RpcCommandOptions_short = md_RpcCommandOptions.Fields().ByName("short") + fd_RpcCommandOptions_example = md_RpcCommandOptions.Fields().ByName("example") + fd_RpcCommandOptions_alias = md_RpcCommandOptions.Fields().ByName("alias") + fd_RpcCommandOptions_suggest_for = md_RpcCommandOptions.Fields().ByName("suggest_for") + fd_RpcCommandOptions_deprecated = md_RpcCommandOptions.Fields().ByName("deprecated") + fd_RpcCommandOptions_version = md_RpcCommandOptions.Fields().ByName("version") + fd_RpcCommandOptions_flag_options = md_RpcCommandOptions.Fields().ByName("flag_options") + fd_RpcCommandOptions_positional_args = md_RpcCommandOptions.Fields().ByName("positional_args") + fd_RpcCommandOptions_skip = md_RpcCommandOptions.Fields().ByName("skip") +} + +var _ protoreflect.Message = (*fastReflection_RpcCommandOptions)(nil) + +type fastReflection_RpcCommandOptions RpcCommandOptions + +func (x *RpcCommandOptions) ProtoReflect() protoreflect.Message { + return (*fastReflection_RpcCommandOptions)(x) +} + +func (x *RpcCommandOptions) slowProtoReflect() protoreflect.Message { + mi := &file_cosmos_autocli_v1_options_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_RpcCommandOptions_messageType fastReflection_RpcCommandOptions_messageType +var _ protoreflect.MessageType = fastReflection_RpcCommandOptions_messageType{} + +type fastReflection_RpcCommandOptions_messageType struct{} + +func (x fastReflection_RpcCommandOptions_messageType) Zero() protoreflect.Message { + return (*fastReflection_RpcCommandOptions)(nil) +} +func (x fastReflection_RpcCommandOptions_messageType) New() protoreflect.Message { + return new(fastReflection_RpcCommandOptions) +} +func (x fastReflection_RpcCommandOptions_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_RpcCommandOptions +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_RpcCommandOptions) Descriptor() protoreflect.MessageDescriptor { + return md_RpcCommandOptions +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_RpcCommandOptions) Type() protoreflect.MessageType { + return _fastReflection_RpcCommandOptions_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_RpcCommandOptions) New() protoreflect.Message { + return new(fastReflection_RpcCommandOptions) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_RpcCommandOptions) Interface() protoreflect.ProtoMessage { + return (*RpcCommandOptions)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_RpcCommandOptions) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.RpcMethod != "" { + value := protoreflect.ValueOfString(x.RpcMethod) + if !f(fd_RpcCommandOptions_rpc_method, value) { + return + } + } + if x.Use != "" { + value := protoreflect.ValueOfString(x.Use) + if !f(fd_RpcCommandOptions_use, value) { + return + } + } + if x.Long != "" { + value := protoreflect.ValueOfString(x.Long) + if !f(fd_RpcCommandOptions_long, value) { + return + } + } + if x.Short != "" { + value := protoreflect.ValueOfString(x.Short) + if !f(fd_RpcCommandOptions_short, value) { + return + } + } + if x.Example != "" { + value := protoreflect.ValueOfString(x.Example) + if !f(fd_RpcCommandOptions_example, value) { + return + } + } + if len(x.Alias) != 0 { + value := protoreflect.ValueOfList(&_RpcCommandOptions_6_list{list: &x.Alias}) + if !f(fd_RpcCommandOptions_alias, value) { + return + } + } + if len(x.SuggestFor) != 0 { + value := protoreflect.ValueOfList(&_RpcCommandOptions_7_list{list: &x.SuggestFor}) + if !f(fd_RpcCommandOptions_suggest_for, value) { + return + } + } + if x.Deprecated != "" { + value := protoreflect.ValueOfString(x.Deprecated) + if !f(fd_RpcCommandOptions_deprecated, value) { + return + } + } + if x.Version != "" { + value := protoreflect.ValueOfString(x.Version) + if !f(fd_RpcCommandOptions_version, value) { + return + } + } + if len(x.FlagOptions) != 0 { + value := protoreflect.ValueOfMap(&_RpcCommandOptions_10_map{m: &x.FlagOptions}) + if !f(fd_RpcCommandOptions_flag_options, value) { + return + } + } + if len(x.PositionalArgs) != 0 { + value := protoreflect.ValueOfList(&_RpcCommandOptions_11_list{list: &x.PositionalArgs}) + if !f(fd_RpcCommandOptions_positional_args, value) { + return + } + } + if x.Skip != false { + value := protoreflect.ValueOfBool(x.Skip) + if !f(fd_RpcCommandOptions_skip, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_RpcCommandOptions) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "cosmos.autocli.v1.RpcCommandOptions.rpc_method": + return x.RpcMethod != "" + case "cosmos.autocli.v1.RpcCommandOptions.use": + return x.Use != "" + case "cosmos.autocli.v1.RpcCommandOptions.long": + return x.Long != "" + case "cosmos.autocli.v1.RpcCommandOptions.short": + return x.Short != "" + case "cosmos.autocli.v1.RpcCommandOptions.example": + return x.Example != "" + case "cosmos.autocli.v1.RpcCommandOptions.alias": + return len(x.Alias) != 0 + case "cosmos.autocli.v1.RpcCommandOptions.suggest_for": + return len(x.SuggestFor) != 0 + case "cosmos.autocli.v1.RpcCommandOptions.deprecated": + return x.Deprecated != "" + case "cosmos.autocli.v1.RpcCommandOptions.version": + return x.Version != "" + case "cosmos.autocli.v1.RpcCommandOptions.flag_options": + return len(x.FlagOptions) != 0 + case "cosmos.autocli.v1.RpcCommandOptions.positional_args": + return len(x.PositionalArgs) != 0 + case "cosmos.autocli.v1.RpcCommandOptions.skip": + return x.Skip != false + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.autocli.v1.RpcCommandOptions")) + } + panic(fmt.Errorf("message cosmos.autocli.v1.RpcCommandOptions does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_RpcCommandOptions) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "cosmos.autocli.v1.RpcCommandOptions.rpc_method": + x.RpcMethod = "" + case "cosmos.autocli.v1.RpcCommandOptions.use": + x.Use = "" + case "cosmos.autocli.v1.RpcCommandOptions.long": + x.Long = "" + case "cosmos.autocli.v1.RpcCommandOptions.short": + x.Short = "" + case "cosmos.autocli.v1.RpcCommandOptions.example": + x.Example = "" + case "cosmos.autocli.v1.RpcCommandOptions.alias": + x.Alias = nil + case "cosmos.autocli.v1.RpcCommandOptions.suggest_for": + x.SuggestFor = nil + case "cosmos.autocli.v1.RpcCommandOptions.deprecated": + x.Deprecated = "" + case "cosmos.autocli.v1.RpcCommandOptions.version": + x.Version = "" + case "cosmos.autocli.v1.RpcCommandOptions.flag_options": + x.FlagOptions = nil + case "cosmos.autocli.v1.RpcCommandOptions.positional_args": + x.PositionalArgs = nil + case "cosmos.autocli.v1.RpcCommandOptions.skip": + x.Skip = false + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.autocli.v1.RpcCommandOptions")) + } + panic(fmt.Errorf("message cosmos.autocli.v1.RpcCommandOptions does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_RpcCommandOptions) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "cosmos.autocli.v1.RpcCommandOptions.rpc_method": + value := x.RpcMethod + return protoreflect.ValueOfString(value) + case "cosmos.autocli.v1.RpcCommandOptions.use": + value := x.Use + return protoreflect.ValueOfString(value) + case "cosmos.autocli.v1.RpcCommandOptions.long": + value := x.Long + return protoreflect.ValueOfString(value) + case "cosmos.autocli.v1.RpcCommandOptions.short": + value := x.Short + return protoreflect.ValueOfString(value) + case "cosmos.autocli.v1.RpcCommandOptions.example": + value := x.Example + return protoreflect.ValueOfString(value) + case "cosmos.autocli.v1.RpcCommandOptions.alias": + if len(x.Alias) == 0 { + return protoreflect.ValueOfList(&_RpcCommandOptions_6_list{}) + } + listValue := &_RpcCommandOptions_6_list{list: &x.Alias} + return protoreflect.ValueOfList(listValue) + case "cosmos.autocli.v1.RpcCommandOptions.suggest_for": + if len(x.SuggestFor) == 0 { + return protoreflect.ValueOfList(&_RpcCommandOptions_7_list{}) + } + listValue := &_RpcCommandOptions_7_list{list: &x.SuggestFor} + return protoreflect.ValueOfList(listValue) + case "cosmos.autocli.v1.RpcCommandOptions.deprecated": + value := x.Deprecated + return protoreflect.ValueOfString(value) + case "cosmos.autocli.v1.RpcCommandOptions.version": + value := x.Version + return protoreflect.ValueOfString(value) + case "cosmos.autocli.v1.RpcCommandOptions.flag_options": + if len(x.FlagOptions) == 0 { + return protoreflect.ValueOfMap(&_RpcCommandOptions_10_map{}) + } + mapValue := &_RpcCommandOptions_10_map{m: &x.FlagOptions} + return protoreflect.ValueOfMap(mapValue) + case "cosmos.autocli.v1.RpcCommandOptions.positional_args": + if len(x.PositionalArgs) == 0 { + return protoreflect.ValueOfList(&_RpcCommandOptions_11_list{}) + } + listValue := &_RpcCommandOptions_11_list{list: &x.PositionalArgs} + return protoreflect.ValueOfList(listValue) + case "cosmos.autocli.v1.RpcCommandOptions.skip": + value := x.Skip + return protoreflect.ValueOfBool(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.autocli.v1.RpcCommandOptions")) + } + panic(fmt.Errorf("message cosmos.autocli.v1.RpcCommandOptions does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_RpcCommandOptions) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "cosmos.autocli.v1.RpcCommandOptions.rpc_method": + x.RpcMethod = value.Interface().(string) + case "cosmos.autocli.v1.RpcCommandOptions.use": + x.Use = value.Interface().(string) + case "cosmos.autocli.v1.RpcCommandOptions.long": + x.Long = value.Interface().(string) + case "cosmos.autocli.v1.RpcCommandOptions.short": + x.Short = value.Interface().(string) + case "cosmos.autocli.v1.RpcCommandOptions.example": + x.Example = value.Interface().(string) + case "cosmos.autocli.v1.RpcCommandOptions.alias": + lv := value.List() + clv := lv.(*_RpcCommandOptions_6_list) + x.Alias = *clv.list + case "cosmos.autocli.v1.RpcCommandOptions.suggest_for": + lv := value.List() + clv := lv.(*_RpcCommandOptions_7_list) + x.SuggestFor = *clv.list + case "cosmos.autocli.v1.RpcCommandOptions.deprecated": + x.Deprecated = value.Interface().(string) + case "cosmos.autocli.v1.RpcCommandOptions.version": + x.Version = value.Interface().(string) + case "cosmos.autocli.v1.RpcCommandOptions.flag_options": + mv := value.Map() + cmv := mv.(*_RpcCommandOptions_10_map) + x.FlagOptions = *cmv.m + case "cosmos.autocli.v1.RpcCommandOptions.positional_args": + lv := value.List() + clv := lv.(*_RpcCommandOptions_11_list) + x.PositionalArgs = *clv.list + case "cosmos.autocli.v1.RpcCommandOptions.skip": + x.Skip = value.Bool() + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.autocli.v1.RpcCommandOptions")) + } + panic(fmt.Errorf("message cosmos.autocli.v1.RpcCommandOptions does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_RpcCommandOptions) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.autocli.v1.RpcCommandOptions.alias": + if x.Alias == nil { + x.Alias = []string{} + } + value := &_RpcCommandOptions_6_list{list: &x.Alias} + return protoreflect.ValueOfList(value) + case "cosmos.autocli.v1.RpcCommandOptions.suggest_for": + if x.SuggestFor == nil { + x.SuggestFor = []string{} + } + value := &_RpcCommandOptions_7_list{list: &x.SuggestFor} + return protoreflect.ValueOfList(value) + case "cosmos.autocli.v1.RpcCommandOptions.flag_options": + if x.FlagOptions == nil { + x.FlagOptions = make(map[string]*FlagOptions) + } + value := &_RpcCommandOptions_10_map{m: &x.FlagOptions} + return protoreflect.ValueOfMap(value) + case "cosmos.autocli.v1.RpcCommandOptions.positional_args": + if x.PositionalArgs == nil { + x.PositionalArgs = []*PositionalArgDescriptor{} + } + value := &_RpcCommandOptions_11_list{list: &x.PositionalArgs} + return protoreflect.ValueOfList(value) + case "cosmos.autocli.v1.RpcCommandOptions.rpc_method": + panic(fmt.Errorf("field rpc_method of message cosmos.autocli.v1.RpcCommandOptions is not mutable")) + case "cosmos.autocli.v1.RpcCommandOptions.use": + panic(fmt.Errorf("field use of message cosmos.autocli.v1.RpcCommandOptions is not mutable")) + case "cosmos.autocli.v1.RpcCommandOptions.long": + panic(fmt.Errorf("field long of message cosmos.autocli.v1.RpcCommandOptions is not mutable")) + case "cosmos.autocli.v1.RpcCommandOptions.short": + panic(fmt.Errorf("field short of message cosmos.autocli.v1.RpcCommandOptions is not mutable")) + case "cosmos.autocli.v1.RpcCommandOptions.example": + panic(fmt.Errorf("field example of message cosmos.autocli.v1.RpcCommandOptions is not mutable")) + case "cosmos.autocli.v1.RpcCommandOptions.deprecated": + panic(fmt.Errorf("field deprecated of message cosmos.autocli.v1.RpcCommandOptions is not mutable")) + case "cosmos.autocli.v1.RpcCommandOptions.version": + panic(fmt.Errorf("field version of message cosmos.autocli.v1.RpcCommandOptions is not mutable")) + case "cosmos.autocli.v1.RpcCommandOptions.skip": + panic(fmt.Errorf("field skip of message cosmos.autocli.v1.RpcCommandOptions is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.autocli.v1.RpcCommandOptions")) + } + panic(fmt.Errorf("message cosmos.autocli.v1.RpcCommandOptions does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_RpcCommandOptions) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.autocli.v1.RpcCommandOptions.rpc_method": + return protoreflect.ValueOfString("") + case "cosmos.autocli.v1.RpcCommandOptions.use": + return protoreflect.ValueOfString("") + case "cosmos.autocli.v1.RpcCommandOptions.long": + return protoreflect.ValueOfString("") + case "cosmos.autocli.v1.RpcCommandOptions.short": + return protoreflect.ValueOfString("") + case "cosmos.autocli.v1.RpcCommandOptions.example": + return protoreflect.ValueOfString("") + case "cosmos.autocli.v1.RpcCommandOptions.alias": + list := []string{} + return protoreflect.ValueOfList(&_RpcCommandOptions_6_list{list: &list}) + case "cosmos.autocli.v1.RpcCommandOptions.suggest_for": + list := []string{} + return protoreflect.ValueOfList(&_RpcCommandOptions_7_list{list: &list}) + case "cosmos.autocli.v1.RpcCommandOptions.deprecated": + return protoreflect.ValueOfString("") + case "cosmos.autocli.v1.RpcCommandOptions.version": + return protoreflect.ValueOfString("") + case "cosmos.autocli.v1.RpcCommandOptions.flag_options": + m := make(map[string]*FlagOptions) + return protoreflect.ValueOfMap(&_RpcCommandOptions_10_map{m: &m}) + case "cosmos.autocli.v1.RpcCommandOptions.positional_args": + list := []*PositionalArgDescriptor{} + return protoreflect.ValueOfList(&_RpcCommandOptions_11_list{list: &list}) + case "cosmos.autocli.v1.RpcCommandOptions.skip": + return protoreflect.ValueOfBool(false) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.autocli.v1.RpcCommandOptions")) + } + panic(fmt.Errorf("message cosmos.autocli.v1.RpcCommandOptions does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_RpcCommandOptions) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in cosmos.autocli.v1.RpcCommandOptions", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_RpcCommandOptions) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_RpcCommandOptions) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_RpcCommandOptions) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_RpcCommandOptions) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*RpcCommandOptions) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + l = len(x.RpcMethod) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Use) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Long) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Short) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Example) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if len(x.Alias) > 0 { + for _, s := range x.Alias { + l = len(s) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + if len(x.SuggestFor) > 0 { + for _, s := range x.SuggestFor { + l = len(s) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + l = len(x.Deprecated) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Version) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if len(x.FlagOptions) > 0 { + SiZeMaP := func(k string, v *FlagOptions) { + l := 0 + if v != nil { + l = options.Size(v) + } + l += 1 + runtime.Sov(uint64(l)) + mapEntrySize := 1 + len(k) + runtime.Sov(uint64(len(k))) + l + n += mapEntrySize + 1 + runtime.Sov(uint64(mapEntrySize)) + } + if options.Deterministic { + sortme := make([]string, 0, len(x.FlagOptions)) + for k := range x.FlagOptions { + sortme = append(sortme, k) + } + sort.Strings(sortme) + for _, k := range sortme { + v := x.FlagOptions[k] + SiZeMaP(k, v) + } + } else { + for k, v := range x.FlagOptions { + SiZeMaP(k, v) + } + } + } + if len(x.PositionalArgs) > 0 { + for _, e := range x.PositionalArgs { + l = options.Size(e) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + if x.Skip { + n += 2 + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*RpcCommandOptions) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if x.Skip { + i-- + if x.Skip { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x60 + } + if len(x.PositionalArgs) > 0 { + for iNdEx := len(x.PositionalArgs) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.PositionalArgs[iNdEx]) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x5a + } + } + if len(x.FlagOptions) > 0 { + MaRsHaLmAp := func(k string, v *FlagOptions) (protoiface.MarshalOutput, error) { + baseI := i + encoded, err := options.Marshal(v) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x12 + i -= len(k) + copy(dAtA[i:], k) + i = runtime.EncodeVarint(dAtA, i, uint64(len(k))) + i-- + dAtA[i] = 0xa + i = runtime.EncodeVarint(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x52 + return protoiface.MarshalOutput{}, nil + } + if options.Deterministic { + keysForFlagOptions := make([]string, 0, len(x.FlagOptions)) + for k := range x.FlagOptions { + keysForFlagOptions = append(keysForFlagOptions, string(k)) + } + sort.Slice(keysForFlagOptions, func(i, j int) bool { + return keysForFlagOptions[i] < keysForFlagOptions[j] + }) + for iNdEx := len(keysForFlagOptions) - 1; iNdEx >= 0; iNdEx-- { + v := x.FlagOptions[string(keysForFlagOptions[iNdEx])] + out, err := MaRsHaLmAp(keysForFlagOptions[iNdEx], v) + if err != nil { + return out, err + } + } + } else { + for k := range x.FlagOptions { + v := x.FlagOptions[k] + out, err := MaRsHaLmAp(k, v) + if err != nil { + return out, err + } + } + } + } + if len(x.Version) > 0 { + i -= len(x.Version) + copy(dAtA[i:], x.Version) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Version))) + i-- + dAtA[i] = 0x4a + } + if len(x.Deprecated) > 0 { + i -= len(x.Deprecated) + copy(dAtA[i:], x.Deprecated) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Deprecated))) + i-- + dAtA[i] = 0x42 + } + if len(x.SuggestFor) > 0 { + for iNdEx := len(x.SuggestFor) - 1; iNdEx >= 0; iNdEx-- { + i -= len(x.SuggestFor[iNdEx]) + copy(dAtA[i:], x.SuggestFor[iNdEx]) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.SuggestFor[iNdEx]))) + i-- + dAtA[i] = 0x3a + } + } + if len(x.Alias) > 0 { + for iNdEx := len(x.Alias) - 1; iNdEx >= 0; iNdEx-- { + i -= len(x.Alias[iNdEx]) + copy(dAtA[i:], x.Alias[iNdEx]) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Alias[iNdEx]))) + i-- + dAtA[i] = 0x32 + } + } + if len(x.Example) > 0 { + i -= len(x.Example) + copy(dAtA[i:], x.Example) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Example))) + i-- + dAtA[i] = 0x2a + } + if len(x.Short) > 0 { + i -= len(x.Short) + copy(dAtA[i:], x.Short) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Short))) + i-- + dAtA[i] = 0x22 + } + if len(x.Long) > 0 { + i -= len(x.Long) + copy(dAtA[i:], x.Long) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Long))) + i-- + dAtA[i] = 0x1a + } + if len(x.Use) > 0 { + i -= len(x.Use) + copy(dAtA[i:], x.Use) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Use))) + i-- + dAtA[i] = 0x12 + } + if len(x.RpcMethod) > 0 { + i -= len(x.RpcMethod) + copy(dAtA[i:], x.RpcMethod) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.RpcMethod))) + i-- + dAtA[i] = 0xa + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*RpcCommandOptions) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: RpcCommandOptions: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: RpcCommandOptions: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RpcMethod", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.RpcMethod = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Use", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Use = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Long", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Long = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Short", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Short = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Example", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Example = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Alias", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Alias = append(x.Alias, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 7: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field SuggestFor", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.SuggestFor = append(x.SuggestFor, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 8: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Deprecated", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Deprecated = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 9: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Version = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 10: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field FlagOptions", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.FlagOptions == nil { + x.FlagOptions = make(map[string]*FlagOptions) + } + var mapkey string + var mapvalue *FlagOptions + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postStringIndexmapkey > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + } else if fieldNum == 2 { + var mapmsglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapmsglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if mapmsglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postmsgIndex := iNdEx + mapmsglen + if postmsgIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postmsgIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + mapvalue = &FlagOptions{} + if err := options.Unmarshal(dAtA[iNdEx:postmsgIndex], mapvalue); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postmsgIndex + } else { + iNdEx = entryPreIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > postIndex { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + x.FlagOptions[mapkey] = mapvalue + iNdEx = postIndex + case 11: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PositionalArgs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.PositionalArgs = append(x.PositionalArgs, &PositionalArgDescriptor{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.PositionalArgs[len(x.PositionalArgs)-1]); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 12: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Skip", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + x.Skip = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_FlagOptions protoreflect.MessageDescriptor + fd_FlagOptions_name protoreflect.FieldDescriptor + fd_FlagOptions_shorthand protoreflect.FieldDescriptor + fd_FlagOptions_usage protoreflect.FieldDescriptor + fd_FlagOptions_default_value protoreflect.FieldDescriptor + fd_FlagOptions_no_opt_default_value protoreflect.FieldDescriptor + fd_FlagOptions_deprecated protoreflect.FieldDescriptor + fd_FlagOptions_shorthand_deprecated protoreflect.FieldDescriptor + fd_FlagOptions_hidden protoreflect.FieldDescriptor +) + +func init() { + file_cosmos_autocli_v1_options_proto_init() + md_FlagOptions = File_cosmos_autocli_v1_options_proto.Messages().ByName("FlagOptions") + fd_FlagOptions_name = md_FlagOptions.Fields().ByName("name") + fd_FlagOptions_shorthand = md_FlagOptions.Fields().ByName("shorthand") + fd_FlagOptions_usage = md_FlagOptions.Fields().ByName("usage") + fd_FlagOptions_default_value = md_FlagOptions.Fields().ByName("default_value") + fd_FlagOptions_no_opt_default_value = md_FlagOptions.Fields().ByName("no_opt_default_value") + fd_FlagOptions_deprecated = md_FlagOptions.Fields().ByName("deprecated") + fd_FlagOptions_shorthand_deprecated = md_FlagOptions.Fields().ByName("shorthand_deprecated") + fd_FlagOptions_hidden = md_FlagOptions.Fields().ByName("hidden") +} + +var _ protoreflect.Message = (*fastReflection_FlagOptions)(nil) + +type fastReflection_FlagOptions FlagOptions + +func (x *FlagOptions) ProtoReflect() protoreflect.Message { + return (*fastReflection_FlagOptions)(x) +} + +func (x *FlagOptions) slowProtoReflect() protoreflect.Message { + mi := &file_cosmos_autocli_v1_options_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_FlagOptions_messageType fastReflection_FlagOptions_messageType +var _ protoreflect.MessageType = fastReflection_FlagOptions_messageType{} + +type fastReflection_FlagOptions_messageType struct{} + +func (x fastReflection_FlagOptions_messageType) Zero() protoreflect.Message { + return (*fastReflection_FlagOptions)(nil) +} +func (x fastReflection_FlagOptions_messageType) New() protoreflect.Message { + return new(fastReflection_FlagOptions) +} +func (x fastReflection_FlagOptions_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_FlagOptions +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_FlagOptions) Descriptor() protoreflect.MessageDescriptor { + return md_FlagOptions +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_FlagOptions) Type() protoreflect.MessageType { + return _fastReflection_FlagOptions_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_FlagOptions) New() protoreflect.Message { + return new(fastReflection_FlagOptions) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_FlagOptions) Interface() protoreflect.ProtoMessage { + return (*FlagOptions)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_FlagOptions) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Name != "" { + value := protoreflect.ValueOfString(x.Name) + if !f(fd_FlagOptions_name, value) { + return + } + } + if x.Shorthand != "" { + value := protoreflect.ValueOfString(x.Shorthand) + if !f(fd_FlagOptions_shorthand, value) { + return + } + } + if x.Usage != "" { + value := protoreflect.ValueOfString(x.Usage) + if !f(fd_FlagOptions_usage, value) { + return + } + } + if x.DefaultValue != "" { + value := protoreflect.ValueOfString(x.DefaultValue) + if !f(fd_FlagOptions_default_value, value) { + return + } + } + if x.NoOptDefaultValue != "" { + value := protoreflect.ValueOfString(x.NoOptDefaultValue) + if !f(fd_FlagOptions_no_opt_default_value, value) { + return + } + } + if x.Deprecated != "" { + value := protoreflect.ValueOfString(x.Deprecated) + if !f(fd_FlagOptions_deprecated, value) { + return + } + } + if x.ShorthandDeprecated != "" { + value := protoreflect.ValueOfString(x.ShorthandDeprecated) + if !f(fd_FlagOptions_shorthand_deprecated, value) { + return + } + } + if x.Hidden != false { + value := protoreflect.ValueOfBool(x.Hidden) + if !f(fd_FlagOptions_hidden, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_FlagOptions) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "cosmos.autocli.v1.FlagOptions.name": + return x.Name != "" + case "cosmos.autocli.v1.FlagOptions.shorthand": + return x.Shorthand != "" + case "cosmos.autocli.v1.FlagOptions.usage": + return x.Usage != "" + case "cosmos.autocli.v1.FlagOptions.default_value": + return x.DefaultValue != "" + case "cosmos.autocli.v1.FlagOptions.no_opt_default_value": + return x.NoOptDefaultValue != "" + case "cosmos.autocli.v1.FlagOptions.deprecated": + return x.Deprecated != "" + case "cosmos.autocli.v1.FlagOptions.shorthand_deprecated": + return x.ShorthandDeprecated != "" + case "cosmos.autocli.v1.FlagOptions.hidden": + return x.Hidden != false + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.autocli.v1.FlagOptions")) + } + panic(fmt.Errorf("message cosmos.autocli.v1.FlagOptions does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_FlagOptions) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "cosmos.autocli.v1.FlagOptions.name": + x.Name = "" + case "cosmos.autocli.v1.FlagOptions.shorthand": + x.Shorthand = "" + case "cosmos.autocli.v1.FlagOptions.usage": + x.Usage = "" + case "cosmos.autocli.v1.FlagOptions.default_value": + x.DefaultValue = "" + case "cosmos.autocli.v1.FlagOptions.no_opt_default_value": + x.NoOptDefaultValue = "" + case "cosmos.autocli.v1.FlagOptions.deprecated": + x.Deprecated = "" + case "cosmos.autocli.v1.FlagOptions.shorthand_deprecated": + x.ShorthandDeprecated = "" + case "cosmos.autocli.v1.FlagOptions.hidden": + x.Hidden = false + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.autocli.v1.FlagOptions")) + } + panic(fmt.Errorf("message cosmos.autocli.v1.FlagOptions does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_FlagOptions) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "cosmos.autocli.v1.FlagOptions.name": + value := x.Name + return protoreflect.ValueOfString(value) + case "cosmos.autocli.v1.FlagOptions.shorthand": + value := x.Shorthand + return protoreflect.ValueOfString(value) + case "cosmos.autocli.v1.FlagOptions.usage": + value := x.Usage + return protoreflect.ValueOfString(value) + case "cosmos.autocli.v1.FlagOptions.default_value": + value := x.DefaultValue + return protoreflect.ValueOfString(value) + case "cosmos.autocli.v1.FlagOptions.no_opt_default_value": + value := x.NoOptDefaultValue + return protoreflect.ValueOfString(value) + case "cosmos.autocli.v1.FlagOptions.deprecated": + value := x.Deprecated + return protoreflect.ValueOfString(value) + case "cosmos.autocli.v1.FlagOptions.shorthand_deprecated": + value := x.ShorthandDeprecated + return protoreflect.ValueOfString(value) + case "cosmos.autocli.v1.FlagOptions.hidden": + value := x.Hidden + return protoreflect.ValueOfBool(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.autocli.v1.FlagOptions")) + } + panic(fmt.Errorf("message cosmos.autocli.v1.FlagOptions does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_FlagOptions) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "cosmos.autocli.v1.FlagOptions.name": + x.Name = value.Interface().(string) + case "cosmos.autocli.v1.FlagOptions.shorthand": + x.Shorthand = value.Interface().(string) + case "cosmos.autocli.v1.FlagOptions.usage": + x.Usage = value.Interface().(string) + case "cosmos.autocli.v1.FlagOptions.default_value": + x.DefaultValue = value.Interface().(string) + case "cosmos.autocli.v1.FlagOptions.no_opt_default_value": + x.NoOptDefaultValue = value.Interface().(string) + case "cosmos.autocli.v1.FlagOptions.deprecated": + x.Deprecated = value.Interface().(string) + case "cosmos.autocli.v1.FlagOptions.shorthand_deprecated": + x.ShorthandDeprecated = value.Interface().(string) + case "cosmos.autocli.v1.FlagOptions.hidden": + x.Hidden = value.Bool() + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.autocli.v1.FlagOptions")) + } + panic(fmt.Errorf("message cosmos.autocli.v1.FlagOptions does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_FlagOptions) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.autocli.v1.FlagOptions.name": + panic(fmt.Errorf("field name of message cosmos.autocli.v1.FlagOptions is not mutable")) + case "cosmos.autocli.v1.FlagOptions.shorthand": + panic(fmt.Errorf("field shorthand of message cosmos.autocli.v1.FlagOptions is not mutable")) + case "cosmos.autocli.v1.FlagOptions.usage": + panic(fmt.Errorf("field usage of message cosmos.autocli.v1.FlagOptions is not mutable")) + case "cosmos.autocli.v1.FlagOptions.default_value": + panic(fmt.Errorf("field default_value of message cosmos.autocli.v1.FlagOptions is not mutable")) + case "cosmos.autocli.v1.FlagOptions.no_opt_default_value": + panic(fmt.Errorf("field no_opt_default_value of message cosmos.autocli.v1.FlagOptions is not mutable")) + case "cosmos.autocli.v1.FlagOptions.deprecated": + panic(fmt.Errorf("field deprecated of message cosmos.autocli.v1.FlagOptions is not mutable")) + case "cosmos.autocli.v1.FlagOptions.shorthand_deprecated": + panic(fmt.Errorf("field shorthand_deprecated of message cosmos.autocli.v1.FlagOptions is not mutable")) + case "cosmos.autocli.v1.FlagOptions.hidden": + panic(fmt.Errorf("field hidden of message cosmos.autocli.v1.FlagOptions is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.autocli.v1.FlagOptions")) + } + panic(fmt.Errorf("message cosmos.autocli.v1.FlagOptions does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_FlagOptions) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.autocli.v1.FlagOptions.name": + return protoreflect.ValueOfString("") + case "cosmos.autocli.v1.FlagOptions.shorthand": + return protoreflect.ValueOfString("") + case "cosmos.autocli.v1.FlagOptions.usage": + return protoreflect.ValueOfString("") + case "cosmos.autocli.v1.FlagOptions.default_value": + return protoreflect.ValueOfString("") + case "cosmos.autocli.v1.FlagOptions.no_opt_default_value": + return protoreflect.ValueOfString("") + case "cosmos.autocli.v1.FlagOptions.deprecated": + return protoreflect.ValueOfString("") + case "cosmos.autocli.v1.FlagOptions.shorthand_deprecated": + return protoreflect.ValueOfString("") + case "cosmos.autocli.v1.FlagOptions.hidden": + return protoreflect.ValueOfBool(false) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.autocli.v1.FlagOptions")) + } + panic(fmt.Errorf("message cosmos.autocli.v1.FlagOptions does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_FlagOptions) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in cosmos.autocli.v1.FlagOptions", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_FlagOptions) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_FlagOptions) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_FlagOptions) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_FlagOptions) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*FlagOptions) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + l = len(x.Name) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Shorthand) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Usage) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.DefaultValue) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.NoOptDefaultValue) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Deprecated) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.ShorthandDeprecated) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.Hidden { + n += 2 + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*FlagOptions) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if x.Hidden { + i-- + if x.Hidden { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x40 + } + if len(x.ShorthandDeprecated) > 0 { + i -= len(x.ShorthandDeprecated) + copy(dAtA[i:], x.ShorthandDeprecated) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ShorthandDeprecated))) + i-- + dAtA[i] = 0x3a + } + if len(x.Deprecated) > 0 { + i -= len(x.Deprecated) + copy(dAtA[i:], x.Deprecated) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Deprecated))) + i-- + dAtA[i] = 0x32 + } + if len(x.NoOptDefaultValue) > 0 { + i -= len(x.NoOptDefaultValue) + copy(dAtA[i:], x.NoOptDefaultValue) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.NoOptDefaultValue))) + i-- + dAtA[i] = 0x2a + } + if len(x.DefaultValue) > 0 { + i -= len(x.DefaultValue) + copy(dAtA[i:], x.DefaultValue) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DefaultValue))) + i-- + dAtA[i] = 0x22 + } + if len(x.Usage) > 0 { + i -= len(x.Usage) + copy(dAtA[i:], x.Usage) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Usage))) + i-- + dAtA[i] = 0x1a + } + if len(x.Shorthand) > 0 { + i -= len(x.Shorthand) + copy(dAtA[i:], x.Shorthand) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Shorthand))) + i-- + dAtA[i] = 0x12 + } + if len(x.Name) > 0 { + i -= len(x.Name) + copy(dAtA[i:], x.Name) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Name))) + i-- + dAtA[i] = 0xa + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*FlagOptions) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: FlagOptions: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: FlagOptions: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Shorthand", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Shorthand = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Usage", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Usage = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DefaultValue", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.DefaultValue = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field NoOptDefaultValue", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.NoOptDefaultValue = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Deprecated", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Deprecated = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ShorthandDeprecated", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.ShorthandDeprecated = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 8: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Hidden", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + x.Hidden = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_PositionalArgDescriptor protoreflect.MessageDescriptor + fd_PositionalArgDescriptor_proto_field protoreflect.FieldDescriptor + fd_PositionalArgDescriptor_varargs protoreflect.FieldDescriptor +) + +func init() { + file_cosmos_autocli_v1_options_proto_init() + md_PositionalArgDescriptor = File_cosmos_autocli_v1_options_proto.Messages().ByName("PositionalArgDescriptor") + fd_PositionalArgDescriptor_proto_field = md_PositionalArgDescriptor.Fields().ByName("proto_field") + fd_PositionalArgDescriptor_varargs = md_PositionalArgDescriptor.Fields().ByName("varargs") +} + +var _ protoreflect.Message = (*fastReflection_PositionalArgDescriptor)(nil) + +type fastReflection_PositionalArgDescriptor PositionalArgDescriptor + +func (x *PositionalArgDescriptor) ProtoReflect() protoreflect.Message { + return (*fastReflection_PositionalArgDescriptor)(x) +} + +func (x *PositionalArgDescriptor) slowProtoReflect() protoreflect.Message { + mi := &file_cosmos_autocli_v1_options_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_PositionalArgDescriptor_messageType fastReflection_PositionalArgDescriptor_messageType +var _ protoreflect.MessageType = fastReflection_PositionalArgDescriptor_messageType{} + +type fastReflection_PositionalArgDescriptor_messageType struct{} + +func (x fastReflection_PositionalArgDescriptor_messageType) Zero() protoreflect.Message { + return (*fastReflection_PositionalArgDescriptor)(nil) +} +func (x fastReflection_PositionalArgDescriptor_messageType) New() protoreflect.Message { + return new(fastReflection_PositionalArgDescriptor) +} +func (x fastReflection_PositionalArgDescriptor_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_PositionalArgDescriptor +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_PositionalArgDescriptor) Descriptor() protoreflect.MessageDescriptor { + return md_PositionalArgDescriptor +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_PositionalArgDescriptor) Type() protoreflect.MessageType { + return _fastReflection_PositionalArgDescriptor_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_PositionalArgDescriptor) New() protoreflect.Message { + return new(fastReflection_PositionalArgDescriptor) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_PositionalArgDescriptor) Interface() protoreflect.ProtoMessage { + return (*PositionalArgDescriptor)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_PositionalArgDescriptor) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.ProtoField != "" { + value := protoreflect.ValueOfString(x.ProtoField) + if !f(fd_PositionalArgDescriptor_proto_field, value) { + return + } + } + if x.Varargs != false { + value := protoreflect.ValueOfBool(x.Varargs) + if !f(fd_PositionalArgDescriptor_varargs, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_PositionalArgDescriptor) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "cosmos.autocli.v1.PositionalArgDescriptor.proto_field": + return x.ProtoField != "" + case "cosmos.autocli.v1.PositionalArgDescriptor.varargs": + return x.Varargs != false + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.autocli.v1.PositionalArgDescriptor")) + } + panic(fmt.Errorf("message cosmos.autocli.v1.PositionalArgDescriptor does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_PositionalArgDescriptor) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "cosmos.autocli.v1.PositionalArgDescriptor.proto_field": + x.ProtoField = "" + case "cosmos.autocli.v1.PositionalArgDescriptor.varargs": + x.Varargs = false + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.autocli.v1.PositionalArgDescriptor")) + } + panic(fmt.Errorf("message cosmos.autocli.v1.PositionalArgDescriptor does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_PositionalArgDescriptor) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "cosmos.autocli.v1.PositionalArgDescriptor.proto_field": + value := x.ProtoField + return protoreflect.ValueOfString(value) + case "cosmos.autocli.v1.PositionalArgDescriptor.varargs": + value := x.Varargs + return protoreflect.ValueOfBool(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.autocli.v1.PositionalArgDescriptor")) + } + panic(fmt.Errorf("message cosmos.autocli.v1.PositionalArgDescriptor does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_PositionalArgDescriptor) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "cosmos.autocli.v1.PositionalArgDescriptor.proto_field": + x.ProtoField = value.Interface().(string) + case "cosmos.autocli.v1.PositionalArgDescriptor.varargs": + x.Varargs = value.Bool() + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.autocli.v1.PositionalArgDescriptor")) + } + panic(fmt.Errorf("message cosmos.autocli.v1.PositionalArgDescriptor does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_PositionalArgDescriptor) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.autocli.v1.PositionalArgDescriptor.proto_field": + panic(fmt.Errorf("field proto_field of message cosmos.autocli.v1.PositionalArgDescriptor is not mutable")) + case "cosmos.autocli.v1.PositionalArgDescriptor.varargs": + panic(fmt.Errorf("field varargs of message cosmos.autocli.v1.PositionalArgDescriptor is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.autocli.v1.PositionalArgDescriptor")) + } + panic(fmt.Errorf("message cosmos.autocli.v1.PositionalArgDescriptor does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_PositionalArgDescriptor) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.autocli.v1.PositionalArgDescriptor.proto_field": + return protoreflect.ValueOfString("") + case "cosmos.autocli.v1.PositionalArgDescriptor.varargs": + return protoreflect.ValueOfBool(false) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.autocli.v1.PositionalArgDescriptor")) + } + panic(fmt.Errorf("message cosmos.autocli.v1.PositionalArgDescriptor does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_PositionalArgDescriptor) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in cosmos.autocli.v1.PositionalArgDescriptor", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_PositionalArgDescriptor) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_PositionalArgDescriptor) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_PositionalArgDescriptor) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_PositionalArgDescriptor) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*PositionalArgDescriptor) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + l = len(x.ProtoField) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.Varargs { + n += 2 + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*PositionalArgDescriptor) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if x.Varargs { + i-- + if x.Varargs { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x10 + } + if len(x.ProtoField) > 0 { + i -= len(x.ProtoField) + copy(dAtA[i:], x.ProtoField) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ProtoField))) + i-- + dAtA[i] = 0xa + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*PositionalArgDescriptor) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: PositionalArgDescriptor: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: PositionalArgDescriptor: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ProtoField", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.ProtoField = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Varargs", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + x.Varargs = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.27.0 +// protoc (unknown) +// source: cosmos/autocli/v1/options.proto + +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) +) + +// ModuleOptions describes the CLI options for a Cosmos SDK module. +type ModuleOptions struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // tx describes the tx command for the module. + Tx *ServiceCommandDescriptor `protobuf:"bytes,1,opt,name=tx,proto3" json:"tx,omitempty"` + // query describes the tx command for the module. + Query *ServiceCommandDescriptor `protobuf:"bytes,2,opt,name=query,proto3" json:"query,omitempty"` +} + +func (x *ModuleOptions) Reset() { + *x = ModuleOptions{} + if protoimpl.UnsafeEnabled { + mi := &file_cosmos_autocli_v1_options_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ModuleOptions) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ModuleOptions) ProtoMessage() {} + +// Deprecated: Use ModuleOptions.ProtoReflect.Descriptor instead. +func (*ModuleOptions) Descriptor() ([]byte, []int) { + return file_cosmos_autocli_v1_options_proto_rawDescGZIP(), []int{0} +} + +func (x *ModuleOptions) GetTx() *ServiceCommandDescriptor { + if x != nil { + return x.Tx + } + return nil +} + +func (x *ModuleOptions) GetQuery() *ServiceCommandDescriptor { + if x != nil { + return x.Query + } + return nil +} + +// ServiceCommandDescriptor describes a CLI command based on a protobuf service. +type ServiceCommandDescriptor struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // service is the fully qualified name of the protobuf service to build + // the command from. It can be left empty if sub_commands are used instead + // which may be the case if a module provides multiple tx and/or query services. + Service string `protobuf:"bytes,1,opt,name=service,proto3" json:"service,omitempty"` + // rpc_command_options are options for commands generated from rpc methods. + // If no options are specified for a given rpc method on the service, a + // command will be generated for that method with the default options. + RpcCommandOptions []*RpcCommandOptions `protobuf:"bytes,2,rep,name=rpc_command_options,json=rpcCommandOptions,proto3" json:"rpc_command_options,omitempty"` + // sub_commands is a map of optional sub-commands for this command based on + // different protobuf services. The map key is used as the name of the + // sub-command. + SubCommands map[string]*ServiceCommandDescriptor `protobuf:"bytes,3,rep,name=sub_commands,json=subCommands,proto3" json:"sub_commands,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (x *ServiceCommandDescriptor) Reset() { + *x = ServiceCommandDescriptor{} + if protoimpl.UnsafeEnabled { + mi := &file_cosmos_autocli_v1_options_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ServiceCommandDescriptor) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ServiceCommandDescriptor) ProtoMessage() {} + +// Deprecated: Use ServiceCommandDescriptor.ProtoReflect.Descriptor instead. +func (*ServiceCommandDescriptor) Descriptor() ([]byte, []int) { + return file_cosmos_autocli_v1_options_proto_rawDescGZIP(), []int{1} +} + +func (x *ServiceCommandDescriptor) GetService() string { + if x != nil { + return x.Service + } + return "" +} + +func (x *ServiceCommandDescriptor) GetRpcCommandOptions() []*RpcCommandOptions { + if x != nil { + return x.RpcCommandOptions + } + return nil +} + +func (x *ServiceCommandDescriptor) GetSubCommands() map[string]*ServiceCommandDescriptor { + if x != nil { + return x.SubCommands + } + return nil +} + +// RpcCommandOptions specifies options for commands generated from protobuf +// rpc methods. +type RpcCommandOptions struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // rpc_method is short name of the protobuf rpc method that this command is + // generated from. + RpcMethod string `protobuf:"bytes,1,opt,name=rpc_method,json=rpcMethod,proto3" json:"rpc_method,omitempty"` + // use is the one-line usage method. It also allows specifying an alternate + // name for the command as the first word of the usage text. + // + // By default the name of an rpc command is the kebab-case short name of the + // rpc method. + Use string `protobuf:"bytes,2,opt,name=use,proto3" json:"use,omitempty"` + // long is the long message shown in the 'help ' output. + Long string `protobuf:"bytes,3,opt,name=long,proto3" json:"long,omitempty"` + // short is the short description shown in the 'help' output. + Short string `protobuf:"bytes,4,opt,name=short,proto3" json:"short,omitempty"` + // example is examples of how to use the command. + Example string `protobuf:"bytes,5,opt,name=example,proto3" json:"example,omitempty"` + // alias is an array of aliases that can be used instead of the first word in Use. + Alias []string `protobuf:"bytes,6,rep,name=alias,proto3" json:"alias,omitempty"` + // suggest_for is an array of command names for which this command will be suggested - + // similar to aliases but only suggests. + SuggestFor []string `protobuf:"bytes,7,rep,name=suggest_for,json=suggestFor,proto3" json:"suggest_for,omitempty"` + // deprecated defines, if this command is deprecated and should print this string when used. + Deprecated string `protobuf:"bytes,8,opt,name=deprecated,proto3" json:"deprecated,omitempty"` + // version defines the version for this command. If this value is non-empty and the command does not + // define a "version" flag, a "version" boolean flag will be added to the command and, if specified, + // will print content of the "Version" variable. A shorthand "v" flag will also be added if the + // command does not define one. + Version string `protobuf:"bytes,9,opt,name=version,proto3" json:"version,omitempty"` + // flag_options are options for flags generated from rpc request fields. + // By default all request fields are configured as flags. They can + // also be configured as positional args instead using positional_args. + FlagOptions map[string]*FlagOptions `protobuf:"bytes,10,rep,name=flag_options,json=flagOptions,proto3" json:"flag_options,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + // positional_args specifies positional arguments for the command. + PositionalArgs []*PositionalArgDescriptor `protobuf:"bytes,11,rep,name=positional_args,json=positionalArgs,proto3" json:"positional_args,omitempty"` + // skip specifies whether to skip this rpc method when generating commands. + Skip bool `protobuf:"varint,12,opt,name=skip,proto3" json:"skip,omitempty"` +} + +func (x *RpcCommandOptions) Reset() { + *x = RpcCommandOptions{} + if protoimpl.UnsafeEnabled { + mi := &file_cosmos_autocli_v1_options_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *RpcCommandOptions) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RpcCommandOptions) ProtoMessage() {} + +// Deprecated: Use RpcCommandOptions.ProtoReflect.Descriptor instead. +func (*RpcCommandOptions) Descriptor() ([]byte, []int) { + return file_cosmos_autocli_v1_options_proto_rawDescGZIP(), []int{2} +} + +func (x *RpcCommandOptions) GetRpcMethod() string { + if x != nil { + return x.RpcMethod + } + return "" +} + +func (x *RpcCommandOptions) GetUse() string { + if x != nil { + return x.Use + } + return "" +} + +func (x *RpcCommandOptions) GetLong() string { + if x != nil { + return x.Long + } + return "" +} + +func (x *RpcCommandOptions) GetShort() string { + if x != nil { + return x.Short + } + return "" +} + +func (x *RpcCommandOptions) GetExample() string { + if x != nil { + return x.Example + } + return "" +} + +func (x *RpcCommandOptions) GetAlias() []string { + if x != nil { + return x.Alias + } + return nil +} + +func (x *RpcCommandOptions) GetSuggestFor() []string { + if x != nil { + return x.SuggestFor + } + return nil +} + +func (x *RpcCommandOptions) GetDeprecated() string { + if x != nil { + return x.Deprecated + } + return "" +} + +func (x *RpcCommandOptions) GetVersion() string { + if x != nil { + return x.Version + } + return "" +} + +func (x *RpcCommandOptions) GetFlagOptions() map[string]*FlagOptions { + if x != nil { + return x.FlagOptions + } + return nil +} + +func (x *RpcCommandOptions) GetPositionalArgs() []*PositionalArgDescriptor { + if x != nil { + return x.PositionalArgs + } + return nil +} + +func (x *RpcCommandOptions) GetSkip() bool { + if x != nil { + return x.Skip + } + return false +} + +// FlagOptions are options for flags generated from rpc request fields. +// By default, all request fields are configured as flags based on the +// kebab-case name of the field. Fields can be turned into positional arguments +// instead by using RpcCommandOptions.positional_args. +type FlagOptions struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // name is an alternate name to use for the field flag. + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + // shorthand is a one-letter abbreviated flag. + Shorthand string `protobuf:"bytes,2,opt,name=shorthand,proto3" json:"shorthand,omitempty"` + // usage is the help message. + Usage string `protobuf:"bytes,3,opt,name=usage,proto3" json:"usage,omitempty"` + // default_value is the default value as text. + DefaultValue string `protobuf:"bytes,4,opt,name=default_value,json=defaultValue,proto3" json:"default_value,omitempty"` + // default value is the default value as text if the flag is used without any value. + NoOptDefaultValue string `protobuf:"bytes,5,opt,name=no_opt_default_value,json=noOptDefaultValue,proto3" json:"no_opt_default_value,omitempty"` + // deprecated is the usage text to show if this flag is deprecated. + Deprecated string `protobuf:"bytes,6,opt,name=deprecated,proto3" json:"deprecated,omitempty"` + // shorthand_deprecated is the usage text to show if the shorthand of this flag is deprecated. + ShorthandDeprecated string `protobuf:"bytes,7,opt,name=shorthand_deprecated,json=shorthandDeprecated,proto3" json:"shorthand_deprecated,omitempty"` + // hidden hides the flag from help/usage text + Hidden bool `protobuf:"varint,8,opt,name=hidden,proto3" json:"hidden,omitempty"` +} + +func (x *FlagOptions) Reset() { + *x = FlagOptions{} + if protoimpl.UnsafeEnabled { + mi := &file_cosmos_autocli_v1_options_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *FlagOptions) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FlagOptions) ProtoMessage() {} + +// Deprecated: Use FlagOptions.ProtoReflect.Descriptor instead. +func (*FlagOptions) Descriptor() ([]byte, []int) { + return file_cosmos_autocli_v1_options_proto_rawDescGZIP(), []int{3} +} + +func (x *FlagOptions) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *FlagOptions) GetShorthand() string { + if x != nil { + return x.Shorthand + } + return "" +} + +func (x *FlagOptions) GetUsage() string { + if x != nil { + return x.Usage + } + return "" +} + +func (x *FlagOptions) GetDefaultValue() string { + if x != nil { + return x.DefaultValue + } + return "" +} + +func (x *FlagOptions) GetNoOptDefaultValue() string { + if x != nil { + return x.NoOptDefaultValue + } + return "" +} + +func (x *FlagOptions) GetDeprecated() string { + if x != nil { + return x.Deprecated + } + return "" +} + +func (x *FlagOptions) GetShorthandDeprecated() string { + if x != nil { + return x.ShorthandDeprecated + } + return "" +} + +func (x *FlagOptions) GetHidden() bool { + if x != nil { + return x.Hidden + } + return false +} + +// PositionalArgDescriptor describes a positional argument. +type PositionalArgDescriptor struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // proto_field specifies the proto field to use as the positional arg. Any + // fields used as positional args will not have a flag generated. + ProtoField string `protobuf:"bytes,1,opt,name=proto_field,json=protoField,proto3" json:"proto_field,omitempty"` + // varargs makes a positional parameter a varargs parameter. This can only be + // applied to last positional parameter and the proto_field must a repeated + // field. + Varargs bool `protobuf:"varint,2,opt,name=varargs,proto3" json:"varargs,omitempty"` +} + +func (x *PositionalArgDescriptor) Reset() { + *x = PositionalArgDescriptor{} + if protoimpl.UnsafeEnabled { + mi := &file_cosmos_autocli_v1_options_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *PositionalArgDescriptor) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PositionalArgDescriptor) ProtoMessage() {} + +// Deprecated: Use PositionalArgDescriptor.ProtoReflect.Descriptor instead. +func (*PositionalArgDescriptor) Descriptor() ([]byte, []int) { + return file_cosmos_autocli_v1_options_proto_rawDescGZIP(), []int{4} +} + +func (x *PositionalArgDescriptor) GetProtoField() string { + if x != nil { + return x.ProtoField + } + return "" +} + +func (x *PositionalArgDescriptor) GetVarargs() bool { + if x != nil { + return x.Varargs + } + return false +} + +var File_cosmos_autocli_v1_options_proto protoreflect.FileDescriptor + +var file_cosmos_autocli_v1_options_proto_rawDesc = []byte{ + 0x0a, 0x1f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x61, 0x75, 0x74, 0x6f, 0x63, 0x6c, 0x69, + 0x2f, 0x76, 0x31, 0x2f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x12, 0x11, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x61, 0x75, 0x74, 0x6f, 0x63, 0x6c, + 0x69, 0x2e, 0x76, 0x31, 0x1a, 0x20, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x8f, 0x01, 0x0a, 0x0d, 0x4d, 0x6f, 0x64, 0x75, 0x6c, + 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x3b, 0x0a, 0x02, 0x74, 0x78, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x61, 0x75, + 0x74, 0x6f, 0x63, 0x6c, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, + 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, + 0x72, 0x52, 0x02, 0x74, 0x78, 0x12, 0x41, 0x0a, 0x05, 0x71, 0x75, 0x65, 0x72, 0x79, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x61, 0x75, + 0x74, 0x6f, 0x63, 0x6c, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, + 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, + 0x72, 0x52, 0x05, 0x71, 0x75, 0x65, 0x72, 0x79, 0x22, 0xd8, 0x02, 0x0a, 0x18, 0x53, 0x65, 0x72, + 0x76, 0x69, 0x63, 0x65, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x44, 0x65, 0x73, 0x63, 0x72, + 0x69, 0x70, 0x74, 0x6f, 0x72, 0x12, 0x18, 0x0a, 0x07, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, + 0x54, 0x0a, 0x13, 0x72, 0x70, 0x63, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x5f, 0x6f, + 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x63, + 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x61, 0x75, 0x74, 0x6f, 0x63, 0x6c, 0x69, 0x2e, 0x76, 0x31, + 0x2e, 0x52, 0x70, 0x63, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, + 0x6e, 0x73, 0x52, 0x11, 0x72, 0x70, 0x63, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x4f, 0x70, + 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x5f, 0x0a, 0x0c, 0x73, 0x75, 0x62, 0x5f, 0x63, 0x6f, 0x6d, + 0x6d, 0x61, 0x6e, 0x64, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3c, 0x2e, 0x63, 0x6f, + 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x61, 0x75, 0x74, 0x6f, 0x63, 0x6c, 0x69, 0x2e, 0x76, 0x31, 0x2e, + 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x44, 0x65, + 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x53, 0x75, 0x62, 0x43, 0x6f, 0x6d, 0x6d, + 0x61, 0x6e, 0x64, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0b, 0x73, 0x75, 0x62, 0x43, 0x6f, + 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x73, 0x1a, 0x6b, 0x0a, 0x10, 0x53, 0x75, 0x62, 0x43, 0x6f, 0x6d, + 0x6d, 0x61, 0x6e, 0x64, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, + 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x41, 0x0a, 0x05, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x63, 0x6f, + 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x61, 0x75, 0x74, 0x6f, 0x63, 0x6c, 0x69, 0x2e, 0x76, 0x31, 0x2e, + 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x44, 0x65, + 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, + 0x02, 0x38, 0x01, 0x22, 0x9c, 0x04, 0x0a, 0x11, 0x52, 0x70, 0x63, 0x43, 0x6f, 0x6d, 0x6d, 0x61, + 0x6e, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x72, 0x70, 0x63, + 0x5f, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x72, + 0x70, 0x63, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x73, 0x65, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x75, 0x73, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6c, 0x6f, + 0x6e, 0x67, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6c, 0x6f, 0x6e, 0x67, 0x12, 0x14, + 0x0a, 0x05, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, + 0x68, 0x6f, 0x72, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x18, + 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x12, 0x14, + 0x0a, 0x05, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x61, + 0x6c, 0x69, 0x61, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x75, 0x67, 0x67, 0x65, 0x73, 0x74, 0x5f, + 0x66, 0x6f, 0x72, 0x18, 0x07, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x73, 0x75, 0x67, 0x67, 0x65, + 0x73, 0x74, 0x46, 0x6f, 0x72, 0x12, 0x1e, 0x0a, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, + 0x74, 0x65, 0x64, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, + 0x63, 0x61, 0x74, 0x65, 0x64, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, + 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, + 0x58, 0x0a, 0x0c, 0x66, 0x6c, 0x61, 0x67, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, + 0x0a, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x35, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x61, + 0x75, 0x74, 0x6f, 0x63, 0x6c, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x70, 0x63, 0x43, 0x6f, 0x6d, + 0x6d, 0x61, 0x6e, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x46, 0x6c, 0x61, 0x67, + 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0b, 0x66, 0x6c, + 0x61, 0x67, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x53, 0x0a, 0x0f, 0x70, 0x6f, 0x73, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x61, 0x72, 0x67, 0x73, 0x18, 0x0b, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x61, 0x75, 0x74, 0x6f, + 0x63, 0x6c, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, + 0x6c, 0x41, 0x72, 0x67, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x52, 0x0e, + 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x41, 0x72, 0x67, 0x73, 0x12, 0x12, + 0x0a, 0x04, 0x73, 0x6b, 0x69, 0x70, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x08, 0x52, 0x04, 0x73, 0x6b, + 0x69, 0x70, 0x1a, 0x5e, 0x0a, 0x10, 0x46, 0x6c, 0x61, 0x67, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, + 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x34, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, + 0x2e, 0x61, 0x75, 0x74, 0x6f, 0x63, 0x6c, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x46, 0x6c, 0x61, 0x67, + 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, + 0x38, 0x01, 0x22, 0x96, 0x02, 0x0a, 0x0b, 0x46, 0x6c, 0x61, 0x67, 0x4f, 0x70, 0x74, 0x69, 0x6f, + 0x6e, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x68, + 0x61, 0x6e, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x68, 0x6f, 0x72, 0x74, + 0x68, 0x61, 0x6e, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x75, 0x73, 0x61, 0x67, 0x65, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x05, 0x75, 0x73, 0x61, 0x67, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x64, 0x65, + 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x0c, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, + 0x2f, 0x0a, 0x14, 0x6e, 0x6f, 0x5f, 0x6f, 0x70, 0x74, 0x5f, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, + 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x11, 0x6e, + 0x6f, 0x4f, 0x70, 0x74, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, + 0x12, 0x1e, 0x0a, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x18, 0x06, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, + 0x12, 0x31, 0x0a, 0x14, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x68, 0x61, 0x6e, 0x64, 0x5f, 0x64, 0x65, + 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x13, + 0x73, 0x68, 0x6f, 0x72, 0x74, 0x68, 0x61, 0x6e, 0x64, 0x44, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, + 0x74, 0x65, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x68, 0x69, 0x64, 0x64, 0x65, 0x6e, 0x18, 0x08, 0x20, + 0x01, 0x28, 0x08, 0x52, 0x06, 0x68, 0x69, 0x64, 0x64, 0x65, 0x6e, 0x22, 0x54, 0x0a, 0x17, 0x50, + 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x41, 0x72, 0x67, 0x44, 0x65, 0x73, 0x63, + 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x61, 0x72, 0x61, 0x72, + 0x67, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x76, 0x61, 0x72, 0x61, 0x72, 0x67, + 0x73, 0x42, 0xb9, 0x01, 0x0a, 0x15, 0x63, 0x6f, 0x6d, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, + 0x2e, 0x61, 0x75, 0x74, 0x6f, 0x63, 0x6c, 0x69, 0x2e, 0x76, 0x31, 0x42, 0x0c, 0x4f, 0x70, 0x74, + 0x69, 0x6f, 0x6e, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x2c, 0x63, 0x6f, 0x73, + 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x63, 0x6f, + 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x61, 0x75, 0x74, 0x6f, 0x63, 0x6c, 0x69, 0x2f, 0x76, 0x31, 0x3b, + 0x61, 0x75, 0x74, 0x6f, 0x63, 0x6c, 0x69, 0x76, 0x31, 0xa2, 0x02, 0x03, 0x43, 0x41, 0x58, 0xaa, + 0x02, 0x11, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x41, 0x75, 0x74, 0x6f, 0x63, 0x6c, 0x69, + 0x2e, 0x56, 0x31, 0xca, 0x02, 0x11, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x5c, 0x41, 0x75, 0x74, + 0x6f, 0x63, 0x6c, 0x69, 0x5c, 0x56, 0x31, 0xe2, 0x02, 0x1d, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, + 0x5c, 0x41, 0x75, 0x74, 0x6f, 0x63, 0x6c, 0x69, 0x5c, 0x56, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, + 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x13, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, + 0x3a, 0x3a, 0x41, 0x75, 0x74, 0x6f, 0x63, 0x6c, 0x69, 0x3a, 0x3a, 0x56, 0x31, 0x62, 0x06, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_cosmos_autocli_v1_options_proto_rawDescOnce sync.Once + file_cosmos_autocli_v1_options_proto_rawDescData = file_cosmos_autocli_v1_options_proto_rawDesc +) + +func file_cosmos_autocli_v1_options_proto_rawDescGZIP() []byte { + file_cosmos_autocli_v1_options_proto_rawDescOnce.Do(func() { + file_cosmos_autocli_v1_options_proto_rawDescData = protoimpl.X.CompressGZIP(file_cosmos_autocli_v1_options_proto_rawDescData) + }) + return file_cosmos_autocli_v1_options_proto_rawDescData +} + +var file_cosmos_autocli_v1_options_proto_msgTypes = make([]protoimpl.MessageInfo, 7) +var file_cosmos_autocli_v1_options_proto_goTypes = []interface{}{ + (*ModuleOptions)(nil), // 0: cosmos.autocli.v1.ModuleOptions + (*ServiceCommandDescriptor)(nil), // 1: cosmos.autocli.v1.ServiceCommandDescriptor + (*RpcCommandOptions)(nil), // 2: cosmos.autocli.v1.RpcCommandOptions + (*FlagOptions)(nil), // 3: cosmos.autocli.v1.FlagOptions + (*PositionalArgDescriptor)(nil), // 4: cosmos.autocli.v1.PositionalArgDescriptor + nil, // 5: cosmos.autocli.v1.ServiceCommandDescriptor.SubCommandsEntry + nil, // 6: cosmos.autocli.v1.RpcCommandOptions.FlagOptionsEntry +} +var file_cosmos_autocli_v1_options_proto_depIdxs = []int32{ + 1, // 0: cosmos.autocli.v1.ModuleOptions.tx:type_name -> cosmos.autocli.v1.ServiceCommandDescriptor + 1, // 1: cosmos.autocli.v1.ModuleOptions.query:type_name -> cosmos.autocli.v1.ServiceCommandDescriptor + 2, // 2: cosmos.autocli.v1.ServiceCommandDescriptor.rpc_command_options:type_name -> cosmos.autocli.v1.RpcCommandOptions + 5, // 3: cosmos.autocli.v1.ServiceCommandDescriptor.sub_commands:type_name -> cosmos.autocli.v1.ServiceCommandDescriptor.SubCommandsEntry + 6, // 4: cosmos.autocli.v1.RpcCommandOptions.flag_options:type_name -> cosmos.autocli.v1.RpcCommandOptions.FlagOptionsEntry + 4, // 5: cosmos.autocli.v1.RpcCommandOptions.positional_args:type_name -> cosmos.autocli.v1.PositionalArgDescriptor + 1, // 6: cosmos.autocli.v1.ServiceCommandDescriptor.SubCommandsEntry.value:type_name -> cosmos.autocli.v1.ServiceCommandDescriptor + 3, // 7: cosmos.autocli.v1.RpcCommandOptions.FlagOptionsEntry.value:type_name -> cosmos.autocli.v1.FlagOptions + 8, // [8:8] is the sub-list for method output_type + 8, // [8:8] is the sub-list for method input_type + 8, // [8:8] is the sub-list for extension type_name + 8, // [8:8] is the sub-list for extension extendee + 0, // [0:8] is the sub-list for field type_name +} + +func init() { file_cosmos_autocli_v1_options_proto_init() } +func file_cosmos_autocli_v1_options_proto_init() { + if File_cosmos_autocli_v1_options_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_cosmos_autocli_v1_options_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ModuleOptions); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cosmos_autocli_v1_options_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ServiceCommandDescriptor); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cosmos_autocli_v1_options_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*RpcCommandOptions); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cosmos_autocli_v1_options_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*FlagOptions); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cosmos_autocli_v1_options_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*PositionalArgDescriptor); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_cosmos_autocli_v1_options_proto_rawDesc, + NumEnums: 0, + NumMessages: 7, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_cosmos_autocli_v1_options_proto_goTypes, + DependencyIndexes: file_cosmos_autocli_v1_options_proto_depIdxs, + MessageInfos: file_cosmos_autocli_v1_options_proto_msgTypes, + }.Build() + File_cosmos_autocli_v1_options_proto = out.File + file_cosmos_autocli_v1_options_proto_rawDesc = nil + file_cosmos_autocli_v1_options_proto_goTypes = nil + file_cosmos_autocli_v1_options_proto_depIdxs = nil +} diff --git a/client/v2/cli/testdata/bank_example.yaml b/client/v2/cli/testdata/bank_example.yaml new file mode 100644 index 000000000..6fb937482 --- /dev/null +++ b/client/v2/cli/testdata/bank_example.yaml @@ -0,0 +1,28 @@ +tx: + service: cosmos.bank.v1beta1.Msg + rpc_command_options: + - rpc_method: Send + use: send [from_key_or_address] [to_address] [amount...] + positional_args: + - proto_field: from_address + - proto_field: to_address + - proto_field: amount + varargs: true +query: + service: cosmos.bank.v1beta1.Query + rpc_command_options: + - rpc_method: Balance + use: balance [address] [denom] + positional_args: + - proto_field: address + - proto_field: denom + - rpc_method: SupplyOf + # this is a contrived example of how to customize flag options + # we would likely prefer positional args here, but this demonstrates usage + use: supply-of --denom [denom] + flag_options: + # flag_options is a map of proto field names to customization options + denom: + shorthand: d + usage: the denom to query + diff --git a/proto/cosmos/autocli/v1/options.proto b/proto/cosmos/autocli/v1/options.proto new file mode 100644 index 000000000..9061d154c --- /dev/null +++ b/proto/cosmos/autocli/v1/options.proto @@ -0,0 +1,129 @@ +syntax = "proto3"; + +package cosmos.autocli.v1; + +import "google/protobuf/descriptor.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/api/cosmos/base/cli/v1;cliv1"; + +// ModuleOptions describes the CLI options for a Cosmos SDK module. +message ModuleOptions { + // tx describes the tx command for the module. + ServiceCommandDescriptor tx = 1; + + // query describes the tx command for the module. + ServiceCommandDescriptor query = 2; +} + +// ServiceCommandDescriptor describes a CLI command based on a protobuf service. +message ServiceCommandDescriptor { + + // service is the fully qualified name of the protobuf service to build + // the command from. It can be left empty if sub_commands are used instead + // which may be the case if a module provides multiple tx and/or query services. + string service = 1; + + // rpc_command_options are options for commands generated from rpc methods. + // If no options are specified for a given rpc method on the service, a + // command will be generated for that method with the default options. + repeated RpcCommandOptions rpc_command_options = 2; + + // sub_commands is a map of optional sub-commands for this command based on + // different protobuf services. The map key is used as the name of the + // sub-command. + map sub_commands = 3; +} + +// RpcCommandOptions specifies options for commands generated from protobuf +// rpc methods. +message RpcCommandOptions { + // rpc_method is short name of the protobuf rpc method that this command is + // generated from. + string rpc_method = 1; + + // use is the one-line usage method. It also allows specifying an alternate + // name for the command as the first word of the usage text. + // + // By default the name of an rpc command is the kebab-case short name of the + // rpc method. + string use = 2; + + // long is the long message shown in the 'help ' output. + string long = 3; + + // short is the short description shown in the 'help' output. + string short = 4; + + // example is examples of how to use the command. + string example = 5; + + // alias is an array of aliases that can be used instead of the first word in Use. + repeated string alias = 6; + + // suggest_for is an array of command names for which this command will be suggested - + // similar to aliases but only suggests. + repeated string suggest_for = 7; + + // deprecated defines, if this command is deprecated and should print this string when used. + string deprecated = 8; + + // version defines the version for this command. If this value is non-empty and the command does not + // define a "version" flag, a "version" boolean flag will be added to the command and, if specified, + // will print content of the "Version" variable. A shorthand "v" flag will also be added if the + // command does not define one. + string version = 9; + + // flag_options are options for flags generated from rpc request fields. + // By default all request fields are configured as flags. They can + // also be configured as positional args instead using positional_args. + map flag_options = 10; + + // positional_args specifies positional arguments for the command. + repeated PositionalArgDescriptor positional_args = 11; + + // skip specifies whether to skip this rpc method when generating commands. + bool skip = 12; +} + +// FlagOptions are options for flags generated from rpc request fields. +// By default, all request fields are configured as flags based on the +// kebab-case name of the field. Fields can be turned into positional arguments +// instead by using RpcCommandOptions.positional_args. +message FlagOptions { + + // name is an alternate name to use for the field flag. + string name = 1; + + // shorthand is a one-letter abbreviated flag. + string shorthand = 2; + + // usage is the help message. + string usage = 3; + + // default_value is the default value as text. + string default_value = 4; + + // default value is the default value as text if the flag is used without any value. + string no_opt_default_value = 5; + + // deprecated is the usage text to show if this flag is deprecated. + string deprecated = 6; + + // shorthand_deprecated is the usage text to show if the shorthand of this flag is deprecated. + string shorthand_deprecated = 7; + + // hidden hides the flag from help/usage text + bool hidden = 8; +} + +// PositionalArgDescriptor describes a positional argument. +message PositionalArgDescriptor { + // proto_field specifies the proto field to use as the positional arg. Any + // fields used as positional args will not have a flag generated. + string proto_field = 1; + + // varargs makes a positional parameter a varargs parameter. This can only be + // applied to last positional parameter and the proto_field must a repeated + // field. + bool varargs = 2; +} diff --git a/scripts/protocgen.sh b/scripts/protocgen.sh index 27cd2c4c9..067721b73 100755 --- a/scripts/protocgen.sh +++ b/scripts/protocgen.sh @@ -11,7 +11,7 @@ cd proto proto_dirs=$(find ./cosmos -path -prune -o -name '*.proto' -print0 | xargs -0 -n1 dirname | sort | uniq) for dir in $proto_dirs; do for file in $(find "${dir}" -maxdepth 1 -name '*.proto'); do - if grep "option go_package" $file &> /dev/null ; then + if grep "option go_package.*(?!cosmos-sdk/api)" $file &> /dev/null ; then buf generate --template buf.gen.gogo.yaml $file fi done