diff --git a/v2/pkg/engine/datasource/grpc_datasource/compiler.go b/v2/pkg/engine/datasource/grpc_datasource/compiler.go index 2c5a082272..3fe77fea83 100644 --- a/v2/pkg/engine/datasource/grpc_datasource/compiler.go +++ b/v2/pkg/engine/datasource/grpc_datasource/compiler.go @@ -948,7 +948,7 @@ func (p *RPCCompiler) setMessageValue(message protoref.Message, fieldName string return nil } - message.Set(message.Descriptor().Fields().ByName(protoref.Name(fieldName)), value) + message.Set(fd, value) return nil } @@ -970,150 +970,259 @@ func (p *RPCCompiler) buildProtoMessage(inputMessage Message, rpcMessage *RPCMes return nil, fmt.Errorf("message %s not found in document", inputMessage.Name) } + // Handle oneof types (interfaces/unions) by populating the correct oneof field + // based on the __typename in the JSON data. + if rpcMessage.IsOneOf() { + return p.buildOneOfMessage(inputMessage, rpcMessage, data) + } + message := dynamicpb.NewMessage(inputMessage.Desc) for _, rpcField := range rpcMessage.Fields { - fd := inputMessage.Desc.Fields() - - // Look up the field in the RPC message definition - field := inputMessage.GetField(rpcField.Name) - if field == nil { + fd := inputMessage.Desc.Fields().ByName(protoref.Name(rpcField.Name)) + if fd == nil { continue } - // Handle repeated fields (arrays/lists) - if field.Repeated { - // Get a mutable reference to the list field - list := message.Mutable(fd.ByName(protoref.Name(field.Name))).List() - // Extract the array elements from the JSON data - elements := data.Get(rpcField.JSONPath).Array() - if len(elements) == 0 { + if err := p.processRPCField(inputMessage, message, fd, &rpcField, data); err != nil { + return nil, err + } + } + + return message, nil +} + +// processRPCField populates a single field on a protobuf message from JSON data. +// It dispatches to specialized handlers based on the field's type: repeated, message, enum, or scalar. +func (p *RPCCompiler) processRPCField(inputMessage Message, message protoref.Message, fd protoref.FieldDescriptor, rpcField *RPCField, data gjson.Result) error { + field := inputMessage.GetField(rpcField.Name) + if field == nil { + return fmt.Errorf("field %s not found in message %s", rpcField.Name, inputMessage.Name) + } + + if field.Repeated { + return p.processRepeatedField(message, fd, field, rpcField, data) + } + + if field.MessageRef >= 0 { + return p.processMessageField(inputMessage, message, fd, field, rpcField, data) + } + + if field.Type == DataTypeEnum { + return p.processEnumField(message, fd, rpcField, data) + } + + return p.setMessageValue(message, field.Name, p.setValueForKind(field.Type, data.Get(rpcField.JSONPath))) +} + +// processRepeatedField handles repeated (array/list) fields by iterating +// JSON array elements and appending each to the protobuf list. +func (p *RPCCompiler) processRepeatedField(message protoref.Message, fd protoref.FieldDescriptor, field *Field, rpcField *RPCField, data gjson.Result) error { + elements := data.Get(rpcField.JSONPath).Array() + if len(elements) == 0 { + return nil + } + + list := message.Mutable(fd).List() + + for _, element := range elements { + switch field.Type { + case DataTypeMessage: + // For entity lookups, filter by __typename to apply only matching representations. + if !isAllowedForTypename(rpcField.Message, element) { continue } - // Process each element and append to the list - for _, element := range elements { - switch field.Type { - case DataTypeMessage: - // If we handle entity lookups, we get a list of representation variables that need to - // be applied to the correct type names. - if !isAllowedForTypename(rpcField.Message, element) { - continue - } - - fieldMsg, err := p.buildProtoMessage(p.doc.Messages[field.MessageRef], rpcField.Message, element) - if err != nil { - return nil, err - } - - list.Append(protoref.ValueOfMessage(fieldMsg)) - default: - list.Append(p.setValueForKind(field.Type, element)) - } + fieldMsg, err := p.buildProtoMessage(p.doc.Messages[field.MessageRef], rpcField.Message, element) + if err != nil { + return err } - continue + list.Append(protoref.ValueOfMessage(fieldMsg)) + default: + list.Append(p.setValueForKind(field.Type, element)) } + } - // Handle nested message fields - if field.MessageRef >= 0 { - var ( - fieldMsg protoref.Message - err error - ) - fieldData := data.Get(rpcField.JSONPath) - - switch { - case rpcField.IsListType: - // Nested and nullable lists are wrapped in a message, therefore we need to handle them differently - // than repeated fields. We need to do this because protobuf repeated fields are not nullable and cannot be nested. - // - // message BlogPost { - // ListOfBoolean is_published = 1; - // ListOfListOfString related_topics = 2; - // } - if !isNonNullValue(fieldData) { - if !rpcField.Optional { - return nil, fmt.Errorf("field %s is required but has no value", rpcField.JSONPath) - } + return nil +} - continue - } +// processMessageField handles nested message fields, dispatching to the +// appropriate builder based on whether the field is a list wrapper, optional +// scalar wrapper, or a regular nested message. +func (p *RPCCompiler) processMessageField(inputMessage Message, message protoref.Message, fd protoref.FieldDescriptor, field *Field, rpcField *RPCField, data gjson.Result) error { + fieldMsg, err := p.resolveNestedMessage(inputMessage.Desc, field, rpcField, data) + if err != nil { + return err + } - if rpcField.ListMetadata == nil { - return nil, fmt.Errorf("list metadata not found for field %s", rpcField.JSONPath) - } + if fieldMsg == nil { + return nil + } - fieldMsg, err = p.buildListMessage(inputMessage.Desc, field, &rpcField, data) - if err != nil { - return nil, err - } + message.Set(fd, protoref.ValueOfMessage(fieldMsg)) + return nil +} - if fieldMsg == nil { - continue - } +// resolveNestedMessage builds the protobuf message for a nested field. +// It handles three cases: +// - List wrapper types for nullable/nested lists that cannot be expressed as plain repeated fields. +// - Optional scalar wrappers (e.g. google.protobuf.StringValue) for nullable scalars. +// - Regular nested messages built recursively. +func (p *RPCCompiler) resolveNestedMessage(inputMessageDesc protoref.MessageDescriptor, field *Field, rpcField *RPCField, data gjson.Result) (protoref.Message, error) { + fieldData := data.Get(rpcField.JSONPath) + + switch { + case rpcField.IsListType: + if isNullValue(fieldData) { + if !rpcField.Optional { + return nil, fmt.Errorf("field %s is required but has no value", rpcField.JSONPath) + } + return nil, nil + } - case rpcField.IsOptionalScalar(): - // If the field is optional, we are handling a scalar value that is wrapped in a message - // as protobuf scalar types are not nullable. + if rpcField.ListMetadata == nil { + return nil, fmt.Errorf("list metadata not found for field %s", rpcField.JSONPath) + } - if !isNonNullValue(fieldData) { - // If we don't have a concrete value for an optional field, leave it unset (absent). - continue - } + return p.buildListMessage(inputMessageDesc, field, rpcField, data) - // As those optional messages are well known wrapper types, we can convert them to the underlying message definition. - fieldMsg, err = p.buildProtoMessage( - p.doc.Messages[field.MessageRef], - rpcField.ToOptionalTypeMessage(p.doc.Messages[field.MessageRef].Name), - data, - ) + case rpcField.IsOptionalScalar(): + if isNullValue(fieldData) { + // If we don't have a concrete value for an optional field, leave it unset (absent). + return nil, nil + } - if err != nil { - return nil, err - } - default: - if !isNonNullValue(fieldData) { - if !rpcField.Optional { - return nil, fmt.Errorf("field %s is required but has no value", rpcField.JSONPath) - } + return p.buildProtoMessage( + p.doc.Messages[field.MessageRef], + rpcField.ToOptionalTypeMessage(p.doc.Messages[field.MessageRef].Name), + data, + ) - continue - } - - fieldMsg, err = p.buildProtoMessage(p.doc.Messages[field.MessageRef], rpcField.Message, fieldData) - if err != nil { - return nil, err - } + default: + if isNullValue(fieldData) { + if !rpcField.Optional { + return nil, fmt.Errorf("field %s is required but has no value", rpcField.JSONPath) } + return nil, nil + } + + return p.buildProtoMessage(p.doc.Messages[field.MessageRef], rpcField.Message, fieldData) + } +} + +// processEnumField resolves an enum value by name and sets it on the message. +func (p *RPCCompiler) processEnumField(message protoref.Message, fd protoref.FieldDescriptor, rpcField *RPCField, data gjson.Result) error { + val, err := p.getEnumValue(rpcField.EnumName, data.Get(rpcField.JSONPath)) + if err != nil { + return err + } + + message.Set(fd, val) + return nil +} + +// buildOneOfMessage constructs a protobuf message for a GraphQL interface or union type. +// It reads the __typename from the JSON data to determine which concrete type was returned, +// looks up the matching oneof variant via findOneOfFieldDescriptor, and populates the +// sub-message with the fragment fields for that concrete type. +// If __typename is absent or no matching fragment/oneof variant is found, the empty +// parent message is returned without setting any oneof field. +func (p *RPCCompiler) buildOneOfMessage(inputMessage Message, rpcMessage *RPCMessage, data gjson.Result) (protoref.Message, error) { + message := dynamicpb.NewMessage(inputMessage.Desc) + typeName := data.Get("__typename").String() + if typeName == "" { + return nil, errors.New("unable to build oneof message: __typename is required to determine the concrete type") + } + + fragmentFields, ok := rpcMessage.FragmentFields[typeName] + if !ok { + return message, nil + } - message.Set(inputMessage.Desc.Fields().ByName(protoref.Name(field.Name)), protoref.ValueOfMessage(fieldMsg)) + // Find the matching oneof field descriptor for the expected concrete type. + oneofFieldDesc := p.findOneOfFieldDescriptor(inputMessage.Desc.Oneofs(), protoref.Name(rpcMessage.OneOfType.FieldName()), protoref.Name(typeName)) + if oneofFieldDesc == nil { + return message, nil + } + + // We expect the oneof field to be a message type, as we expect oneofs only for interfaces and unions. + if oneofFieldDesc.Kind() != protoref.MessageKind { + return nil, fmt.Errorf("unsupported: oneof field %s is not a message type", oneofFieldDesc.Name()) + } + + subMsg := dynamicpb.NewMessage(oneofFieldDesc.Message()) + for _, fragmentRPCField := range fragmentFields { + subFieldDesc := oneofFieldDesc.Message().Fields().ByName(protoref.Name(fragmentRPCField.Name)) + if subFieldDesc == nil { continue } - if field.Type == DataTypeEnum { - val, err := p.getEnumValue(rpcField.EnumName, data.Get(rpcField.JSONPath)) - if err != nil { - return nil, err - } + fullMessageName := p.fullMessageName(oneofFieldDesc.Message()) + msg, found := p.doc.MessageByName(fullMessageName) + if !found { + return nil, fmt.Errorf("message %s not found in document", fullMessageName) + } - if val != nil { - message.Set(fd.ByName(protoref.Name(field.Name)), *val) - } + if err := p.processRPCField(msg, subMsg, subFieldDesc, &fragmentRPCField, data); err != nil { + return nil, err + } + } + + message.Set(oneofFieldDesc, protoref.ValueOfMessage(subMsg)) + + return message, nil +} + +// findOneOfFieldDescriptor looks up a oneof field descriptor whose message name matches typeName. +// This is used when resolving @requires fields that contain interface/union types, which are +// represented as protobuf oneof fields. Unions use "value" and interfaces use "instance": +// +// message MyUnion { +// oneof value { +// ConcreteTypeA concrete_type_a = 1; +// ConcreteTypeB concrete_type_b = 2; +// } +// } +// +// message MyInterface { +// oneof instance { +// ImplementorA implementor_a = 1; +// ImplementorB implementor_b = 2; +// } +// } +// +// Calling findOneOfFieldDescriptor(MyUnion.oneofs, "value", "ConcreteTypeA") returns the +// field descriptor for concrete_type_a, allowing the compiler to set the correct oneof +// variant when constructing the protobuf message. +func (p *RPCCompiler) findOneOfFieldDescriptor(oneOfs protoref.OneofDescriptors, oneofFieldName, typeName protoref.Name) protoref.FieldDescriptor { + if oneOfs == nil || oneOfs.Len() == 0 { + return nil + } + oneofDesc := oneOfs.ByName(oneofFieldName) + if oneofDesc == nil { + return nil + } + + for i := range oneofDesc.Fields().Len() { + fd := oneofDesc.Fields().Get(i) + // For interfaces and unions, we will only be dealing with message types. + if fd.Kind() != protoref.MessageKind { continue } - // Handle scalar fields - value := data.Get(rpcField.JSONPath) - message.Set(fd.ByName(protoref.Name(field.Name)), p.setValueForKind(field.Type, value)) + // The Protobuf representation of the message field will have the concrete type name as the message name. + if fd.Message().Name() == typeName { + return fd + } } - return message, nil + return nil } -func isNonNullValue(data gjson.Result) bool { - return data.Exists() && data.Type != gjson.Null +func isNullValue(data gjson.Result) bool { + return !data.Exists() || data.Type == gjson.Null } // buildListMessage creates a new protobuf message, which reflects a wrapper type to work with a list in GraphQL. @@ -1177,7 +1286,7 @@ func (p *RPCCompiler) traverseList(rootMsg protoref.Message, level int, field *F itemsField := itemsFieldMsg.Mutable(itemsFieldDesc).List() if level >= rpcField.ListMetadata.NestingLevel { - switch DataType(rpcField.ProtoTypeName) { + switch rpcField.ProtoTypeName { case DataTypeMessage: itemsFieldMsg, ok := p.doc.MessageByName(rpcField.Message.Name) if !ok { @@ -1201,9 +1310,7 @@ func (p *RPCCompiler) traverseList(rootMsg protoref.Message, level int, field *F return nil, err } - if val != nil { - itemsField.Append(*val) - } + itemsField.Append(val) } default: for _, element := range elements { @@ -1232,20 +1339,19 @@ func (p *RPCCompiler) traverseList(rootMsg protoref.Message, level int, field *F return rootMsg, nil } -func (p *RPCCompiler) getEnumValue(enumName string, data gjson.Result) (*protoref.Value, error) { +func (p *RPCCompiler) getEnumValue(enumName string, data gjson.Result) (protoref.Value, error) { enum, ok := p.doc.EnumByName(enumName) if !ok { - return nil, fmt.Errorf("enum %s not found in document", enumName) + return protoref.Value{}, fmt.Errorf("enum %s not found in document", enumName) } for _, enumValue := range enum.Values { if enumValue.GraphqlValue == data.String() { - v := protoref.ValueOfEnum(protoref.EnumNumber(enumValue.Number)) - return &v, nil + return protoref.ValueOfEnum(protoref.EnumNumber(enumValue.Number)), nil } } - return nil, nil + return protoref.Value{}, fmt.Errorf("enum value %q not found in enum %s", data.String(), enumName) } // setValueForKind converts a gjson.Result value to the appropriate protobuf value @@ -1417,13 +1523,8 @@ func (p *RPCCompiler) parseField(f protoref.FieldDescriptor) Field { } func isAllowedForTypename(message *RPCMessage, element gjson.Result) bool { - if message == nil { - // We assume that having a nil message expects a null value. - return true - } - - // If we don't have a member types, we assume that the message is allowed for all types. - if message.MemberTypes == nil { + // If we don't have a message or member types, we assume that the message is allowed for all types. + if message == nil || message.MemberTypes == nil { return true } @@ -1433,8 +1534,6 @@ func isAllowedForTypename(message *RPCMessage, element gjson.Result) bool { return true } - typeString := typeName.String() - // If we have a type name, we need to check if the message is restricted to a specific type. - return slices.Contains(message.MemberTypes, typeString) + return slices.Contains(message.MemberTypes, typeName.String()) } diff --git a/v2/pkg/engine/datasource/grpc_datasource/compiler_input_presence_test.go b/v2/pkg/engine/datasource/grpc_datasource/compiler_input_presence_test.go deleted file mode 100644 index 4b4b77b94f..0000000000 --- a/v2/pkg/engine/datasource/grpc_datasource/compiler_input_presence_test.go +++ /dev/null @@ -1,141 +0,0 @@ -package grpcdatasource - -import ( - "testing" - - "github.com/stretchr/testify/require" - "github.com/tidwall/gjson" - "google.golang.org/protobuf/reflect/protoreflect" -) - -const protoSchemaWithOptionalNestedInputs = ` -syntax = "proto3"; -package rule.v1; - -import "google/protobuf/wrappers.proto"; - -service RuleService { - rpc UpdateRule(UpdateRuleRequest) returns (UpdateRuleResponse) {} -} - -message UpdateRuleRequest { - ConditionsInput conditions = 1; - google.protobuf.StringValue params = 2; -} - -message ConditionsInput { - string key = 1; -} - -message UpdateRuleResponse {} -` - -func TestCompileOptionalNestedInputsTreatsNullAsAbsent(t *testing.T) { - t.Parallel() - - testCases := []struct { - name string - input string - expectConditions bool - expectConditionsKey bool - expectParams bool - }{ - { - name: "omitted optional fields stay absent", - input: `{}`, - expectConditions: false, - expectParams: false, - }, - { - name: "null optional fields stay absent", - input: `{"conditions":null,"params":null}`, - expectConditions: false, - expectParams: false, - }, - { - name: "explicit empty object keeps nested message", - input: `{"conditions":{}}`, - expectConditions: true, - expectConditionsKey: false, - expectParams: false, - }, - { - name: "explicit nested value is preserved", - input: `{"conditions":{"key":"status"},"params":"{\"value\":\"1212\"}"}`, - expectConditions: true, - expectConditionsKey: true, - expectParams: true, - }, - } - - for _, tc := range testCases { - t.Run(tc.name, func(t *testing.T) { - t.Parallel() - compiler, err := NewProtoCompiler(protoSchemaWithOptionalNestedInputs, nil) - require.NoError(t, err) - - inputMessage, ok := compiler.doc.MessageByName("UpdateRuleRequest") - require.True(t, ok) - - request, err := compiler.buildProtoMessage(inputMessage, optionalNestedInputsMessage(), gjson.Parse(tc.input)) - require.NoError(t, err) - - conditionsDesc := request.Descriptor().Fields().ByName(protoreflect.Name("conditions")) - require.NotNil(t, conditionsDesc) - require.Equal(t, tc.expectConditions, request.Has(conditionsDesc)) - - if tc.expectConditions { - conditions := request.Get(conditionsDesc).Message() - keyDesc := conditions.Descriptor().Fields().ByName(protoreflect.Name("key")) - require.NotNil(t, keyDesc) - require.Equal(t, tc.expectConditionsKey, conditions.Has(keyDesc)) - if tc.expectConditionsKey { - require.Equal(t, "status", conditions.Get(keyDesc).String()) - } - } - - paramsDesc := request.Descriptor().Fields().ByName(protoreflect.Name("params")) - require.NotNil(t, paramsDesc) - require.Equal(t, tc.expectParams, request.Has(paramsDesc)) - - if tc.expectParams { - params := request.Get(paramsDesc).Message() - valueDesc := params.Descriptor().Fields().ByName(protoreflect.Name("value")) - require.NotNil(t, valueDesc) - require.True(t, params.Has(valueDesc)) - require.Equal(t, `{"value":"1212"}`, params.Get(valueDesc).String()) - } - }) - } -} - -func optionalNestedInputsMessage() *RPCMessage { - return &RPCMessage{ - Name: "UpdateRuleRequest", - Fields: RPCFields{ - { - Name: "conditions", - ProtoTypeName: DataTypeMessage, - JSONPath: "conditions", - Optional: true, - Message: &RPCMessage{ - Name: "ConditionsInput", - Fields: RPCFields{ - { - Name: "key", - ProtoTypeName: DataTypeString, - JSONPath: "key", - Optional: true, - }, - }, - }, - }, - { - Name: "params", - ProtoTypeName: DataTypeString, - JSONPath: "params", - Optional: true, - }, - }, - } -} diff --git a/v2/pkg/engine/datasource/grpc_datasource/compiler_test.go b/v2/pkg/engine/datasource/grpc_datasource/compiler_test.go index ccc8c07395..0afcbb692d 100644 --- a/v2/pkg/engine/datasource/grpc_datasource/compiler_test.go +++ b/v2/pkg/engine/datasource/grpc_datasource/compiler_test.go @@ -506,3 +506,135 @@ func TestCompileNestedMessages(t *testing.T) { require.Equal(t, "SecondMessage.MyMessage", compiler.doc.Messages[3].Name) require.Equal(t, "SecondMessage.MyMessage.NestedMessage", compiler.doc.Messages[4].Name) } + +func TestCompileOptionalNestedInputsTreatsNullAsAbsent(t *testing.T) { + t.Parallel() + + testCases := []struct { + name string + input string + expectConditions bool + expectConditionsKey bool + expectParams bool + }{ + { + name: "omitted optional fields stay absent", + input: `{}`, + expectConditions: false, + expectParams: false, + }, + { + name: "null optional fields stay absent", + input: `{"conditions":null,"params":null}`, + expectConditions: false, + expectParams: false, + }, + { + name: "explicit empty object keeps nested message", + input: `{"conditions":{}}`, + expectConditions: true, + expectConditionsKey: false, + expectParams: false, + }, + { + name: "explicit nested value is preserved", + input: `{"conditions":{"key":"status"},"params":"{\"value\":\"1212\"}"}`, + expectConditions: true, + expectConditionsKey: true, + expectParams: true, + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + t.Parallel() + compiler, err := NewProtoCompiler(protoSchemaWithOptionalNestedInputs, nil) + require.NoError(t, err) + + inputMessage, ok := compiler.doc.MessageByName("UpdateRuleRequest") + require.True(t, ok) + + request, err := compiler.buildProtoMessage(inputMessage, optionalNestedInputsMessage(), gjson.Parse(tc.input)) + require.NoError(t, err) + + conditionsDesc := request.Descriptor().Fields().ByName(protoreflect.Name("conditions")) + require.NotNil(t, conditionsDesc) + require.Equal(t, tc.expectConditions, request.Has(conditionsDesc)) + + if tc.expectConditions { + conditions := request.Get(conditionsDesc).Message() + keyDesc := conditions.Descriptor().Fields().ByName(protoreflect.Name("key")) + require.NotNil(t, keyDesc) + require.Equal(t, tc.expectConditionsKey, conditions.Has(keyDesc)) + if tc.expectConditionsKey { + require.Equal(t, "status", conditions.Get(keyDesc).String()) + } + } + + paramsDesc := request.Descriptor().Fields().ByName(protoreflect.Name("params")) + require.NotNil(t, paramsDesc) + require.Equal(t, tc.expectParams, request.Has(paramsDesc)) + + if tc.expectParams { + params := request.Get(paramsDesc).Message() + valueDesc := params.Descriptor().Fields().ByName(protoreflect.Name("value")) + require.NotNil(t, valueDesc) + require.True(t, params.Has(valueDesc)) + require.Equal(t, `{"value":"1212"}`, params.Get(valueDesc).String()) + } + }) + } +} + +func optionalNestedInputsMessage() *RPCMessage { + return &RPCMessage{ + Name: "UpdateRuleRequest", + Fields: RPCFields{ + { + Name: "conditions", + ProtoTypeName: DataTypeMessage, + JSONPath: "conditions", + Optional: true, + Message: &RPCMessage{ + Name: "ConditionsInput", + Fields: RPCFields{ + { + Name: "key", + ProtoTypeName: DataTypeString, + JSONPath: "key", + Optional: true, + }, + }, + }, + }, + { + Name: "params", + ProtoTypeName: DataTypeString, + JSONPath: "params", + Optional: true, + }, + }, + } +} + +const protoSchemaWithOptionalNestedInputs = ` +syntax = "proto3"; +package rule.v1; + +import "google/protobuf/wrappers.proto"; + +service RuleService { + rpc UpdateRule(UpdateRuleRequest) returns (UpdateRuleResponse) {} +} + +message UpdateRuleRequest { + ConditionsInput conditions = 1; + google.protobuf.StringValue params = 2; +} + +message ConditionsInput { + string key = 1; +} + +message UpdateRuleResponse {} +` diff --git a/v2/pkg/engine/datasource/grpc_datasource/execution_plan.go b/v2/pkg/engine/datasource/grpc_datasource/execution_plan.go index 33a959d293..69c16a746d 100644 --- a/v2/pkg/engine/datasource/grpc_datasource/execution_plan.go +++ b/v2/pkg/engine/datasource/grpc_datasource/execution_plan.go @@ -1073,7 +1073,7 @@ func (r *rpcPlanningContext) getFieldsFromFieldResolverDirective(parentNode ast. walker := astvisitor.WalkerFromPool() defer walker.Release() - v := newRequiredFieldsVisitor(walker, &RPCMessage{}, r) + v := newRequiredFieldsVisitor(walker, &RPCMessage{}, r.mapping) if err := v.visitWithDefaults(r.definition, parentNode.NameString(r.definition), fieldsString); err != nil { return nil, err } @@ -1420,7 +1420,7 @@ func (r *rpcPlanningContext) createRequiredFieldsRPCCall(callIndex int, subgraph walker := astvisitor.WalkerFromPool() defer walker.Release() - vis := newRequiredFieldsVisitor(walker, fieldMessage, r) + vis := newRequiredFieldsVisitor(walker, fieldMessage, r.mapping) if err := vis.visit(r.definition, typeName, requiredField.selectionSet, requiredFieldVisitorConfig{ referenceNestedMessages: true, }); err != nil { diff --git a/v2/pkg/engine/datasource/grpc_datasource/execution_plan_requires_test.go b/v2/pkg/engine/datasource/grpc_datasource/execution_plan_requires_test.go index 0d47f4afc0..8f7db5286c 100644 --- a/v2/pkg/engine/datasource/grpc_datasource/execution_plan_requires_test.go +++ b/v2/pkg/engine/datasource/grpc_datasource/execution_plan_requires_test.go @@ -1722,6 +1722,925 @@ func TestExecutionPlan_FederationRequires(t *testing.T) { } } +func TestExecutionPlan_FederationRequires_AbstractTypes(t *testing.T) { + t.Parallel() + + // storageEntityLookupCall returns the common entity lookup call shared by all tests + storageEntityLookupCall := func() RPCCall { + return RPCCall{ + ServiceName: "Products", + MethodName: "LookupStorageById", + Kind: CallKindEntity, + Request: RPCMessage{ + Name: "LookupStorageByIdRequest", + Fields: []RPCField{ + { + Name: "keys", + ProtoTypeName: DataTypeMessage, + Repeated: true, + JSONPath: "representations", + Message: &RPCMessage{ + Name: "LookupStorageByIdRequestKey", + MemberTypes: []string{"Storage"}, + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + }, + }, + }, + }, + }, + }, + Response: RPCMessage{ + Name: "LookupStorageByIdResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + Repeated: true, + JSONPath: "_entities", + Message: &RPCMessage{ + Name: "Storage", + Fields: []RPCField{ + { + Name: "__typename", + ProtoTypeName: DataTypeString, + JSONPath: "__typename", + StaticValue: "Storage", + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + }, + }, + }, + }, + }, + } + } + + storageKeyMessage := func() *RPCMessage { + return &RPCMessage{ + Name: "LookupStorageByIdRequestKey", + MemberTypes: []string{"Storage"}, + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + }, + }, + } + } + + tests := []struct { + name string + query string + expectedPlan *RPCExecutionPlan + mapping *GRPCMapping + federationConfigs plan.FederationFieldConfigurations + }{ + { + name: "requires with interface type in selection set", + query: `query EntityLookup($representations: [_Any!]!) { _entities(representations: $representations) { ... on Storage { __typename name itemInfo } } }`, + mapping: testMapping(), + federationConfigs: plan.FederationFieldConfigurations{ + { + TypeName: "Storage", + SelectionSet: "id", + }, + { + TypeName: "Storage", + FieldName: "itemInfo", + SelectionSet: `primaryItem { ... on PalletItem { name palletCount } ... on ContainerItem { name containerSize } }`, + }, + }, + expectedPlan: &RPCExecutionPlan{ + Calls: []RPCCall{ + storageEntityLookupCall(), + { + ID: 1, + ServiceName: "Products", + Kind: CallKindRequired, + MethodName: "RequireStorageItemInfoById", + ResponsePath: buildPath("_entities.itemInfo"), + Request: RPCMessage{ + Name: "RequireStorageItemInfoByIdRequest", + Fields: []RPCField{ + { + Name: "context", + ProtoTypeName: DataTypeMessage, + Repeated: true, + JSONPath: "representations", + Message: &RPCMessage{ + Name: "RequireStorageItemInfoByIdContext", + Fields: []RPCField{ + { + Name: "key", + ProtoTypeName: DataTypeMessage, + Message: storageKeyMessage(), + }, + { + Name: "fields", + ProtoTypeName: DataTypeMessage, + Message: &RPCMessage{ + Name: "RequireStorageItemInfoByIdFields", + Fields: []RPCField{ + { + Name: "primary_item", + ProtoTypeName: DataTypeMessage, + JSONPath: "primaryItem", + Message: &RPCMessage{ + Name: "RequireStorageItemInfoByIdFields.StorageItem", + OneOfType: OneOfTypeInterface, + MemberTypes: []string{"PalletItem", "ContainerItem"}, + FragmentFields: RPCFieldSelectionSet{ + "PalletItem": { + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + { + Name: "pallet_count", + ProtoTypeName: DataTypeInt32, + JSONPath: "palletCount", + }, + }, + "ContainerItem": { + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + { + Name: "container_size", + ProtoTypeName: DataTypeString, + JSONPath: "containerSize", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + Response: RPCMessage{ + Name: "RequireStorageItemInfoByIdResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + Repeated: true, + JSONPath: "result", + Message: &RPCMessage{ + Name: "RequireStorageItemInfoByIdResult", + Fields: RPCFields{ + { + Name: "item_info", + ProtoTypeName: DataTypeString, + JSONPath: "itemInfo", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + { + name: "requires with union type in selection set", + query: `query EntityLookup($representations: [_Any!]!) { _entities(representations: $representations) { ... on Storage { __typename name operationReport } } }`, + mapping: testMapping(), + federationConfigs: plan.FederationFieldConfigurations{ + { + TypeName: "Storage", + SelectionSet: "id", + }, + { + TypeName: "Storage", + FieldName: "operationReport", + SelectionSet: `lastStorageOperation { ... on StorageSuccess { message completedAt } ... on StorageFailure { message errorCode } }`, + }, + }, + expectedPlan: &RPCExecutionPlan{ + Calls: []RPCCall{ + storageEntityLookupCall(), + { + ID: 1, + ServiceName: "Products", + Kind: CallKindRequired, + MethodName: "RequireStorageOperationReportById", + ResponsePath: buildPath("_entities.operationReport"), + Request: RPCMessage{ + Name: "RequireStorageOperationReportByIdRequest", + Fields: []RPCField{ + { + Name: "context", + ProtoTypeName: DataTypeMessage, + Repeated: true, + JSONPath: "representations", + Message: &RPCMessage{ + Name: "RequireStorageOperationReportByIdContext", + Fields: []RPCField{ + { + Name: "key", + ProtoTypeName: DataTypeMessage, + Message: storageKeyMessage(), + }, + { + Name: "fields", + ProtoTypeName: DataTypeMessage, + Message: &RPCMessage{ + Name: "RequireStorageOperationReportByIdFields", + Fields: []RPCField{ + { + Name: "last_storage_operation", + ProtoTypeName: DataTypeMessage, + JSONPath: "lastStorageOperation", + Message: &RPCMessage{ + Name: "RequireStorageOperationReportByIdFields.StorageOperationResult", + OneOfType: OneOfTypeUnion, + MemberTypes: []string{"StorageSuccess", "StorageFailure"}, + FragmentFields: RPCFieldSelectionSet{ + "StorageSuccess": { + { + Name: "message", + ProtoTypeName: DataTypeString, + JSONPath: "message", + }, + { + Name: "completed_at", + ProtoTypeName: DataTypeString, + JSONPath: "completedAt", + }, + }, + "StorageFailure": { + { + Name: "message", + ProtoTypeName: DataTypeString, + JSONPath: "message", + }, + { + Name: "error_code", + ProtoTypeName: DataTypeString, + JSONPath: "errorCode", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + Response: RPCMessage{ + Name: "RequireStorageOperationReportByIdResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + Repeated: true, + JSONPath: "result", + Message: &RPCMessage{ + Name: "RequireStorageOperationReportByIdResult", + Fields: RPCFields{ + { + Name: "operation_report", + ProtoTypeName: DataTypeString, + JSONPath: "operationReport", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + { + name: "requires with concrete type wrapping abstract type", + query: `query EntityLookup($representations: [_Any!]!) { _entities(representations: $representations) { ... on Storage { __typename name securitySummary } } }`, + mapping: testMapping(), + federationConfigs: plan.FederationFieldConfigurations{ + { + TypeName: "Storage", + SelectionSet: "id", + }, + { + TypeName: "Storage", + FieldName: "securitySummary", + SelectionSet: `securitySetup { securityLevel primaryItem { ... on PalletItem { name palletCount } ... on ContainerItem { name containerSize } } }`, + }, + }, + expectedPlan: &RPCExecutionPlan{ + Calls: []RPCCall{ + storageEntityLookupCall(), + { + ID: 1, + ServiceName: "Products", + Kind: CallKindRequired, + MethodName: "RequireStorageSecuritySummaryById", + ResponsePath: buildPath("_entities.securitySummary"), + Request: RPCMessage{ + Name: "RequireStorageSecuritySummaryByIdRequest", + Fields: []RPCField{ + { + Name: "context", + ProtoTypeName: DataTypeMessage, + Repeated: true, + JSONPath: "representations", + Message: &RPCMessage{ + Name: "RequireStorageSecuritySummaryByIdContext", + Fields: []RPCField{ + { + Name: "key", + ProtoTypeName: DataTypeMessage, + Message: storageKeyMessage(), + }, + { + Name: "fields", + ProtoTypeName: DataTypeMessage, + Message: &RPCMessage{ + Name: "RequireStorageSecuritySummaryByIdFields", + Fields: []RPCField{ + { + Name: "security_setup", + ProtoTypeName: DataTypeMessage, + JSONPath: "securitySetup", + Message: &RPCMessage{ + Name: "RequireStorageSecuritySummaryByIdFields.SecuritySetup", + Fields: []RPCField{ + { + Name: "security_level", + ProtoTypeName: DataTypeString, + JSONPath: "securityLevel", + }, + { + Name: "primary_item", + ProtoTypeName: DataTypeMessage, + JSONPath: "primaryItem", + Message: &RPCMessage{ + Name: "RequireStorageSecuritySummaryByIdFields.SecuritySetup.StorageItem", + OneOfType: OneOfTypeInterface, + MemberTypes: []string{"PalletItem", "ContainerItem"}, + FragmentFields: RPCFieldSelectionSet{ + "PalletItem": { + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + { + Name: "pallet_count", + ProtoTypeName: DataTypeInt32, + JSONPath: "palletCount", + }, + }, + "ContainerItem": { + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + { + Name: "container_size", + ProtoTypeName: DataTypeString, + JSONPath: "containerSize", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + Response: RPCMessage{ + Name: "RequireStorageSecuritySummaryByIdResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + Repeated: true, + JSONPath: "result", + Message: &RPCMessage{ + Name: "RequireStorageSecuritySummaryByIdResult", + Fields: RPCFields{ + { + Name: "security_summary", + ProtoTypeName: DataTypeString, + JSONPath: "securitySummary", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + { + name: "requires with nested concrete message inside interface fragment", + query: `query EntityLookup($representations: [_Any!]!) { _entities(representations: $representations) { ... on Storage { __typename name itemHandlerInfo } } }`, + mapping: testMapping(), + federationConfigs: plan.FederationFieldConfigurations{ + { + TypeName: "Storage", + SelectionSet: "id", + }, + { + TypeName: "Storage", + FieldName: "itemHandlerInfo", + SelectionSet: `primaryItem { ... on PalletItem { handler { name } } ... on ContainerItem { handler { name } } }`, + }, + }, + expectedPlan: &RPCExecutionPlan{ + Calls: []RPCCall{ + storageEntityLookupCall(), + { + ID: 1, + ServiceName: "Products", + Kind: CallKindRequired, + MethodName: "RequireStorageItemHandlerInfoById", + ResponsePath: buildPath("_entities.itemHandlerInfo"), + Request: RPCMessage{ + Name: "RequireStorageItemHandlerInfoByIdRequest", + Fields: []RPCField{ + { + Name: "context", + ProtoTypeName: DataTypeMessage, + Repeated: true, + JSONPath: "representations", + Message: &RPCMessage{ + Name: "RequireStorageItemHandlerInfoByIdContext", + Fields: []RPCField{ + { + Name: "key", + ProtoTypeName: DataTypeMessage, + Message: storageKeyMessage(), + }, + { + Name: "fields", + ProtoTypeName: DataTypeMessage, + Message: &RPCMessage{ + Name: "RequireStorageItemHandlerInfoByIdFields", + Fields: []RPCField{ + { + Name: "primary_item", + ProtoTypeName: DataTypeMessage, + JSONPath: "primaryItem", + Message: &RPCMessage{ + Name: "RequireStorageItemHandlerInfoByIdFields.StorageItem", + OneOfType: OneOfTypeInterface, + MemberTypes: []string{"PalletItem", "ContainerItem"}, + FragmentFields: RPCFieldSelectionSet{ + "PalletItem": { + { + Name: "handler", + ProtoTypeName: DataTypeMessage, + JSONPath: "handler", + Message: &RPCMessage{ + Name: "RequireStorageItemHandlerInfoByIdFields.StorageItem.ItemHandler", + Fields: []RPCField{ + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + }, + }, + }, + }, + "ContainerItem": { + { + Name: "handler", + ProtoTypeName: DataTypeMessage, + JSONPath: "handler", + Message: &RPCMessage{ + Name: "RequireStorageItemHandlerInfoByIdFields.StorageItem.ItemHandler", + Fields: []RPCField{ + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + Response: RPCMessage{ + Name: "RequireStorageItemHandlerInfoByIdResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + Repeated: true, + JSONPath: "result", + Message: &RPCMessage{ + Name: "RequireStorageItemHandlerInfoByIdResult", + Fields: RPCFields{ + { + Name: "item_handler_info", + ProtoTypeName: DataTypeString, + JSONPath: "itemHandlerInfo", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + { + name: "requires with deep concrete nesting inside interface fragment", + query: `query EntityLookup($representations: [_Any!]!) { _entities(representations: $representations) { ... on Storage { __typename name itemSpecsInfo } } }`, + mapping: testMapping(), + federationConfigs: plan.FederationFieldConfigurations{ + { + TypeName: "Storage", + SelectionSet: "id", + }, + { + TypeName: "Storage", + FieldName: "itemSpecsInfo", + SelectionSet: `primaryItem { ... on PalletItem { specs { name dimensions { length width } } } ... on ContainerItem { specs { name dimensions { length width } } } }`, + }, + }, + expectedPlan: &RPCExecutionPlan{ + Calls: []RPCCall{ + storageEntityLookupCall(), + { + ID: 1, + ServiceName: "Products", + Kind: CallKindRequired, + MethodName: "RequireStorageItemSpecsInfoById", + ResponsePath: buildPath("_entities.itemSpecsInfo"), + Request: RPCMessage{ + Name: "RequireStorageItemSpecsInfoByIdRequest", + Fields: []RPCField{ + { + Name: "context", + ProtoTypeName: DataTypeMessage, + Repeated: true, + JSONPath: "representations", + Message: &RPCMessage{ + Name: "RequireStorageItemSpecsInfoByIdContext", + Fields: []RPCField{ + { + Name: "key", + ProtoTypeName: DataTypeMessage, + Message: storageKeyMessage(), + }, + { + Name: "fields", + ProtoTypeName: DataTypeMessage, + Message: &RPCMessage{ + Name: "RequireStorageItemSpecsInfoByIdFields", + Fields: []RPCField{ + { + Name: "primary_item", + ProtoTypeName: DataTypeMessage, + JSONPath: "primaryItem", + Message: &RPCMessage{ + Name: "RequireStorageItemSpecsInfoByIdFields.StorageItem", + OneOfType: OneOfTypeInterface, + MemberTypes: []string{"PalletItem", "ContainerItem"}, + FragmentFields: RPCFieldSelectionSet{ + "PalletItem": { + { + Name: "specs", + ProtoTypeName: DataTypeMessage, + JSONPath: "specs", + Message: &RPCMessage{ + Name: "RequireStorageItemSpecsInfoByIdFields.StorageItem.PalletSpecs", + Fields: []RPCField{ + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + { + Name: "dimensions", + ProtoTypeName: DataTypeMessage, + JSONPath: "dimensions", + Message: &RPCMessage{ + Name: "RequireStorageItemSpecsInfoByIdFields.StorageItem.PalletSpecs.Dimensions", + Fields: []RPCField{ + { + Name: "length", + ProtoTypeName: DataTypeDouble, + JSONPath: "length", + }, + { + Name: "width", + ProtoTypeName: DataTypeDouble, + JSONPath: "width", + }, + }, + }, + }, + }, + }, + }, + }, + "ContainerItem": { + { + Name: "specs", + ProtoTypeName: DataTypeMessage, + JSONPath: "specs", + Message: &RPCMessage{ + Name: "RequireStorageItemSpecsInfoByIdFields.StorageItem.ContainerSpecs", + Fields: []RPCField{ + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + { + Name: "dimensions", + ProtoTypeName: DataTypeMessage, + JSONPath: "dimensions", + Message: &RPCMessage{ + Name: "RequireStorageItemSpecsInfoByIdFields.StorageItem.ContainerSpecs.Dimensions", + Fields: []RPCField{ + { + Name: "length", + ProtoTypeName: DataTypeDouble, + JSONPath: "length", + }, + { + Name: "width", + ProtoTypeName: DataTypeDouble, + JSONPath: "width", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + Response: RPCMessage{ + Name: "RequireStorageItemSpecsInfoByIdResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + Repeated: true, + JSONPath: "result", + Message: &RPCMessage{ + Name: "RequireStorageItemSpecsInfoByIdResult", + Fields: RPCFields{ + { + Name: "item_specs_info", + ProtoTypeName: DataTypeString, + JSONPath: "itemSpecsInfo", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + { + name: "requires with nested abstract type through concrete intermediary", + query: `query EntityLookup($representations: [_Any!]!) { _entities(representations: $representations) { ... on Storage { __typename name deepItemInfo } } }`, + mapping: testMapping(), + federationConfigs: plan.FederationFieldConfigurations{ + { + TypeName: "Storage", + SelectionSet: "id", + }, + { + TypeName: "Storage", + FieldName: "deepItemInfo", + SelectionSet: `primaryItem { ... on PalletItem { handler { assignedItem { ... on ContainerItem { name containerSize } ... on PalletItem { name palletCount } } } } ... on ContainerItem { handler { name } } }`, + }, + }, + expectedPlan: &RPCExecutionPlan{ + Calls: []RPCCall{ + storageEntityLookupCall(), + { + ID: 1, + ServiceName: "Products", + Kind: CallKindRequired, + MethodName: "RequireStorageDeepItemInfoById", + ResponsePath: buildPath("_entities.deepItemInfo"), + Request: RPCMessage{ + Name: "RequireStorageDeepItemInfoByIdRequest", + Fields: []RPCField{ + { + Name: "context", + ProtoTypeName: DataTypeMessage, + Repeated: true, + JSONPath: "representations", + Message: &RPCMessage{ + Name: "RequireStorageDeepItemInfoByIdContext", + Fields: []RPCField{ + { + Name: "key", + ProtoTypeName: DataTypeMessage, + Message: storageKeyMessage(), + }, + { + Name: "fields", + ProtoTypeName: DataTypeMessage, + Message: &RPCMessage{ + Name: "RequireStorageDeepItemInfoByIdFields", + Fields: []RPCField{ + { + Name: "primary_item", + ProtoTypeName: DataTypeMessage, + JSONPath: "primaryItem", + Message: &RPCMessage{ + Name: "RequireStorageDeepItemInfoByIdFields.StorageItem", + OneOfType: OneOfTypeInterface, + MemberTypes: []string{"PalletItem", "ContainerItem"}, + FragmentFields: RPCFieldSelectionSet{ + "PalletItem": { + { + Name: "handler", + ProtoTypeName: DataTypeMessage, + JSONPath: "handler", + Message: &RPCMessage{ + Name: "RequireStorageDeepItemInfoByIdFields.StorageItem.ItemHandler", + Fields: []RPCField{ + { + Name: "assigned_item", + ProtoTypeName: DataTypeMessage, + JSONPath: "assignedItem", + Message: &RPCMessage{ + Name: "RequireStorageDeepItemInfoByIdFields.StorageItem.ItemHandler.StorageItem", + OneOfType: OneOfTypeInterface, + MemberTypes: []string{"PalletItem", "ContainerItem"}, + FragmentFields: RPCFieldSelectionSet{ + "ContainerItem": { + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + { + Name: "container_size", + ProtoTypeName: DataTypeString, + JSONPath: "containerSize", + }, + }, + "PalletItem": { + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + { + Name: "pallet_count", + ProtoTypeName: DataTypeInt32, + JSONPath: "palletCount", + }, + }, + }, + }, + }, + }, + }, + }, + }, + "ContainerItem": { + { + Name: "handler", + ProtoTypeName: DataTypeMessage, + JSONPath: "handler", + Message: &RPCMessage{ + Name: "RequireStorageDeepItemInfoByIdFields.StorageItem.ItemHandler", + Fields: []RPCField{ + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + Response: RPCMessage{ + Name: "RequireStorageDeepItemInfoByIdResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + Repeated: true, + JSONPath: "result", + Message: &RPCMessage{ + Name: "RequireStorageDeepItemInfoByIdResult", + Fields: RPCFields{ + { + Name: "deep_item_info", + ProtoTypeName: DataTypeString, + JSONPath: "deepItemInfo", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + t.Parallel() + // Parse the GraphQL schema + schemaDoc := grpctest.MustGraphQLSchema(t) + + // Parse the GraphQL query + queryDoc, report := astparser.ParseGraphqlDocumentString(tt.query) + if report.HasErrors() { + t.Fatalf("failed to parse query: %s", report.Error()) + } + + planner, err := NewPlanner("Products", tt.mapping, tt.federationConfigs) + if err != nil { + t.Fatalf("failed to create planner: %s", err) + } + plan, err := planner.PlanOperation(&queryDoc, &schemaDoc) + if err != nil { + t.Fatalf("failed to plan operation: %s", err) + } + + diff := cmp.Diff(tt.expectedPlan, plan) + if diff != "" { + t.Fatalf("execution plan mismatch: %s", diff) + } + }) + } +} + func TestExecutionPlan_FederationRequires_WithFieldResolvers(t *testing.T) { t.Parallel() diff --git a/v2/pkg/engine/datasource/grpc_datasource/execution_plan_visitor_federation.go b/v2/pkg/engine/datasource/grpc_datasource/execution_plan_visitor_federation.go index bb00d9e9cc..54af09dcb0 100644 --- a/v2/pkg/engine/datasource/grpc_datasource/execution_plan_visitor_federation.go +++ b/v2/pkg/engine/datasource/grpc_datasource/execution_plan_visitor_federation.go @@ -526,7 +526,7 @@ func (r *rpcPlanVisitorFederation) scaffoldEntityLookup(typeName string, ecd ent walker := astvisitor.WalkerFromPool() defer walker.Release() - requiredFieldsVisitor := newRequiredFieldsVisitor(walker, keyFieldMessage, r.planCtx) + requiredFieldsVisitor := newRequiredFieldsVisitor(walker, keyFieldMessage, r.planCtx.mapping) err := requiredFieldsVisitor.visitWithDefaults(r.definition, typeName, ecd.keyFields) if err != nil { r.walker.StopWithInternalErr(err) diff --git a/v2/pkg/engine/datasource/grpc_datasource/grpc_datasource_federation_test.go b/v2/pkg/engine/datasource/grpc_datasource/grpc_datasource_federation_test.go index bdffde44c3..821cc6b64e 100644 --- a/v2/pkg/engine/datasource/grpc_datasource/grpc_datasource_federation_test.go +++ b/v2/pkg/engine/datasource/grpc_datasource/grpc_datasource_federation_test.go @@ -1708,3 +1708,147 @@ func Test_DataSource_Load_WithEntity_Calls_And_Requires_And_FieldResolvers(t *te }) } } + +func Test_DataSource_Load_WithEntity_Calls_And_Requires_AbstractTypes(t *testing.T) { + conn, cleanup := setupTestGRPCServer(t) + t.Cleanup(cleanup) + + type graphqlError struct { + Message string `json:"message"` + } + type graphqlResponse struct { + Data map[string]interface{} `json:"data"` + Errors []graphqlError `json:"errors,omitempty"` + } + + testCases := []struct { + name string + query string + vars string + federationConfigs plan.FederationFieldConfigurations + validate func(t *testing.T, data map[string]interface{}) + validateError func(t *testing.T, errData []graphqlError) + }{ + { + name: "Query Storage with itemInfo requiring interface type", + query: `query($representations: [_Any!]!) { _entities(representations: $representations) { ...on Storage { id name itemInfo } } }`, + vars: `{"variables":{"representations":[ + {"__typename":"Storage","id":"1","primaryItem":{"__typename":"PalletItem","name":"Heavy Pallet","palletCount":10}}, + {"__typename":"Storage","id":"2","primaryItem":{"__typename":"ContainerItem","name":"Steel Container","containerSize":"40ft"}} + ]}}`, + federationConfigs: plan.FederationFieldConfigurations{ + { + TypeName: "Storage", + SelectionSet: "id", + }, + { + TypeName: "Storage", + FieldName: "itemInfo", + SelectionSet: `primaryItem { ... on PalletItem { name palletCount } ... on ContainerItem { name containerSize } }`, + }, + }, + validate: func(t *testing.T, data map[string]interface{}) { + entities, ok := data["_entities"].([]interface{}) + require.True(t, ok, "_entities should be an array") + require.Len(t, entities, 2) + + storage1, ok := entities[0].(map[string]interface{}) + require.True(t, ok, "storage1 should be an object") + require.Equal(t, "1", storage1["id"]) + require.Equal(t, "Storage 1", storage1["name"]) + require.Equal(t, "Pallet: Heavy Pallet (count: 10)", storage1["itemInfo"]) + + storage2, ok := entities[1].(map[string]interface{}) + require.True(t, ok, "storage2 should be an object") + require.Equal(t, "2", storage2["id"]) + require.Equal(t, "Storage 2", storage2["name"]) + require.Equal(t, "Container: Steel Container (size: 40ft)", storage2["itemInfo"]) + }, + validateError: func(t *testing.T, errorData []graphqlError) { + require.Empty(t, errorData) + }, + }, + { + name: "Query Storage with operationReport requiring union type", + query: `query($representations: [_Any!]!) { _entities(representations: $representations) { ...on Storage { id name operationReport } } }`, + vars: `{"variables":{"representations":[ + {"__typename":"Storage","id":"1","lastStorageOperation":{"__typename":"StorageSuccess","message":"Item stored","completedAt":"2024-01-15T10:30:00Z"}}, + {"__typename":"Storage","id":"2","lastStorageOperation":{"__typename":"StorageFailure","message":"Storage full","errorCode":"ERR_FULL"}} + ]}}`, + federationConfigs: plan.FederationFieldConfigurations{ + { + TypeName: "Storage", + SelectionSet: "id", + }, + { + TypeName: "Storage", + FieldName: "operationReport", + SelectionSet: `lastStorageOperation { ... on StorageSuccess { message completedAt } ... on StorageFailure { message errorCode } }`, + }, + }, + validate: func(t *testing.T, data map[string]interface{}) { + entities, ok := data["_entities"].([]interface{}) + require.True(t, ok, "_entities should be an array") + require.Len(t, entities, 2) + + storage1, ok := entities[0].(map[string]interface{}) + require.True(t, ok, "storage1 should be an object") + require.Equal(t, "1", storage1["id"]) + require.Equal(t, "Storage 1", storage1["name"]) + require.Equal(t, "Success: Item stored at 2024-01-15T10:30:00Z", storage1["operationReport"]) + + storage2, ok := entities[1].(map[string]interface{}) + require.True(t, ok, "storage2 should be an object") + require.Equal(t, "2", storage2["id"]) + require.Equal(t, "Storage 2", storage2["name"]) + require.Equal(t, "Failure: Storage full (code: ERR_FULL)", storage2["operationReport"]) + }, + validateError: func(t *testing.T, errorData []graphqlError) { + require.Empty(t, errorData) + }, + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + // Parse the GraphQL schema + schemaDoc := grpctest.MustGraphQLSchema(t) + + // Parse the GraphQL query + queryDoc, report := astparser.ParseGraphqlDocumentString(tc.query) + if report.HasErrors() { + t.Fatalf("failed to parse query: %s", report.Error()) + } + + compiler, err := NewProtoCompiler(grpctest.MustProtoSchema(t), testMapping()) + if err != nil { + t.Fatalf("failed to compile proto: %v", err) + } + + // Create the datasource + ds, err := NewDataSource(conn, DataSourceConfig{ + Operation: &queryDoc, + Definition: &schemaDoc, + SubgraphName: "Products", + Mapping: testMapping(), + Compiler: compiler, + FederationConfigs: tc.federationConfigs, + }) + require.NoError(t, err) + + // Execute the query through our datasource + input := fmt.Sprintf(`{"query":%q,"body":%s}`, tc.query, tc.vars) + data, err := ds.Load(context.Background(), nil, []byte(input)) + require.NoError(t, err) + + // Parse the response + var resp graphqlResponse + + err = json.Unmarshal(data, &resp) + require.NoError(t, err, "Failed to unmarshal response") + + tc.validate(t, resp.Data) + tc.validateError(t, resp.Errors) + }) + } +} diff --git a/v2/pkg/engine/datasource/grpc_datasource/mapping_test_helper.go b/v2/pkg/engine/datasource/grpc_datasource/mapping_test_helper.go index 193300b409..7eb5288c35 100644 --- a/v2/pkg/engine/datasource/grpc_datasource/mapping_test_helper.go +++ b/v2/pkg/engine/datasource/grpc_datasource/mapping_test_helper.go @@ -621,6 +621,54 @@ func testMapping() *GRPCMapping { Response: "RequireStorageCategoryInfoSummaryByIdResponse", }, }, + "itemInfo": { + TargetName: "item_info", + RPCConfig: RPCConfig{ + RPC: "RequireStorageItemInfoById", + Request: "RequireStorageItemInfoByIdRequest", + Response: "RequireStorageItemInfoByIdResponse", + }, + }, + "operationReport": { + TargetName: "operation_report", + RPCConfig: RPCConfig{ + RPC: "RequireStorageOperationReportById", + Request: "RequireStorageOperationReportByIdRequest", + Response: "RequireStorageOperationReportByIdResponse", + }, + }, + "securitySummary": { + TargetName: "security_summary", + RPCConfig: RPCConfig{ + RPC: "RequireStorageSecuritySummaryById", + Request: "RequireStorageSecuritySummaryByIdRequest", + Response: "RequireStorageSecuritySummaryByIdResponse", + }, + }, + "itemHandlerInfo": { + TargetName: "item_handler_info", + RPCConfig: RPCConfig{ + RPC: "RequireStorageItemHandlerInfoById", + Request: "RequireStorageItemHandlerInfoByIdRequest", + Response: "RequireStorageItemHandlerInfoByIdResponse", + }, + }, + "itemSpecsInfo": { + TargetName: "item_specs_info", + RPCConfig: RPCConfig{ + RPC: "RequireStorageItemSpecsInfoById", + Request: "RequireStorageItemSpecsInfoByIdRequest", + Response: "RequireStorageItemSpecsInfoByIdResponse", + }, + }, + "deepItemInfo": { + TargetName: "deep_item_info", + RPCConfig: RPCConfig{ + RPC: "RequireStorageDeepItemInfoById", + Request: "RequireStorageDeepItemInfoByIdRequest", + Response: "RequireStorageDeepItemInfoByIdResponse", + }, + }, }, }, }, @@ -1017,6 +1065,33 @@ func testMapping() *GRPCMapping { "categoryInfoSummary": { TargetName: "category_info_summary", }, + "primaryItem": { + TargetName: "primary_item", + }, + "lastStorageOperation": { + TargetName: "last_storage_operation", + }, + "securitySetup": { + TargetName: "security_setup", + }, + "itemInfo": { + TargetName: "item_info", + }, + "operationReport": { + TargetName: "operation_report", + }, + "securitySummary": { + TargetName: "security_summary", + }, + "itemHandlerInfo": { + TargetName: "item_handler_info", + }, + "itemSpecsInfo": { + TargetName: "item_specs_info", + }, + "deepItemInfo": { + TargetName: "deep_item_info", + }, "storageStatus": { TargetName: "storage_status", ArgumentMappings: FieldArgumentMap{ @@ -1488,6 +1563,114 @@ func testMapping() *GRPCMapping { TargetName: "lifespan", }, }, + "PalletItem": { + "id": { + TargetName: "id", + }, + "name": { + TargetName: "name", + }, + "weight": { + TargetName: "weight", + }, + "palletCount": { + TargetName: "pallet_count", + }, + "handler": { + TargetName: "handler", + }, + "specs": { + TargetName: "specs", + }, + }, + "ContainerItem": { + "id": { + TargetName: "id", + }, + "name": { + TargetName: "name", + }, + "weight": { + TargetName: "weight", + }, + "containerSize": { + TargetName: "container_size", + }, + "handler": { + TargetName: "handler", + }, + "specs": { + TargetName: "specs", + }, + }, + "ItemHandler": { + "id": { + TargetName: "id", + }, + "name": { + TargetName: "name", + }, + "assignedItem": { + TargetName: "assigned_item", + }, + }, + "PalletSpecs": { + "name": { + TargetName: "name", + }, + "maxWeight": { + TargetName: "max_weight", + }, + "dimensions": { + TargetName: "dimensions", + }, + }, + "ContainerSpecs": { + "name": { + TargetName: "name", + }, + "volume": { + TargetName: "volume", + }, + "dimensions": { + TargetName: "dimensions", + }, + }, + "Dimensions": { + "length": { + TargetName: "length", + }, + "width": { + TargetName: "width", + }, + "height": { + TargetName: "height", + }, + }, + "StorageSuccess": { + "message": { + TargetName: "message", + }, + "completedAt": { + TargetName: "completed_at", + }, + }, + "StorageFailure": { + "message": { + TargetName: "message", + }, + "errorCode": { + TargetName: "error_code", + }, + }, + "SecuritySetup": { + "securityLevel": { + TargetName: "security_level", + }, + "primaryItem": { + TargetName: "primary_item", + }, + }, "ActionSuccess": { "message": { TargetName: "message", diff --git a/v2/pkg/engine/datasource/grpc_datasource/required_fields_visitor.go b/v2/pkg/engine/datasource/grpc_datasource/required_fields_visitor.go index cd1a86ae6e..379fce08c2 100644 --- a/v2/pkg/engine/datasource/grpc_datasource/required_fields_visitor.go +++ b/v2/pkg/engine/datasource/grpc_datasource/required_fields_visitor.go @@ -29,6 +29,7 @@ type requiredFieldsVisitor struct { message *RPCMessage fieldDefinitionRefs []int + mapping *GRPCMapping planCtx *rpcPlanningContext messageAncestors []*RPCMessage @@ -39,11 +40,11 @@ type requiredFieldsVisitor struct { // newRequiredFieldsVisitor creates a new requiredFieldsVisitor. // It registers the visitor with the walker and returns it. -func newRequiredFieldsVisitor(walker *astvisitor.Walker, message *RPCMessage, planCtx *rpcPlanningContext) *requiredFieldsVisitor { +func newRequiredFieldsVisitor(walker *astvisitor.Walker, message *RPCMessage, mapping *GRPCMapping) *requiredFieldsVisitor { visitor := &requiredFieldsVisitor{ walker: walker, message: message, - planCtx: planCtx, + mapping: mapping, messageAncestors: []*RPCMessage{}, fieldDefinitionRefs: []int{}, } @@ -98,21 +99,20 @@ func (r *requiredFieldsVisitor) EnterDocument(operation *ast.Document, definitio r.operation = operation r.definition = definition + + // Create a planCtx scoped to this walk's operation document so that methods + // like lastResponseField and newMessageFromSelectionSet use the correct + // document refs (the visitor walks a fragment doc that may differ from the + // outer planner's operation). + r.planCtx = newRPCPlanningContext(operation, definition, r.mapping) } -// EnterSelectionSet implements astvisitor.SelectionSetVisitor. -func (r *requiredFieldsVisitor) EnterSelectionSet(ref int) { - // Ignore the root selection set - if r.walker.Ancestor().Kind == ast.NodeKindFragmentDefinition { - return +func (r *requiredFieldsVisitor) enterNestedField(ref int, inlineFragmentRef int) bool { + lastField := r.planCtx.lastResponseField(r.message, inlineFragmentRef) + if lastField == nil { + return false } - if len(r.message.Fields) == 0 { - r.walker.StopWithInternalErr(errors.New("cannot access last field: message has no fields")) - return - } - - lastField := &r.message.Fields[len(r.message.Fields)-1] if lastField.Message == nil { lastField.Message = r.planCtx.newMessageFromSelectionSet(r.walker.EnclosingTypeDefinition, ref) } @@ -121,8 +121,25 @@ func (r *requiredFieldsVisitor) EnterSelectionSet(ref int) { if r.referenceNestedMessages { lastField.Message.Name = r.formatNestedMessageName(lastField.Message.Name) } - r.message = lastField.Message + return true +} + +// EnterSelectionSet implements astvisitor.SelectionSetVisitor. +func (r *requiredFieldsVisitor) EnterSelectionSet(ref int) { + // If we don't select on a field, we can return. + if r.walker.Ancestor().Kind != ast.NodeKindField { + return + } + + // Determine which inline fragment directly contains the field we are about + // to descend into. When entering a field's selection set, the walker Ancestors + // are: [..., (maybe inline fragment), parent selection set, field]. + // Ancestors[-3] is therefore the inline fragment directly wrapping the field, if any. + inlineFragmentRef := inlineFragmentRefFromAncestors(r.walker.Ancestors) + if !r.enterNestedField(ref, inlineFragmentRef) { + return + } if err := r.handleCompositeType(r.walker.EnclosingTypeDefinition); err != nil { r.walker.StopWithInternalErr(err) @@ -132,7 +149,7 @@ func (r *requiredFieldsVisitor) EnterSelectionSet(ref int) { // LeaveSelectionSet implements astvisitor.SelectionSetVisitor. func (r *requiredFieldsVisitor) LeaveSelectionSet(ref int) { - if r.walker.Ancestor().Kind == ast.NodeKindFragmentDefinition { + if r.walker.Ancestor().Kind != ast.NodeKindField { return } @@ -169,6 +186,17 @@ func (r *requiredFieldsVisitor) EnterField(ref int) { } r.fieldDefinitionRefs = append(r.fieldDefinitionRefs, fd) + // check if we are inside an inline fragment + if ref := r.walker.ResolveInlineFragment(); ref != ast.InvalidRef { + if r.message.FragmentFields == nil { + r.message.FragmentFields = make(RPCFieldSelectionSet) + } + + inlineFragmentName := r.operation.InlineFragmentTypeConditionNameString(ref) + r.message.FragmentFields.Add(inlineFragmentName, field) + return + } + r.message.Fields = append(r.message.Fields, field) } @@ -204,6 +232,7 @@ func (r *requiredFieldsVisitor) handleCompositeType(node ast.Node) error { r.message.OneOfType = oneOfType r.message.MemberTypes = memberTypes + r.message.Fields = nil return nil } diff --git a/v2/pkg/engine/datasource/grpc_datasource/required_fields_visitor_test.go b/v2/pkg/engine/datasource/grpc_datasource/required_fields_visitor_test.go new file mode 100644 index 0000000000..7f92739dc2 --- /dev/null +++ b/v2/pkg/engine/datasource/grpc_datasource/required_fields_visitor_test.go @@ -0,0 +1,597 @@ +package grpcdatasource + +import ( + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + + "github.com/wundergraph/graphql-go-tools/v2/pkg/astvalidation" + "github.com/wundergraph/graphql-go-tools/v2/pkg/astvisitor" + "github.com/wundergraph/graphql-go-tools/v2/pkg/internal/unsafeparser" + "github.com/wundergraph/graphql-go-tools/v2/pkg/operationreport" +) + +func runRequiredFieldsVisitor(t *testing.T, schema string, mapping *GRPCMapping, typeName, requiredFields string) *RPCMessage { + t.Helper() + definition := unsafeparser.ParseGraphqlDocumentStringWithBaseSchema(schema) + report := operationreport.Report{} + astvalidation.DefaultDefinitionValidator().Validate(&definition, &report) + require.False(t, report.HasErrors(), report.Error()) + + message := &RPCMessage{Name: "TestMessage"} + walker := astvisitor.NewWalker(0) + visitor := newRequiredFieldsVisitor(&walker, message, mapping) + err := visitor.visitWithDefaults(&definition, typeName, requiredFields) + require.NoError(t, err) + return message +} + +func runRequiredFieldsVisitorWithConfig(t *testing.T, schema string, mapping *GRPCMapping, typeName, requiredFields string, config requiredFieldVisitorConfig) *RPCMessage { + t.Helper() + definition := unsafeparser.ParseGraphqlDocumentStringWithBaseSchema(schema) + report := operationreport.Report{} + astvalidation.DefaultDefinitionValidator().Validate(&definition, &report) + require.False(t, report.HasErrors(), report.Error()) + + message := &RPCMessage{Name: "TestMessage"} + walker := astvisitor.NewWalker(0) + visitor := newRequiredFieldsVisitor(&walker, message, mapping) + err := visitor.visit(&definition, typeName, requiredFields, config) + require.NoError(t, err) + return message +} + +func TestRequiredFieldsVisitor_ScalarFields(t *testing.T) { + t.Parallel() + + schema := ` + type Storage { id: ID! name: String! itemCount: Int! price: Float! active: Boolean! } + ` + mapping := &GRPCMapping{ + Fields: map[string]FieldMap{ + "Storage": { + "itemCount": {TargetName: "item_count"}, + }, + }, + } + + message := runRequiredFieldsVisitor(t, schema, mapping, "Storage", "itemCount") + + require.Len(t, message.Fields, 1) + field := message.Fields[0] + assert.Equal(t, "item_count", field.Name) + assert.Equal(t, DataTypeInt32, field.ProtoTypeName) + assert.Equal(t, "itemCount", field.JSONPath) +} + +func TestRequiredFieldsVisitor_MultipleScalarFields(t *testing.T) { + t.Parallel() + + schema := ` + type Storage { id: ID! name: String! itemCount: Int! price: Float! active: Boolean! } + ` + mapping := &GRPCMapping{ + Fields: map[string]FieldMap{ + "Storage": { + "itemCount": {TargetName: "item_count"}, + }, + }, + } + + message := runRequiredFieldsVisitor(t, schema, mapping, "Storage", "itemCount name") + + require.Len(t, message.Fields, 2) + + assert.Equal(t, "item_count", message.Fields[0].Name) + assert.Equal(t, DataTypeInt32, message.Fields[0].ProtoTypeName) + assert.Equal(t, "itemCount", message.Fields[0].JSONPath) + + assert.Equal(t, "name", message.Fields[1].Name) + assert.Equal(t, DataTypeString, message.Fields[1].ProtoTypeName) + assert.Equal(t, "name", message.Fields[1].JSONPath) +} + +func TestRequiredFieldsVisitor_NestedObject(t *testing.T) { + t.Parallel() + + schema := ` + type Storage { id: ID! metadata: Metadata! } + type Metadata { capacity: Int! zone: String! } + ` + mapping := &GRPCMapping{ + Fields: map[string]FieldMap{ + "Storage": {"metadata": {TargetName: "metadata"}}, + "Metadata": {"capacity": {TargetName: "capacity"}, "zone": {TargetName: "zone"}}, + }, + } + + message := runRequiredFieldsVisitor(t, schema, mapping, "Storage", "metadata { capacity zone }") + + require.Len(t, message.Fields, 1) + metadataField := message.Fields[0] + assert.Equal(t, "metadata", metadataField.Name) + assert.Equal(t, DataTypeMessage, metadataField.ProtoTypeName) + require.NotNil(t, metadataField.Message) + assert.Equal(t, "Metadata", metadataField.Message.Name) + + require.Len(t, metadataField.Message.Fields, 2) + assert.Equal(t, "capacity", metadataField.Message.Fields[0].Name) + assert.Equal(t, DataTypeInt32, metadataField.Message.Fields[0].ProtoTypeName) + assert.Equal(t, "zone", metadataField.Message.Fields[1].Name) + assert.Equal(t, DataTypeString, metadataField.Message.Fields[1].ProtoTypeName) +} + +func TestRequiredFieldsVisitor_DeeplyNestedObject(t *testing.T) { + t.Parallel() + + schema := ` + type Storage { id: ID! metadata: Metadata! } + type Metadata { inner: InnerData! } + type InnerData { value: String! } + ` + mapping := &GRPCMapping{ + Fields: map[string]FieldMap{ + "Storage": {"metadata": {TargetName: "metadata"}}, + "Metadata": {"inner": {TargetName: "inner"}}, + "InnerData": {"value": {TargetName: "value"}}, + }, + } + + message := runRequiredFieldsVisitor(t, schema, mapping, "Storage", "metadata { inner { value } }") + + require.Len(t, message.Fields, 1) + metadataField := message.Fields[0] + require.NotNil(t, metadataField.Message) + assert.Equal(t, "Metadata", metadataField.Message.Name) + + require.Len(t, metadataField.Message.Fields, 1) + innerField := metadataField.Message.Fields[0] + assert.Equal(t, "inner", innerField.Name) + assert.Equal(t, DataTypeMessage, innerField.ProtoTypeName) + require.NotNil(t, innerField.Message) + assert.Equal(t, "InnerData", innerField.Message.Name) + + require.Len(t, innerField.Message.Fields, 1) + assert.Equal(t, "value", innerField.Message.Fields[0].Name) + assert.Equal(t, DataTypeString, innerField.Message.Fields[0].ProtoTypeName) +} + +func TestRequiredFieldsVisitor_EnumField(t *testing.T) { + t.Parallel() + + schema := ` + type Storage { id: ID! kind: StorageKind! } + enum StorageKind { COLD HOT } + ` + mapping := &GRPCMapping{} + + message := runRequiredFieldsVisitor(t, schema, mapping, "Storage", "kind") + + require.Len(t, message.Fields, 1) + field := message.Fields[0] + assert.Equal(t, "kind", field.Name) + assert.Equal(t, DataTypeEnum, field.ProtoTypeName) + assert.Equal(t, "StorageKind", field.EnumName) +} + +func TestRequiredFieldsVisitor_NestedObjectWithEnum(t *testing.T) { + t.Parallel() + + schema := ` + type Storage { id: ID! info: Info! } + type Info { kind: StorageKind! name: String! } + enum StorageKind { COLD HOT } + ` + mapping := &GRPCMapping{ + Fields: map[string]FieldMap{ + "Storage": {"info": {TargetName: "info"}}, + "Info": {"kind": {TargetName: "kind"}, "name": {TargetName: "name"}}, + }, + } + + message := runRequiredFieldsVisitor(t, schema, mapping, "Storage", "info { kind name }") + + require.Len(t, message.Fields, 1) + infoField := message.Fields[0] + require.NotNil(t, infoField.Message) + + require.Len(t, infoField.Message.Fields, 2) + + kindField := infoField.Message.Fields[0] + assert.Equal(t, "kind", kindField.Name) + assert.Equal(t, DataTypeEnum, kindField.ProtoTypeName) + assert.Equal(t, "StorageKind", kindField.EnumName) + + nameField := infoField.Message.Fields[1] + assert.Equal(t, "name", nameField.Name) + assert.Equal(t, DataTypeString, nameField.ProtoTypeName) +} + +func TestRequiredFieldsVisitor_ListField(t *testing.T) { + t.Parallel() + + schema := ` + type Storage { id: ID! tags: [String!]! } + ` + mapping := &GRPCMapping{} + + message := runRequiredFieldsVisitor(t, schema, mapping, "Storage", "tags") + + require.Len(t, message.Fields, 1) + field := message.Fields[0] + assert.Equal(t, "tags", field.Name) + assert.True(t, field.Repeated) + assert.Equal(t, DataTypeString, field.ProtoTypeName) +} + +func TestRequiredFieldsVisitor_InterfaceField(t *testing.T) { + t.Parallel() + + schema := ` + type Storage { id: ID! pet: Animal! } + interface Animal { name: String! } + type Cat implements Animal { name: String! meowVolume: Int! } + type Dog implements Animal { name: String! barkVolume: Int! } + ` + mapping := &GRPCMapping{ + Fields: map[string]FieldMap{ + "Storage": {"pet": {TargetName: "pet"}}, + "Cat": {"name": {TargetName: "name"}, "meowVolume": {TargetName: "meow_volume"}}, + "Dog": {"name": {TargetName: "name"}, "barkVolume": {TargetName: "bark_volume"}}, + }, + } + + message := runRequiredFieldsVisitor(t, schema, mapping, "Storage", `pet { ... on Cat { name meowVolume } ... on Dog { name barkVolume } }`) + + require.Len(t, message.Fields, 1) + petField := message.Fields[0] + assert.Equal(t, "pet", petField.Name) + assert.Equal(t, DataTypeMessage, petField.ProtoTypeName) + require.NotNil(t, petField.Message) + + assert.Equal(t, OneOfTypeInterface, petField.Message.OneOfType) + assert.ElementsMatch(t, []string{"Cat", "Dog"}, petField.Message.MemberTypes) + + require.NotNil(t, petField.Message.FragmentFields) + catFields := petField.Message.FragmentFields["Cat"] + require.Len(t, catFields, 2) + assert.Equal(t, "name", catFields[0].Name) + assert.Equal(t, DataTypeString, catFields[0].ProtoTypeName) + assert.Equal(t, "meow_volume", catFields[1].Name) + assert.Equal(t, DataTypeInt32, catFields[1].ProtoTypeName) + + dogFields := petField.Message.FragmentFields["Dog"] + require.Len(t, dogFields, 2) + assert.Equal(t, "name", dogFields[0].Name) + assert.Equal(t, DataTypeString, dogFields[0].ProtoTypeName) + assert.Equal(t, "bark_volume", dogFields[1].Name) + assert.Equal(t, DataTypeInt32, dogFields[1].ProtoTypeName) +} + +func TestRequiredFieldsVisitor_UnionField(t *testing.T) { + t.Parallel() + + schema := ` + type Storage { id: ID! result: ActionResult! } + union ActionResult = ActionSuccess | ActionError + type ActionSuccess { message: String! timestamp: String! } + type ActionError { message: String! code: String! } + ` + mapping := &GRPCMapping{ + Fields: map[string]FieldMap{ + "Storage": {"result": {TargetName: "result"}}, + "ActionSuccess": {"message": {TargetName: "message"}, "timestamp": {TargetName: "timestamp"}}, + "ActionError": {"message": {TargetName: "message"}, "code": {TargetName: "code"}}, + }, + } + + message := runRequiredFieldsVisitor(t, schema, mapping, "Storage", `result { ... on ActionSuccess { message timestamp } ... on ActionError { message code } }`) + + require.Len(t, message.Fields, 1) + resultField := message.Fields[0] + assert.Equal(t, "result", resultField.Name) + assert.Equal(t, DataTypeMessage, resultField.ProtoTypeName) + require.NotNil(t, resultField.Message) + + assert.Equal(t, OneOfTypeUnion, resultField.Message.OneOfType) + assert.ElementsMatch(t, []string{"ActionSuccess", "ActionError"}, resultField.Message.MemberTypes) + + require.NotNil(t, resultField.Message.FragmentFields) + successFields := resultField.Message.FragmentFields["ActionSuccess"] + require.Len(t, successFields, 2) + assert.Equal(t, "message", successFields[0].Name) + assert.Equal(t, DataTypeString, successFields[0].ProtoTypeName) + assert.Equal(t, "timestamp", successFields[1].Name) + assert.Equal(t, DataTypeString, successFields[1].ProtoTypeName) + + errorFields := resultField.Message.FragmentFields["ActionError"] + require.Len(t, errorFields, 2) + assert.Equal(t, "message", errorFields[0].Name) + assert.Equal(t, DataTypeString, errorFields[0].ProtoTypeName) + assert.Equal(t, "code", errorFields[1].Name) + assert.Equal(t, DataTypeString, errorFields[1].ProtoTypeName) +} + +func TestRequiredFieldsVisitor_ReferenceNestedMessages(t *testing.T) { + t.Parallel() + + schema := ` + type Storage { id: ID! metadata: Metadata! } + type Metadata { capacity: Int! zone: String! } + ` + mapping := &GRPCMapping{ + Fields: map[string]FieldMap{ + "Storage": {"metadata": {TargetName: "metadata"}}, + "Metadata": {"capacity": {TargetName: "capacity"}, "zone": {TargetName: "zone"}}, + }, + } + + message := runRequiredFieldsVisitorWithConfig(t, schema, mapping, "Storage", "metadata { capacity zone }", requiredFieldVisitorConfig{ + includeMemberType: false, + skipFieldResolvers: false, + referenceNestedMessages: true, + }) + + require.Len(t, message.Fields, 1) + metadataField := message.Fields[0] + require.NotNil(t, metadataField.Message) + assert.Equal(t, "TestMessage.Metadata", metadataField.Message.Name) +} + +func TestRequiredFieldsVisitor_MemberTypes(t *testing.T) { + t.Parallel() + + schema := ` + type Storage { id: ID! name: String! } + ` + mapping := &GRPCMapping{} + + message := runRequiredFieldsVisitor(t, schema, mapping, "Storage", "name") + + assert.Equal(t, []string{"Storage"}, message.MemberTypes) +} + +func TestRequiredFieldsVisitor_DuplicateFields(t *testing.T) { + t.Parallel() + + schema := ` + type Storage { id: ID! name: String! } + ` + mapping := &GRPCMapping{} + + message := runRequiredFieldsVisitor(t, schema, mapping, "Storage", "name name") + + require.Len(t, message.Fields, 1) + assert.Equal(t, "name", message.Fields[0].Name) + assert.Equal(t, DataTypeString, message.Fields[0].ProtoTypeName) +} + +func TestRequiredFieldsVisitor_InterfaceWithNestedConcreteMessage(t *testing.T) { + t.Parallel() + + schema := ` + type Storage { id: ID! item: StorageItem! } + interface StorageItem { id: ID! name: String! } + type PalletItem implements StorageItem { id: ID! name: String! handler: ItemHandler! } + type ContainerItem implements StorageItem { id: ID! name: String! handler: ItemHandler! } + type ItemHandler { id: ID! name: String! } + ` + mapping := &GRPCMapping{ + Fields: map[string]FieldMap{ + "Storage": {"item": {TargetName: "item"}}, + "PalletItem": {"handler": {TargetName: "handler"}}, + "ContainerItem": {"handler": {TargetName: "handler"}}, + "ItemHandler": {"name": {TargetName: "name"}}, + }, + } + + message := runRequiredFieldsVisitor(t, schema, mapping, "Storage", + `item { ... on PalletItem { handler { name } } ... on ContainerItem { handler { name } } }`) + + require.Len(t, message.Fields, 1) + itemField := message.Fields[0] + assert.Equal(t, "item", itemField.Name) + assert.Equal(t, DataTypeMessage, itemField.ProtoTypeName) + require.NotNil(t, itemField.Message) + assert.Equal(t, OneOfTypeInterface, itemField.Message.OneOfType) + assert.ElementsMatch(t, []string{"PalletItem", "ContainerItem"}, itemField.Message.MemberTypes) + + require.NotNil(t, itemField.Message.FragmentFields) + + palletFields := itemField.Message.FragmentFields["PalletItem"] + require.Len(t, palletFields, 1) + assert.Equal(t, "handler", palletFields[0].Name) + assert.Equal(t, DataTypeMessage, palletFields[0].ProtoTypeName) + require.NotNil(t, palletFields[0].Message) + assert.Equal(t, "ItemHandler", palletFields[0].Message.Name) + require.Len(t, palletFields[0].Message.Fields, 1) + assert.Equal(t, "name", palletFields[0].Message.Fields[0].Name) + assert.Equal(t, DataTypeString, palletFields[0].Message.Fields[0].ProtoTypeName) + + containerFields := itemField.Message.FragmentFields["ContainerItem"] + require.Len(t, containerFields, 1) + assert.Equal(t, "handler", containerFields[0].Name) + assert.Equal(t, DataTypeMessage, containerFields[0].ProtoTypeName) + require.NotNil(t, containerFields[0].Message) + assert.Equal(t, "ItemHandler", containerFields[0].Message.Name) + require.Len(t, containerFields[0].Message.Fields, 1) + assert.Equal(t, "name", containerFields[0].Message.Fields[0].Name) + assert.Equal(t, DataTypeString, containerFields[0].Message.Fields[0].ProtoTypeName) +} + +func TestRequiredFieldsVisitor_InterfaceWithDeepConcreteNesting(t *testing.T) { + t.Parallel() + + schema := ` + type Storage { id: ID! item: StorageItem! } + interface StorageItem { id: ID! name: String! } + type PalletItem implements StorageItem { id: ID! name: String! specs: PalletSpecs! } + type ContainerItem implements StorageItem { id: ID! name: String! specs: ContainerSpecs! } + type PalletSpecs { name: String! dimensions: Dimensions! } + type ContainerSpecs { name: String! dimensions: Dimensions! } + type Dimensions { length: Float! width: Float! } + ` + mapping := &GRPCMapping{ + Fields: map[string]FieldMap{ + "Storage": {"item": {TargetName: "item"}}, + "PalletItem": {"specs": {TargetName: "specs"}}, + "ContainerItem": {"specs": {TargetName: "specs"}}, + "PalletSpecs": {"name": {TargetName: "name"}, "dimensions": {TargetName: "dimensions"}}, + "ContainerSpecs": {"name": {TargetName: "name"}, "dimensions": {TargetName: "dimensions"}}, + "Dimensions": {"length": {TargetName: "length"}, "width": {TargetName: "width"}}, + }, + } + + message := runRequiredFieldsVisitor(t, schema, mapping, "Storage", + `item { ... on PalletItem { specs { name dimensions { length width } } } ... on ContainerItem { specs { name dimensions { length width } } } }`) + + require.Len(t, message.Fields, 1) + itemField := message.Fields[0] + assert.Equal(t, OneOfTypeInterface, itemField.Message.OneOfType) + + // Verify PalletItem fragment: specs → dimensions + palletFields := itemField.Message.FragmentFields["PalletItem"] + require.Len(t, palletFields, 1) + specsField := palletFields[0] + assert.Equal(t, "specs", specsField.Name) + assert.Equal(t, DataTypeMessage, specsField.ProtoTypeName) + require.NotNil(t, specsField.Message) + require.Len(t, specsField.Message.Fields, 2) + assert.Equal(t, "name", specsField.Message.Fields[0].Name) + dimsField := specsField.Message.Fields[1] + assert.Equal(t, "dimensions", dimsField.Name) + assert.Equal(t, DataTypeMessage, dimsField.ProtoTypeName) + require.NotNil(t, dimsField.Message) + require.Len(t, dimsField.Message.Fields, 2) + assert.Equal(t, "length", dimsField.Message.Fields[0].Name) + assert.Equal(t, DataTypeDouble, dimsField.Message.Fields[0].ProtoTypeName) + assert.Equal(t, "width", dimsField.Message.Fields[1].Name) + assert.Equal(t, DataTypeDouble, dimsField.Message.Fields[1].ProtoTypeName) + + // Verify ContainerItem fragment has same structure + containerFields := itemField.Message.FragmentFields["ContainerItem"] + require.Len(t, containerFields, 1) + cSpecsField := containerFields[0] + assert.Equal(t, "specs", cSpecsField.Name) + require.NotNil(t, cSpecsField.Message) + require.Len(t, cSpecsField.Message.Fields, 2) + cDimsField := cSpecsField.Message.Fields[1] + assert.Equal(t, "dimensions", cDimsField.Name) + require.NotNil(t, cDimsField.Message) + require.Len(t, cDimsField.Message.Fields, 2) +} + +func TestRequiredFieldsVisitor_ConcreteWrappingAbstract(t *testing.T) { + t.Parallel() + + schema := ` + type Storage { id: ID! setup: SecuritySetup! } + type SecuritySetup { securityLevel: String! primaryItem: StorageItem! } + interface StorageItem { id: ID! name: String! } + type PalletItem implements StorageItem { id: ID! name: String! palletCount: Int! } + type ContainerItem implements StorageItem { id: ID! name: String! containerSize: String! } + ` + mapping := &GRPCMapping{ + Fields: map[string]FieldMap{ + "Storage": {"setup": {TargetName: "setup"}}, + "SecuritySetup": {"securityLevel": {TargetName: "security_level"}, "primaryItem": {TargetName: "primary_item"}}, + "PalletItem": {"name": {TargetName: "name"}, "palletCount": {TargetName: "pallet_count"}}, + "ContainerItem": {"name": {TargetName: "name"}, "containerSize": {TargetName: "container_size"}}, + }, + } + + message := runRequiredFieldsVisitor(t, schema, mapping, "Storage", + `setup { securityLevel primaryItem { ... on PalletItem { name palletCount } ... on ContainerItem { name containerSize } } }`) + + require.Len(t, message.Fields, 1) + setupField := message.Fields[0] + assert.Equal(t, "setup", setupField.Name) + assert.Equal(t, DataTypeMessage, setupField.ProtoTypeName) + require.NotNil(t, setupField.Message) + assert.Equal(t, "SecuritySetup", setupField.Message.Name) + + require.Len(t, setupField.Message.Fields, 2) + assert.Equal(t, "security_level", setupField.Message.Fields[0].Name) + assert.Equal(t, DataTypeString, setupField.Message.Fields[0].ProtoTypeName) + + itemField := setupField.Message.Fields[1] + assert.Equal(t, "primary_item", itemField.Name) + assert.Equal(t, DataTypeMessage, itemField.ProtoTypeName) + require.NotNil(t, itemField.Message) + assert.Equal(t, OneOfTypeInterface, itemField.Message.OneOfType) + assert.ElementsMatch(t, []string{"PalletItem", "ContainerItem"}, itemField.Message.MemberTypes) + + palletFields := itemField.Message.FragmentFields["PalletItem"] + require.Len(t, palletFields, 2) + assert.Equal(t, "name", palletFields[0].Name) + assert.Equal(t, "pallet_count", palletFields[1].Name) + + containerFields := itemField.Message.FragmentFields["ContainerItem"] + require.Len(t, containerFields, 2) + assert.Equal(t, "name", containerFields[0].Name) + assert.Equal(t, "container_size", containerFields[1].Name) +} + +func TestRequiredFieldsVisitor_NestedAbstractThroughConcrete(t *testing.T) { + t.Parallel() + + schema := ` + type Storage { id: ID! item: StorageItem! } + interface StorageItem { id: ID! name: String! } + type PalletItem implements StorageItem { id: ID! name: String! palletCount: Int! handler: ItemHandler! } + type ContainerItem implements StorageItem { id: ID! name: String! containerSize: String! handler: ItemHandler! } + type ItemHandler { id: ID! name: String! assignedItem: StorageItem! } + ` + mapping := &GRPCMapping{ + Fields: map[string]FieldMap{ + "Storage": {"item": {TargetName: "item"}}, + "PalletItem": {"handler": {TargetName: "handler"}, "name": {TargetName: "name"}, "palletCount": {TargetName: "pallet_count"}}, + "ContainerItem": {"handler": {TargetName: "handler"}, "name": {TargetName: "name"}, "containerSize": {TargetName: "container_size"}}, + "ItemHandler": {"assignedItem": {TargetName: "assigned_item"}, "name": {TargetName: "name"}}, + }, + } + + message := runRequiredFieldsVisitor(t, schema, mapping, "Storage", + `item { ... on PalletItem { handler { assignedItem { ... on ContainerItem { name containerSize } ... on PalletItem { name palletCount } } } } ... on ContainerItem { handler { name } } }`) + + require.Len(t, message.Fields, 1) + itemField := message.Fields[0] + assert.Equal(t, OneOfTypeInterface, itemField.Message.OneOfType) + + // PalletItem fragment: handler → assignedItem (abstract) + palletFields := itemField.Message.FragmentFields["PalletItem"] + require.Len(t, palletFields, 1) + handlerField := palletFields[0] + assert.Equal(t, "handler", handlerField.Name) + assert.Equal(t, DataTypeMessage, handlerField.ProtoTypeName) + require.NotNil(t, handlerField.Message) + + require.Len(t, handlerField.Message.Fields, 1) + assignedField := handlerField.Message.Fields[0] + assert.Equal(t, "assigned_item", assignedField.Name) + assert.Equal(t, DataTypeMessage, assignedField.ProtoTypeName) + require.NotNil(t, assignedField.Message) + assert.Equal(t, OneOfTypeInterface, assignedField.Message.OneOfType) + assert.ElementsMatch(t, []string{"ContainerItem", "PalletItem"}, assignedField.Message.MemberTypes) + + innerContainerFields := assignedField.Message.FragmentFields["ContainerItem"] + require.Len(t, innerContainerFields, 2) + assert.Equal(t, "name", innerContainerFields[0].Name) + assert.Equal(t, "container_size", innerContainerFields[1].Name) + + innerPalletFields := assignedField.Message.FragmentFields["PalletItem"] + require.Len(t, innerPalletFields, 2) + assert.Equal(t, "name", innerPalletFields[0].Name) + assert.Equal(t, "pallet_count", innerPalletFields[1].Name) + + // ContainerItem fragment: handler → name (scalar) + containerFields := itemField.Message.FragmentFields["ContainerItem"] + require.Len(t, containerFields, 1) + cHandlerField := containerFields[0] + assert.Equal(t, "handler", cHandlerField.Name) + require.NotNil(t, cHandlerField.Message) + require.Len(t, cHandlerField.Message.Fields, 1) + assert.Equal(t, "name", cHandlerField.Message.Fields[0].Name) + assert.Equal(t, DataTypeString, cHandlerField.Message.Fields[0].ProtoTypeName) +} diff --git a/v2/pkg/grpctest/mapping/mapping.go b/v2/pkg/grpctest/mapping/mapping.go index ac6d402522..2b151c513f 100644 --- a/v2/pkg/grpctest/mapping/mapping.go +++ b/v2/pkg/grpctest/mapping/mapping.go @@ -627,6 +627,54 @@ func DefaultGRPCMapping() *grpcdatasource.GRPCMapping { Response: "RequireStorageCategoryInfoSummaryByIdResponse", }, }, + "itemInfo": { + TargetName: "item_info", + RPCConfig: grpcdatasource.RPCConfig{ + RPC: "RequireStorageItemInfoById", + Request: "RequireStorageItemInfoByIdRequest", + Response: "RequireStorageItemInfoByIdResponse", + }, + }, + "operationReport": { + TargetName: "operation_report", + RPCConfig: grpcdatasource.RPCConfig{ + RPC: "RequireStorageOperationReportById", + Request: "RequireStorageOperationReportByIdRequest", + Response: "RequireStorageOperationReportByIdResponse", + }, + }, + "securitySummary": { + TargetName: "security_summary", + RPCConfig: grpcdatasource.RPCConfig{ + RPC: "RequireStorageSecuritySummaryById", + Request: "RequireStorageSecuritySummaryByIdRequest", + Response: "RequireStorageSecuritySummaryByIdResponse", + }, + }, + "itemHandlerInfo": { + TargetName: "item_handler_info", + RPCConfig: grpcdatasource.RPCConfig{ + RPC: "RequireStorageItemHandlerInfoById", + Request: "RequireStorageItemHandlerInfoByIdRequest", + Response: "RequireStorageItemHandlerInfoByIdResponse", + }, + }, + "itemSpecsInfo": { + TargetName: "item_specs_info", + RPCConfig: grpcdatasource.RPCConfig{ + RPC: "RequireStorageItemSpecsInfoById", + Request: "RequireStorageItemSpecsInfoByIdRequest", + Response: "RequireStorageItemSpecsInfoByIdResponse", + }, + }, + "deepItemInfo": { + TargetName: "deep_item_info", + RPCConfig: grpcdatasource.RPCConfig{ + RPC: "RequireStorageDeepItemInfoById", + Request: "RequireStorageDeepItemInfoByIdRequest", + Response: "RequireStorageDeepItemInfoByIdResponse", + }, + }, }, }, }, @@ -1023,6 +1071,33 @@ func DefaultGRPCMapping() *grpcdatasource.GRPCMapping { "categoryInfoSummary": { TargetName: "category_info_summary", }, + "primaryItem": { + TargetName: "primary_item", + }, + "lastStorageOperation": { + TargetName: "last_storage_operation", + }, + "securitySetup": { + TargetName: "security_setup", + }, + "itemInfo": { + TargetName: "item_info", + }, + "operationReport": { + TargetName: "operation_report", + }, + "securitySummary": { + TargetName: "security_summary", + }, + "itemHandlerInfo": { + TargetName: "item_handler_info", + }, + "itemSpecsInfo": { + TargetName: "item_specs_info", + }, + "deepItemInfo": { + TargetName: "deep_item_info", + }, "storageStatus": { TargetName: "storage_status", ArgumentMappings: grpcdatasource.FieldArgumentMap{ @@ -1494,6 +1569,114 @@ func DefaultGRPCMapping() *grpcdatasource.GRPCMapping { TargetName: "lifespan", }, }, + "PalletItem": { + "id": { + TargetName: "id", + }, + "name": { + TargetName: "name", + }, + "weight": { + TargetName: "weight", + }, + "palletCount": { + TargetName: "pallet_count", + }, + "handler": { + TargetName: "handler", + }, + "specs": { + TargetName: "specs", + }, + }, + "ContainerItem": { + "id": { + TargetName: "id", + }, + "name": { + TargetName: "name", + }, + "weight": { + TargetName: "weight", + }, + "containerSize": { + TargetName: "container_size", + }, + "handler": { + TargetName: "handler", + }, + "specs": { + TargetName: "specs", + }, + }, + "ItemHandler": { + "id": { + TargetName: "id", + }, + "name": { + TargetName: "name", + }, + "assignedItem": { + TargetName: "assigned_item", + }, + }, + "PalletSpecs": { + "name": { + TargetName: "name", + }, + "maxWeight": { + TargetName: "max_weight", + }, + "dimensions": { + TargetName: "dimensions", + }, + }, + "ContainerSpecs": { + "name": { + TargetName: "name", + }, + "volume": { + TargetName: "volume", + }, + "dimensions": { + TargetName: "dimensions", + }, + }, + "Dimensions": { + "length": { + TargetName: "length", + }, + "width": { + TargetName: "width", + }, + "height": { + TargetName: "height", + }, + }, + "StorageSuccess": { + "message": { + TargetName: "message", + }, + "completedAt": { + TargetName: "completed_at", + }, + }, + "StorageFailure": { + "message": { + TargetName: "message", + }, + "errorCode": { + TargetName: "error_code", + }, + }, + "SecuritySetup": { + "securityLevel": { + TargetName: "security_level", + }, + "primaryItem": { + TargetName: "primary_item", + }, + }, "ActionSuccess": { "message": { TargetName: "message", diff --git a/v2/pkg/grpctest/mockservice_requires.go b/v2/pkg/grpctest/mockservice_requires.go index d5d8840d72..c8d533cc31 100644 --- a/v2/pkg/grpctest/mockservice_requires.go +++ b/v2/pkg/grpctest/mockservice_requires.go @@ -297,3 +297,179 @@ func (s *MockService) RequireStorageCategoryInfoSummaryById(_ context.Context, r return &productv1.RequireStorageCategoryInfoSummaryByIdResponse{Result: results}, nil } + +// RequireStorageItemInfoById implements [productv1.ProductServiceServer]. +// Extracts primaryItem interface from fields and formats a summary string. +func (s *MockService) RequireStorageItemInfoById(_ context.Context, req *productv1.RequireStorageItemInfoByIdRequest) (*productv1.RequireStorageItemInfoByIdResponse, error) { + results := make([]*productv1.RequireStorageItemInfoByIdResult, 0, len(req.GetContext())) + + for _, ctx := range req.GetContext() { + fields := ctx.GetFields() + item := fields.GetPrimaryItem() + + var summary string + switch v := item.GetInstance().(type) { + case *productv1.RequireStorageItemInfoByIdFields_StorageItem_PalletItem: + summary = fmt.Sprintf("Pallet: %s (count: %d)", v.PalletItem.GetName(), v.PalletItem.GetPalletCount()) + case *productv1.RequireStorageItemInfoByIdFields_StorageItem_ContainerItem: + summary = fmt.Sprintf("Container: %s (size: %s)", v.ContainerItem.GetName(), v.ContainerItem.GetContainerSize()) + default: + summary = "Unknown item" + } + + results = append(results, &productv1.RequireStorageItemInfoByIdResult{ + ItemInfo: summary, + }) + } + + return &productv1.RequireStorageItemInfoByIdResponse{Result: results}, nil +} + +// RequireStorageOperationReportById implements [productv1.ProductServiceServer]. +// Extracts lastStorageOperation union from fields and formats a report string. +func (s *MockService) RequireStorageOperationReportById(_ context.Context, req *productv1.RequireStorageOperationReportByIdRequest) (*productv1.RequireStorageOperationReportByIdResponse, error) { + results := make([]*productv1.RequireStorageOperationReportByIdResult, 0, len(req.GetContext())) + + for _, ctx := range req.GetContext() { + fields := ctx.GetFields() + op := fields.GetLastStorageOperation() + + var report string + switch v := op.GetValue().(type) { + case *productv1.RequireStorageOperationReportByIdFields_StorageOperationResult_StorageSuccess: + report = fmt.Sprintf("Success: %s at %s", v.StorageSuccess.GetMessage(), v.StorageSuccess.GetCompletedAt()) + case *productv1.RequireStorageOperationReportByIdFields_StorageOperationResult_StorageFailure: + report = fmt.Sprintf("Failure: %s (code: %s)", v.StorageFailure.GetMessage(), v.StorageFailure.GetErrorCode()) + default: + report = "Unknown operation" + } + + results = append(results, &productv1.RequireStorageOperationReportByIdResult{ + OperationReport: report, + }) + } + + return &productv1.RequireStorageOperationReportByIdResponse{Result: results}, nil +} + +// RequireStorageSecuritySummaryById implements [productv1.ProductServiceServer]. +// Extracts securitySetup (concrete wrapping abstract) and formats a summary. +func (s *MockService) RequireStorageSecuritySummaryById(_ context.Context, req *productv1.RequireStorageSecuritySummaryByIdRequest) (*productv1.RequireStorageSecuritySummaryByIdResponse, error) { + results := make([]*productv1.RequireStorageSecuritySummaryByIdResult, 0, len(req.GetContext())) + + for _, ctx := range req.GetContext() { + fields := ctx.GetFields() + setup := fields.GetSecuritySetup() + + itemSummary := "Unknown item" + if item := setup.GetPrimaryItem(); item != nil { + switch v := item.GetInstance().(type) { + case *productv1.RequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem_PalletItem: + itemSummary = fmt.Sprintf("Pallet: %s (count: %d)", v.PalletItem.GetName(), v.PalletItem.GetPalletCount()) + case *productv1.RequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem_ContainerItem: + itemSummary = fmt.Sprintf("Container: %s (size: %s)", v.ContainerItem.GetName(), v.ContainerItem.GetContainerSize()) + } + } + + summary := fmt.Sprintf("[%s] %s", setup.GetSecurityLevel(), itemSummary) + results = append(results, &productv1.RequireStorageSecuritySummaryByIdResult{ + SecuritySummary: summary, + }) + } + + return &productv1.RequireStorageSecuritySummaryByIdResponse{Result: results}, nil +} + +// RequireStorageItemHandlerInfoById implements [productv1.ProductServiceServer]. +// Extracts handler name from within interface fragments. +func (s *MockService) RequireStorageItemHandlerInfoById(_ context.Context, req *productv1.RequireStorageItemHandlerInfoByIdRequest) (*productv1.RequireStorageItemHandlerInfoByIdResponse, error) { + results := make([]*productv1.RequireStorageItemHandlerInfoByIdResult, 0, len(req.GetContext())) + + for _, ctx := range req.GetContext() { + fields := ctx.GetFields() + item := fields.GetPrimaryItem() + + var info string + switch v := item.GetInstance().(type) { + case *productv1.RequireStorageItemHandlerInfoByIdFields_StorageItem_PalletItem: + info = fmt.Sprintf("PalletHandler: %s", v.PalletItem.GetHandler().GetName()) + case *productv1.RequireStorageItemHandlerInfoByIdFields_StorageItem_ContainerItem: + info = fmt.Sprintf("ContainerHandler: %s", v.ContainerItem.GetHandler().GetName()) + default: + info = "Unknown handler" + } + + results = append(results, &productv1.RequireStorageItemHandlerInfoByIdResult{ + ItemHandlerInfo: info, + }) + } + + return &productv1.RequireStorageItemHandlerInfoByIdResponse{Result: results}, nil +} + +// RequireStorageItemSpecsInfoById implements [productv1.ProductServiceServer]. +// Extracts specs and dimensions from deep concrete nesting inside interface fragments. +func (s *MockService) RequireStorageItemSpecsInfoById(_ context.Context, req *productv1.RequireStorageItemSpecsInfoByIdRequest) (*productv1.RequireStorageItemSpecsInfoByIdResponse, error) { + results := make([]*productv1.RequireStorageItemSpecsInfoByIdResult, 0, len(req.GetContext())) + + for _, ctx := range req.GetContext() { + fields := ctx.GetFields() + item := fields.GetPrimaryItem() + + var info string + switch v := item.GetInstance().(type) { + case *productv1.RequireStorageItemSpecsInfoByIdFields_StorageItem_PalletItem: + specs := v.PalletItem.GetSpecs() + dims := specs.GetDimensions() + info = fmt.Sprintf("PalletSpecs: %s (%.1fx%.1f)", specs.GetName(), dims.GetLength(), dims.GetWidth()) + case *productv1.RequireStorageItemSpecsInfoByIdFields_StorageItem_ContainerItem: + specs := v.ContainerItem.GetSpecs() + dims := specs.GetDimensions() + info = fmt.Sprintf("ContainerSpecs: %s (%.1fx%.1f)", specs.GetName(), dims.GetLength(), dims.GetWidth()) + default: + info = "Unknown specs" + } + + results = append(results, &productv1.RequireStorageItemSpecsInfoByIdResult{ + ItemSpecsInfo: info, + }) + } + + return &productv1.RequireStorageItemSpecsInfoByIdResponse{Result: results}, nil +} + +// RequireStorageDeepItemInfoById implements [productv1.ProductServiceServer]. +// Extracts nested abstract type through concrete intermediary (handler → assignedItem). +func (s *MockService) RequireStorageDeepItemInfoById(_ context.Context, req *productv1.RequireStorageDeepItemInfoByIdRequest) (*productv1.RequireStorageDeepItemInfoByIdResponse, error) { + results := make([]*productv1.RequireStorageDeepItemInfoByIdResult, 0, len(req.GetContext())) + + for _, ctx := range req.GetContext() { + fields := ctx.GetFields() + item := fields.GetPrimaryItem() + + var info string + switch v := item.GetInstance().(type) { + case *productv1.RequireStorageDeepItemInfoByIdFields_StorageItem_PalletItem: + handler := v.PalletItem.GetHandler() + assignedItem := handler.GetAssignedItem() + switch av := assignedItem.GetInstance().(type) { + case *productv1.RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem_ContainerItem: + info = fmt.Sprintf("PalletHandler->Container: %s (size: %s)", av.ContainerItem.GetName(), av.ContainerItem.GetContainerSize()) + case *productv1.RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem_PalletItem: + info = fmt.Sprintf("PalletHandler->Pallet: %s (count: %d)", av.PalletItem.GetName(), av.PalletItem.GetPalletCount()) + default: + info = "PalletHandler->Unknown" + } + case *productv1.RequireStorageDeepItemInfoByIdFields_StorageItem_ContainerItem: + info = fmt.Sprintf("ContainerHandler: %s", v.ContainerItem.GetHandler().GetName()) + default: + info = "Unknown deep item" + } + + results = append(results, &productv1.RequireStorageDeepItemInfoByIdResult{ + DeepItemInfo: info, + }) + } + + return &productv1.RequireStorageDeepItemInfoByIdResponse{Result: results}, nil +} diff --git a/v2/pkg/grpctest/product.proto b/v2/pkg/grpctest/product.proto index 61fcfaf857..e9c5c194dc 100644 --- a/v2/pkg/grpctest/product.proto +++ b/v2/pkg/grpctest/product.proto @@ -59,14 +59,20 @@ service ProductService { rpc QueryUser(QueryUserRequest) returns (QueryUserResponse) {} rpc QueryUsers(QueryUsersRequest) returns (QueryUsersResponse) {} rpc RequireStorageCategoryInfoSummaryById(RequireStorageCategoryInfoSummaryByIdRequest) returns (RequireStorageCategoryInfoSummaryByIdResponse) {} + rpc RequireStorageDeepItemInfoById(RequireStorageDeepItemInfoByIdRequest) returns (RequireStorageDeepItemInfoByIdResponse) {} + rpc RequireStorageItemHandlerInfoById(RequireStorageItemHandlerInfoByIdRequest) returns (RequireStorageItemHandlerInfoByIdResponse) {} + rpc RequireStorageItemInfoById(RequireStorageItemInfoByIdRequest) returns (RequireStorageItemInfoByIdResponse) {} + rpc RequireStorageItemSpecsInfoById(RequireStorageItemSpecsInfoByIdRequest) returns (RequireStorageItemSpecsInfoByIdResponse) {} rpc RequireStorageKindSummaryById(RequireStorageKindSummaryByIdRequest) returns (RequireStorageKindSummaryByIdResponse) {} rpc RequireStorageMetadataScoreById(RequireStorageMetadataScoreByIdRequest) returns (RequireStorageMetadataScoreByIdResponse) {} + rpc RequireStorageOperationReportById(RequireStorageOperationReportByIdRequest) returns (RequireStorageOperationReportByIdResponse) {} rpc RequireStorageOptionalProcessedMetadataById(RequireStorageOptionalProcessedMetadataByIdRequest) returns (RequireStorageOptionalProcessedMetadataByIdResponse) {} rpc RequireStorageOptionalProcessedTagsById(RequireStorageOptionalProcessedTagsByIdRequest) returns (RequireStorageOptionalProcessedTagsByIdResponse) {} rpc RequireStorageOptionalTagSummaryById(RequireStorageOptionalTagSummaryByIdRequest) returns (RequireStorageOptionalTagSummaryByIdResponse) {} rpc RequireStorageProcessedMetadataById(RequireStorageProcessedMetadataByIdRequest) returns (RequireStorageProcessedMetadataByIdResponse) {} rpc RequireStorageProcessedMetadataHistoryById(RequireStorageProcessedMetadataHistoryByIdRequest) returns (RequireStorageProcessedMetadataHistoryByIdResponse) {} rpc RequireStorageProcessedTagsById(RequireStorageProcessedTagsByIdRequest) returns (RequireStorageProcessedTagsByIdResponse) {} + rpc RequireStorageSecuritySummaryById(RequireStorageSecuritySummaryByIdRequest) returns (RequireStorageSecuritySummaryByIdResponse) {} rpc RequireStorageStockHealthScoreById(RequireStorageStockHealthScoreByIdRequest) returns (RequireStorageStockHealthScoreByIdResponse) {} rpc RequireStorageTagSummaryById(RequireStorageTagSummaryByIdRequest) returns (RequireStorageTagSummaryByIdResponse) {} rpc RequireWarehouseStockHealthScoreById(RequireWarehouseStockHealthScoreByIdRequest) returns (RequireWarehouseStockHealthScoreByIdResponse) {} @@ -1548,6 +1554,291 @@ message RequireStorageCategoryInfoSummaryByIdFields { StorageCategoryInfo category_info = 1; } +message RequireStorageItemInfoByIdRequest { + // RequireStorageItemInfoByIdContext provides the context for the required fields method RequireStorageItemInfoById. + repeated RequireStorageItemInfoByIdContext context = 1; +} + +message RequireStorageItemInfoByIdContext { + LookupStorageByIdRequestKey key = 1; + RequireStorageItemInfoByIdFields fields = 2; +} + +message RequireStorageItemInfoByIdResponse { + // RequireStorageItemInfoByIdResult provides the result for the required fields method RequireStorageItemInfoById. + repeated RequireStorageItemInfoByIdResult result = 1; +} + +message RequireStorageItemInfoByIdResult { + string item_info = 1; +} + +message RequireStorageItemInfoByIdFields { + message PalletItem { + string name = 1; + int32 pallet_count = 2; + } + + message ContainerItem { + string name = 1; + string container_size = 2; + } + + message StorageItem { + oneof instance { + ContainerItem container_item = 1; + PalletItem pallet_item = 2; + } + } + StorageItem primary_item = 1; +} + +message RequireStorageOperationReportByIdRequest { + // RequireStorageOperationReportByIdContext provides the context for the required fields method RequireStorageOperationReportById. + repeated RequireStorageOperationReportByIdContext context = 1; +} + +message RequireStorageOperationReportByIdContext { + LookupStorageByIdRequestKey key = 1; + RequireStorageOperationReportByIdFields fields = 2; +} + +message RequireStorageOperationReportByIdResponse { + // RequireStorageOperationReportByIdResult provides the result for the required fields method RequireStorageOperationReportById. + repeated RequireStorageOperationReportByIdResult result = 1; +} + +message RequireStorageOperationReportByIdResult { + string operation_report = 1; +} + +message RequireStorageOperationReportByIdFields { + message StorageSuccess { + string message = 1; + string completed_at = 2; + } + + message StorageFailure { + string message = 1; + string error_code = 2; + } + + message StorageOperationResult { + oneof value { + StorageFailure storage_failure = 1; + StorageSuccess storage_success = 2; + } + } + StorageOperationResult last_storage_operation = 1; +} + +message RequireStorageSecuritySummaryByIdRequest { + // RequireStorageSecuritySummaryByIdContext provides the context for the required fields method RequireStorageSecuritySummaryById. + repeated RequireStorageSecuritySummaryByIdContext context = 1; +} + +message RequireStorageSecuritySummaryByIdContext { + LookupStorageByIdRequestKey key = 1; + RequireStorageSecuritySummaryByIdFields fields = 2; +} + +message RequireStorageSecuritySummaryByIdResponse { + // RequireStorageSecuritySummaryByIdResult provides the result for the required fields method RequireStorageSecuritySummaryById. + repeated RequireStorageSecuritySummaryByIdResult result = 1; +} + +message RequireStorageSecuritySummaryByIdResult { + string security_summary = 1; +} + +message RequireStorageSecuritySummaryByIdFields { + message SecuritySetup { + message PalletItem { + string name = 1; + int32 pallet_count = 2; + } + + message ContainerItem { + string name = 1; + string container_size = 2; + } + + message StorageItem { + oneof instance { + ContainerItem container_item = 1; + PalletItem pallet_item = 2; + } + } + string security_level = 1; + StorageItem primary_item = 2; + } + + SecuritySetup security_setup = 1; +} + +message RequireStorageItemHandlerInfoByIdRequest { + // RequireStorageItemHandlerInfoByIdContext provides the context for the required fields method RequireStorageItemHandlerInfoById. + repeated RequireStorageItemHandlerInfoByIdContext context = 1; +} + +message RequireStorageItemHandlerInfoByIdContext { + LookupStorageByIdRequestKey key = 1; + RequireStorageItemHandlerInfoByIdFields fields = 2; +} + +message RequireStorageItemHandlerInfoByIdResponse { + // RequireStorageItemHandlerInfoByIdResult provides the result for the required fields method RequireStorageItemHandlerInfoById. + repeated RequireStorageItemHandlerInfoByIdResult result = 1; +} + +message RequireStorageItemHandlerInfoByIdResult { + string item_handler_info = 1; +} + +message RequireStorageItemHandlerInfoByIdFields { + message PalletItem { + message ItemHandler { + string name = 1; + } + + ItemHandler handler = 1; + } + + message ContainerItem { + message ItemHandler { + string name = 1; + } + + ItemHandler handler = 1; + } + + message StorageItem { + oneof instance { + ContainerItem container_item = 1; + PalletItem pallet_item = 2; + } + } + StorageItem primary_item = 1; +} + +message RequireStorageItemSpecsInfoByIdRequest { + // RequireStorageItemSpecsInfoByIdContext provides the context for the required fields method RequireStorageItemSpecsInfoById. + repeated RequireStorageItemSpecsInfoByIdContext context = 1; +} + +message RequireStorageItemSpecsInfoByIdContext { + LookupStorageByIdRequestKey key = 1; + RequireStorageItemSpecsInfoByIdFields fields = 2; +} + +message RequireStorageItemSpecsInfoByIdResponse { + // RequireStorageItemSpecsInfoByIdResult provides the result for the required fields method RequireStorageItemSpecsInfoById. + repeated RequireStorageItemSpecsInfoByIdResult result = 1; +} + +message RequireStorageItemSpecsInfoByIdResult { + string item_specs_info = 1; +} + +message RequireStorageItemSpecsInfoByIdFields { + message PalletItem { + message PalletSpecs { + message Dimensions { + double length = 1; + double width = 2; + } + + string name = 1; + Dimensions dimensions = 2; + } + + PalletSpecs specs = 1; + } + + message ContainerItem { + message ContainerSpecs { + message Dimensions { + double length = 1; + double width = 2; + } + + string name = 1; + Dimensions dimensions = 2; + } + + ContainerSpecs specs = 1; + } + + message StorageItem { + oneof instance { + ContainerItem container_item = 1; + PalletItem pallet_item = 2; + } + } + StorageItem primary_item = 1; +} + +message RequireStorageDeepItemInfoByIdRequest { + // RequireStorageDeepItemInfoByIdContext provides the context for the required fields method RequireStorageDeepItemInfoById. + repeated RequireStorageDeepItemInfoByIdContext context = 1; +} + +message RequireStorageDeepItemInfoByIdContext { + LookupStorageByIdRequestKey key = 1; + RequireStorageDeepItemInfoByIdFields fields = 2; +} + +message RequireStorageDeepItemInfoByIdResponse { + // RequireStorageDeepItemInfoByIdResult provides the result for the required fields method RequireStorageDeepItemInfoById. + repeated RequireStorageDeepItemInfoByIdResult result = 1; +} + +message RequireStorageDeepItemInfoByIdResult { + string deep_item_info = 1; +} + +message RequireStorageDeepItemInfoByIdFields { + message PalletItem { + message ItemHandler { + message ContainerItem { + string name = 1; + string container_size = 2; + } + + message PalletItem { + string name = 1; + int32 pallet_count = 2; + } + + message StorageItem { + oneof instance { + ContainerItem container_item = 1; + PalletItem pallet_item = 2; + } + } + StorageItem assigned_item = 1; + } + + ItemHandler handler = 1; + } + + message ContainerItem { + message ItemHandler { + string name = 1; + } + + ItemHandler handler = 1; + } + + message StorageItem { + oneof instance { + ContainerItem container_item = 1; + PalletItem pallet_item = 2; + } + } + StorageItem primary_item = 1; +} + message RequireWarehouseStockHealthScoreByIdRequest { // RequireWarehouseStockHealthScoreByIdContext provides the context for the required fields method RequireWarehouseStockHealthScoreById. repeated RequireWarehouseStockHealthScoreByIdContext context = 1; @@ -1950,6 +2241,77 @@ message BreedCharacteristics { string lifespan = 3; } +message StorageItem { + oneof instance { + PalletItem pallet_item = 1; + ContainerItem container_item = 2; + } +} + +message PalletItem { + string id = 1; + string name = 2; + double weight = 3; + int32 pallet_count = 4; + ItemHandler handler = 5; + PalletSpecs specs = 6; +} + +message ContainerItem { + string id = 1; + string name = 2; + double weight = 3; + string container_size = 4; + ItemHandler handler = 5; + ContainerSpecs specs = 6; +} + +message ItemHandler { + string id = 1; + string name = 2; + StorageItem assigned_item = 3; +} + +message PalletSpecs { + string name = 1; + double max_weight = 2; + Dimensions dimensions = 3; +} + +message ContainerSpecs { + string name = 1; + double volume = 2; + Dimensions dimensions = 3; +} + +message Dimensions { + double length = 1; + double width = 2; + double height = 3; +} + +message StorageOperationResult { + oneof value { + StorageSuccess storage_success = 1; + StorageFailure storage_failure = 2; + } +} + +message StorageSuccess { + string message = 1; + string completed_at = 2; +} + +message StorageFailure { + string message = 1; + string error_code = 2; +} + +message SecuritySetup { + string security_level = 1; + StorageItem primary_item = 2; +} + message ActionSuccess { string message = 1; string timestamp = 2; diff --git a/v2/pkg/grpctest/productv1/product.pb.go b/v2/pkg/grpctest/productv1/product.pb.go index d7dbf11daf..f616dcfd9e 100644 --- a/v2/pkg/grpctest/productv1/product.pb.go +++ b/v2/pkg/grpctest/productv1/product.pb.go @@ -13704,28 +13704,28 @@ func (x *RequireStorageCategoryInfoSummaryByIdFields) GetCategoryInfo() *Require return nil } -type RequireWarehouseStockHealthScoreByIdRequest struct { +type RequireStorageItemInfoByIdRequest struct { state protoimpl.MessageState `protogen:"open.v1"` - // RequireWarehouseStockHealthScoreByIdContext provides the context for the required fields method RequireWarehouseStockHealthScoreById. - Context []*RequireWarehouseStockHealthScoreByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` + // RequireStorageItemInfoByIdContext provides the context for the required fields method RequireStorageItemInfoById. + Context []*RequireStorageItemInfoByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireWarehouseStockHealthScoreByIdRequest) Reset() { - *x = RequireWarehouseStockHealthScoreByIdRequest{} +func (x *RequireStorageItemInfoByIdRequest) Reset() { + *x = RequireStorageItemInfoByIdRequest{} mi := &file_product_proto_msgTypes[295] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireWarehouseStockHealthScoreByIdRequest) String() string { +func (x *RequireStorageItemInfoByIdRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireWarehouseStockHealthScoreByIdRequest) ProtoMessage() {} +func (*RequireStorageItemInfoByIdRequest) ProtoMessage() {} -func (x *RequireWarehouseStockHealthScoreByIdRequest) ProtoReflect() protoreflect.Message { +func (x *RequireStorageItemInfoByIdRequest) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[295] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -13737,40 +13737,40 @@ func (x *RequireWarehouseStockHealthScoreByIdRequest) ProtoReflect() protoreflec return mi.MessageOf(x) } -// Deprecated: Use RequireWarehouseStockHealthScoreByIdRequest.ProtoReflect.Descriptor instead. -func (*RequireWarehouseStockHealthScoreByIdRequest) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageItemInfoByIdRequest.ProtoReflect.Descriptor instead. +func (*RequireStorageItemInfoByIdRequest) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{295} } -func (x *RequireWarehouseStockHealthScoreByIdRequest) GetContext() []*RequireWarehouseStockHealthScoreByIdContext { +func (x *RequireStorageItemInfoByIdRequest) GetContext() []*RequireStorageItemInfoByIdContext { if x != nil { return x.Context } return nil } -type RequireWarehouseStockHealthScoreByIdContext struct { - state protoimpl.MessageState `protogen:"open.v1"` - Key *LookupWarehouseByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` - Fields *RequireWarehouseStockHealthScoreByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` +type RequireStorageItemInfoByIdContext struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Fields *RequireStorageItemInfoByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireWarehouseStockHealthScoreByIdContext) Reset() { - *x = RequireWarehouseStockHealthScoreByIdContext{} +func (x *RequireStorageItemInfoByIdContext) Reset() { + *x = RequireStorageItemInfoByIdContext{} mi := &file_product_proto_msgTypes[296] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireWarehouseStockHealthScoreByIdContext) String() string { +func (x *RequireStorageItemInfoByIdContext) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireWarehouseStockHealthScoreByIdContext) ProtoMessage() {} +func (*RequireStorageItemInfoByIdContext) ProtoMessage() {} -func (x *RequireWarehouseStockHealthScoreByIdContext) ProtoReflect() protoreflect.Message { +func (x *RequireStorageItemInfoByIdContext) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[296] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -13782,47 +13782,47 @@ func (x *RequireWarehouseStockHealthScoreByIdContext) ProtoReflect() protoreflec return mi.MessageOf(x) } -// Deprecated: Use RequireWarehouseStockHealthScoreByIdContext.ProtoReflect.Descriptor instead. -func (*RequireWarehouseStockHealthScoreByIdContext) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageItemInfoByIdContext.ProtoReflect.Descriptor instead. +func (*RequireStorageItemInfoByIdContext) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{296} } -func (x *RequireWarehouseStockHealthScoreByIdContext) GetKey() *LookupWarehouseByIdRequestKey { +func (x *RequireStorageItemInfoByIdContext) GetKey() *LookupStorageByIdRequestKey { if x != nil { return x.Key } return nil } -func (x *RequireWarehouseStockHealthScoreByIdContext) GetFields() *RequireWarehouseStockHealthScoreByIdFields { +func (x *RequireStorageItemInfoByIdContext) GetFields() *RequireStorageItemInfoByIdFields { if x != nil { return x.Fields } return nil } -type RequireWarehouseStockHealthScoreByIdResponse struct { +type RequireStorageItemInfoByIdResponse struct { state protoimpl.MessageState `protogen:"open.v1"` - // RequireWarehouseStockHealthScoreByIdResult provides the result for the required fields method RequireWarehouseStockHealthScoreById. - Result []*RequireWarehouseStockHealthScoreByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` + // RequireStorageItemInfoByIdResult provides the result for the required fields method RequireStorageItemInfoById. + Result []*RequireStorageItemInfoByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireWarehouseStockHealthScoreByIdResponse) Reset() { - *x = RequireWarehouseStockHealthScoreByIdResponse{} +func (x *RequireStorageItemInfoByIdResponse) Reset() { + *x = RequireStorageItemInfoByIdResponse{} mi := &file_product_proto_msgTypes[297] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireWarehouseStockHealthScoreByIdResponse) String() string { +func (x *RequireStorageItemInfoByIdResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireWarehouseStockHealthScoreByIdResponse) ProtoMessage() {} +func (*RequireStorageItemInfoByIdResponse) ProtoMessage() {} -func (x *RequireWarehouseStockHealthScoreByIdResponse) ProtoReflect() protoreflect.Message { +func (x *RequireStorageItemInfoByIdResponse) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[297] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -13834,39 +13834,39 @@ func (x *RequireWarehouseStockHealthScoreByIdResponse) ProtoReflect() protorefle return mi.MessageOf(x) } -// Deprecated: Use RequireWarehouseStockHealthScoreByIdResponse.ProtoReflect.Descriptor instead. -func (*RequireWarehouseStockHealthScoreByIdResponse) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageItemInfoByIdResponse.ProtoReflect.Descriptor instead. +func (*RequireStorageItemInfoByIdResponse) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{297} } -func (x *RequireWarehouseStockHealthScoreByIdResponse) GetResult() []*RequireWarehouseStockHealthScoreByIdResult { +func (x *RequireStorageItemInfoByIdResponse) GetResult() []*RequireStorageItemInfoByIdResult { if x != nil { return x.Result } return nil } -type RequireWarehouseStockHealthScoreByIdResult struct { - state protoimpl.MessageState `protogen:"open.v1"` - StockHealthScore float64 `protobuf:"fixed64,1,opt,name=stock_health_score,json=stockHealthScore,proto3" json:"stock_health_score,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type RequireStorageItemInfoByIdResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + ItemInfo string `protobuf:"bytes,1,opt,name=item_info,json=itemInfo,proto3" json:"item_info,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *RequireWarehouseStockHealthScoreByIdResult) Reset() { - *x = RequireWarehouseStockHealthScoreByIdResult{} +func (x *RequireStorageItemInfoByIdResult) Reset() { + *x = RequireStorageItemInfoByIdResult{} mi := &file_product_proto_msgTypes[298] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireWarehouseStockHealthScoreByIdResult) String() string { +func (x *RequireStorageItemInfoByIdResult) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireWarehouseStockHealthScoreByIdResult) ProtoMessage() {} +func (*RequireStorageItemInfoByIdResult) ProtoMessage() {} -func (x *RequireWarehouseStockHealthScoreByIdResult) ProtoReflect() protoreflect.Message { +func (x *RequireStorageItemInfoByIdResult) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[298] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -13878,40 +13878,39 @@ func (x *RequireWarehouseStockHealthScoreByIdResult) ProtoReflect() protoreflect return mi.MessageOf(x) } -// Deprecated: Use RequireWarehouseStockHealthScoreByIdResult.ProtoReflect.Descriptor instead. -func (*RequireWarehouseStockHealthScoreByIdResult) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageItemInfoByIdResult.ProtoReflect.Descriptor instead. +func (*RequireStorageItemInfoByIdResult) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{298} } -func (x *RequireWarehouseStockHealthScoreByIdResult) GetStockHealthScore() float64 { +func (x *RequireStorageItemInfoByIdResult) GetItemInfo() string { if x != nil { - return x.StockHealthScore + return x.ItemInfo } - return 0 + return "" } -type RequireWarehouseStockHealthScoreByIdFields struct { - state protoimpl.MessageState `protogen:"open.v1"` - InventoryCount int32 `protobuf:"varint,1,opt,name=inventory_count,json=inventoryCount,proto3" json:"inventory_count,omitempty"` - RestockData *RequireWarehouseStockHealthScoreByIdFields_RestockData `protobuf:"bytes,2,opt,name=restock_data,json=restockData,proto3" json:"restock_data,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type RequireStorageItemInfoByIdFields struct { + state protoimpl.MessageState `protogen:"open.v1"` + PrimaryItem *RequireStorageItemInfoByIdFields_StorageItem `protobuf:"bytes,1,opt,name=primary_item,json=primaryItem,proto3" json:"primary_item,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *RequireWarehouseStockHealthScoreByIdFields) Reset() { - *x = RequireWarehouseStockHealthScoreByIdFields{} +func (x *RequireStorageItemInfoByIdFields) Reset() { + *x = RequireStorageItemInfoByIdFields{} mi := &file_product_proto_msgTypes[299] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireWarehouseStockHealthScoreByIdFields) String() string { +func (x *RequireStorageItemInfoByIdFields) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireWarehouseStockHealthScoreByIdFields) ProtoMessage() {} +func (*RequireStorageItemInfoByIdFields) ProtoMessage() {} -func (x *RequireWarehouseStockHealthScoreByIdFields) ProtoReflect() protoreflect.Message { +func (x *RequireStorageItemInfoByIdFields) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[299] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -13923,48 +13922,40 @@ func (x *RequireWarehouseStockHealthScoreByIdFields) ProtoReflect() protoreflect return mi.MessageOf(x) } -// Deprecated: Use RequireWarehouseStockHealthScoreByIdFields.ProtoReflect.Descriptor instead. -func (*RequireWarehouseStockHealthScoreByIdFields) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageItemInfoByIdFields.ProtoReflect.Descriptor instead. +func (*RequireStorageItemInfoByIdFields) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{299} } -func (x *RequireWarehouseStockHealthScoreByIdFields) GetInventoryCount() int32 { - if x != nil { - return x.InventoryCount - } - return 0 -} - -func (x *RequireWarehouseStockHealthScoreByIdFields) GetRestockData() *RequireWarehouseStockHealthScoreByIdFields_RestockData { +func (x *RequireStorageItemInfoByIdFields) GetPrimaryItem() *RequireStorageItemInfoByIdFields_StorageItem { if x != nil { - return x.RestockData + return x.PrimaryItem } return nil } -type Product struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` - Price float64 `protobuf:"fixed64,3,opt,name=price,proto3" json:"price,omitempty"` +type RequireStorageOperationReportByIdRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // RequireStorageOperationReportByIdContext provides the context for the required fields method RequireStorageOperationReportById. + Context []*RequireStorageOperationReportByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *Product) Reset() { - *x = Product{} +func (x *RequireStorageOperationReportByIdRequest) Reset() { + *x = RequireStorageOperationReportByIdRequest{} mi := &file_product_proto_msgTypes[300] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *Product) String() string { +func (x *RequireStorageOperationReportByIdRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*Product) ProtoMessage() {} +func (*RequireStorageOperationReportByIdRequest) ProtoMessage() {} -func (x *Product) ProtoReflect() protoreflect.Message { +func (x *RequireStorageOperationReportByIdRequest) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[300] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -13976,55 +13967,40 @@ func (x *Product) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use Product.ProtoReflect.Descriptor instead. -func (*Product) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageOperationReportByIdRequest.ProtoReflect.Descriptor instead. +func (*RequireStorageOperationReportByIdRequest) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{300} } -func (x *Product) GetId() string { - if x != nil { - return x.Id - } - return "" -} - -func (x *Product) GetName() string { - if x != nil { - return x.Name - } - return "" -} - -func (x *Product) GetPrice() float64 { +func (x *RequireStorageOperationReportByIdRequest) GetContext() []*RequireStorageOperationReportByIdContext { if x != nil { - return x.Price + return x.Context } - return 0 + return nil } -type Storage struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` - Location string `protobuf:"bytes,3,opt,name=location,proto3" json:"location,omitempty"` +type RequireStorageOperationReportByIdContext struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Fields *RequireStorageOperationReportByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *Storage) Reset() { - *x = Storage{} +func (x *RequireStorageOperationReportByIdContext) Reset() { + *x = RequireStorageOperationReportByIdContext{} mi := &file_product_proto_msgTypes[301] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *Storage) String() string { +func (x *RequireStorageOperationReportByIdContext) String() string { return protoimpl.X.MessageStringOf(x) } -func (*Storage) ProtoMessage() {} +func (*RequireStorageOperationReportByIdContext) ProtoMessage() {} -func (x *Storage) ProtoReflect() protoreflect.Message { +func (x *RequireStorageOperationReportByIdContext) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[301] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -14036,55 +14012,47 @@ func (x *Storage) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use Storage.ProtoReflect.Descriptor instead. -func (*Storage) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageOperationReportByIdContext.ProtoReflect.Descriptor instead. +func (*RequireStorageOperationReportByIdContext) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{301} } -func (x *Storage) GetId() string { - if x != nil { - return x.Id - } - return "" -} - -func (x *Storage) GetName() string { +func (x *RequireStorageOperationReportByIdContext) GetKey() *LookupStorageByIdRequestKey { if x != nil { - return x.Name + return x.Key } - return "" + return nil } -func (x *Storage) GetLocation() string { +func (x *RequireStorageOperationReportByIdContext) GetFields() *RequireStorageOperationReportByIdFields { if x != nil { - return x.Location + return x.Fields } - return "" + return nil } -type Warehouse struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` - Location string `protobuf:"bytes,3,opt,name=location,proto3" json:"location,omitempty"` +type RequireStorageOperationReportByIdResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // RequireStorageOperationReportByIdResult provides the result for the required fields method RequireStorageOperationReportById. + Result []*RequireStorageOperationReportByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *Warehouse) Reset() { - *x = Warehouse{} +func (x *RequireStorageOperationReportByIdResponse) Reset() { + *x = RequireStorageOperationReportByIdResponse{} mi := &file_product_proto_msgTypes[302] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *Warehouse) String() string { +func (x *RequireStorageOperationReportByIdResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*Warehouse) ProtoMessage() {} +func (*RequireStorageOperationReportByIdResponse) ProtoMessage() {} -func (x *Warehouse) ProtoReflect() protoreflect.Message { +func (x *RequireStorageOperationReportByIdResponse) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[302] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -14096,54 +14064,39 @@ func (x *Warehouse) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use Warehouse.ProtoReflect.Descriptor instead. -func (*Warehouse) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageOperationReportByIdResponse.ProtoReflect.Descriptor instead. +func (*RequireStorageOperationReportByIdResponse) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{302} } -func (x *Warehouse) GetId() string { - if x != nil { - return x.Id - } - return "" -} - -func (x *Warehouse) GetName() string { - if x != nil { - return x.Name - } - return "" -} - -func (x *Warehouse) GetLocation() string { +func (x *RequireStorageOperationReportByIdResponse) GetResult() []*RequireStorageOperationReportByIdResult { if x != nil { - return x.Location + return x.Result } - return "" + return nil } -type User struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type RequireStorageOperationReportByIdResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + OperationReport string `protobuf:"bytes,1,opt,name=operation_report,json=operationReport,proto3" json:"operation_report,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *User) Reset() { - *x = User{} +func (x *RequireStorageOperationReportByIdResult) Reset() { + *x = RequireStorageOperationReportByIdResult{} mi := &file_product_proto_msgTypes[303] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *User) String() string { +func (x *RequireStorageOperationReportByIdResult) String() string { return protoimpl.X.MessageStringOf(x) } -func (*User) ProtoMessage() {} +func (*RequireStorageOperationReportByIdResult) ProtoMessage() {} -func (x *User) ProtoReflect() protoreflect.Message { +func (x *RequireStorageOperationReportByIdResult) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[303] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -14155,48 +14108,39 @@ func (x *User) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use User.ProtoReflect.Descriptor instead. -func (*User) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageOperationReportByIdResult.ProtoReflect.Descriptor instead. +func (*RequireStorageOperationReportByIdResult) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{303} } -func (x *User) GetId() string { - if x != nil { - return x.Id - } - return "" -} - -func (x *User) GetName() string { +func (x *RequireStorageOperationReportByIdResult) GetOperationReport() string { if x != nil { - return x.Name + return x.OperationReport } return "" } -type NestedTypeA struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` - B *NestedTypeB `protobuf:"bytes,3,opt,name=b,proto3" json:"b,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type RequireStorageOperationReportByIdFields struct { + state protoimpl.MessageState `protogen:"open.v1"` + LastStorageOperation *RequireStorageOperationReportByIdFields_StorageOperationResult `protobuf:"bytes,1,opt,name=last_storage_operation,json=lastStorageOperation,proto3" json:"last_storage_operation,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *NestedTypeA) Reset() { - *x = NestedTypeA{} +func (x *RequireStorageOperationReportByIdFields) Reset() { + *x = RequireStorageOperationReportByIdFields{} mi := &file_product_proto_msgTypes[304] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *NestedTypeA) String() string { +func (x *RequireStorageOperationReportByIdFields) String() string { return protoimpl.X.MessageStringOf(x) } -func (*NestedTypeA) ProtoMessage() {} +func (*RequireStorageOperationReportByIdFields) ProtoMessage() {} -func (x *NestedTypeA) ProtoReflect() protoreflect.Message { +func (x *RequireStorageOperationReportByIdFields) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[304] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -14208,55 +14152,40 @@ func (x *NestedTypeA) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use NestedTypeA.ProtoReflect.Descriptor instead. -func (*NestedTypeA) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageOperationReportByIdFields.ProtoReflect.Descriptor instead. +func (*RequireStorageOperationReportByIdFields) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{304} } -func (x *NestedTypeA) GetId() string { - if x != nil { - return x.Id - } - return "" -} - -func (x *NestedTypeA) GetName() string { - if x != nil { - return x.Name - } - return "" -} - -func (x *NestedTypeA) GetB() *NestedTypeB { +func (x *RequireStorageOperationReportByIdFields) GetLastStorageOperation() *RequireStorageOperationReportByIdFields_StorageOperationResult { if x != nil { - return x.B + return x.LastStorageOperation } return nil } -type RecursiveType struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` - RecursiveType *RecursiveType `protobuf:"bytes,3,opt,name=recursive_type,json=recursiveType,proto3" json:"recursive_type,omitempty"` +type RequireStorageSecuritySummaryByIdRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // RequireStorageSecuritySummaryByIdContext provides the context for the required fields method RequireStorageSecuritySummaryById. + Context []*RequireStorageSecuritySummaryByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RecursiveType) Reset() { - *x = RecursiveType{} +func (x *RequireStorageSecuritySummaryByIdRequest) Reset() { + *x = RequireStorageSecuritySummaryByIdRequest{} mi := &file_product_proto_msgTypes[305] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RecursiveType) String() string { +func (x *RequireStorageSecuritySummaryByIdRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RecursiveType) ProtoMessage() {} +func (*RequireStorageSecuritySummaryByIdRequest) ProtoMessage() {} -func (x *RecursiveType) ProtoReflect() protoreflect.Message { +func (x *RequireStorageSecuritySummaryByIdRequest) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[305] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -14268,56 +14197,40 @@ func (x *RecursiveType) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use RecursiveType.ProtoReflect.Descriptor instead. -func (*RecursiveType) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageSecuritySummaryByIdRequest.ProtoReflect.Descriptor instead. +func (*RequireStorageSecuritySummaryByIdRequest) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{305} } -func (x *RecursiveType) GetId() string { +func (x *RequireStorageSecuritySummaryByIdRequest) GetContext() []*RequireStorageSecuritySummaryByIdContext { if x != nil { - return x.Id + return x.Context } - return "" + return nil } -func (x *RecursiveType) GetName() string { - if x != nil { - return x.Name - } - return "" +type RequireStorageSecuritySummaryByIdContext struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Fields *RequireStorageSecuritySummaryByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *RecursiveType) GetRecursiveType() *RecursiveType { - if x != nil { - return x.RecursiveType - } - return nil -} - -type TypeWithMultipleFilterFields struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` - FilterField_1 string `protobuf:"bytes,3,opt,name=filter_field_1,json=filterField1,proto3" json:"filter_field_1,omitempty"` - FilterField_2 string `protobuf:"bytes,4,opt,name=filter_field_2,json=filterField2,proto3" json:"filter_field_2,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *TypeWithMultipleFilterFields) Reset() { - *x = TypeWithMultipleFilterFields{} +func (x *RequireStorageSecuritySummaryByIdContext) Reset() { + *x = RequireStorageSecuritySummaryByIdContext{} mi := &file_product_proto_msgTypes[306] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *TypeWithMultipleFilterFields) String() string { +func (x *RequireStorageSecuritySummaryByIdContext) String() string { return protoimpl.X.MessageStringOf(x) } -func (*TypeWithMultipleFilterFields) ProtoMessage() {} +func (*RequireStorageSecuritySummaryByIdContext) ProtoMessage() {} -func (x *TypeWithMultipleFilterFields) ProtoReflect() protoreflect.Message { +func (x *RequireStorageSecuritySummaryByIdContext) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[306] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -14329,61 +14242,47 @@ func (x *TypeWithMultipleFilterFields) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use TypeWithMultipleFilterFields.ProtoReflect.Descriptor instead. -func (*TypeWithMultipleFilterFields) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageSecuritySummaryByIdContext.ProtoReflect.Descriptor instead. +func (*RequireStorageSecuritySummaryByIdContext) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{306} } -func (x *TypeWithMultipleFilterFields) GetId() string { - if x != nil { - return x.Id - } - return "" -} - -func (x *TypeWithMultipleFilterFields) GetName() string { - if x != nil { - return x.Name - } - return "" -} - -func (x *TypeWithMultipleFilterFields) GetFilterField_1() string { +func (x *RequireStorageSecuritySummaryByIdContext) GetKey() *LookupStorageByIdRequestKey { if x != nil { - return x.FilterField_1 + return x.Key } - return "" + return nil } -func (x *TypeWithMultipleFilterFields) GetFilterField_2() string { +func (x *RequireStorageSecuritySummaryByIdContext) GetFields() *RequireStorageSecuritySummaryByIdFields { if x != nil { - return x.FilterField_2 + return x.Fields } - return "" + return nil } -type FilterTypeInput struct { - state protoimpl.MessageState `protogen:"open.v1"` - FilterField_1 string `protobuf:"bytes,1,opt,name=filter_field_1,json=filterField1,proto3" json:"filter_field_1,omitempty"` - FilterField_2 string `protobuf:"bytes,2,opt,name=filter_field_2,json=filterField2,proto3" json:"filter_field_2,omitempty"` +type RequireStorageSecuritySummaryByIdResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // RequireStorageSecuritySummaryByIdResult provides the result for the required fields method RequireStorageSecuritySummaryById. + Result []*RequireStorageSecuritySummaryByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *FilterTypeInput) Reset() { - *x = FilterTypeInput{} +func (x *RequireStorageSecuritySummaryByIdResponse) Reset() { + *x = RequireStorageSecuritySummaryByIdResponse{} mi := &file_product_proto_msgTypes[307] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *FilterTypeInput) String() string { +func (x *RequireStorageSecuritySummaryByIdResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*FilterTypeInput) ProtoMessage() {} +func (*RequireStorageSecuritySummaryByIdResponse) ProtoMessage() {} -func (x *FilterTypeInput) ProtoReflect() protoreflect.Message { +func (x *RequireStorageSecuritySummaryByIdResponse) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[307] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -14395,46 +14294,39 @@ func (x *FilterTypeInput) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use FilterTypeInput.ProtoReflect.Descriptor instead. -func (*FilterTypeInput) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageSecuritySummaryByIdResponse.ProtoReflect.Descriptor instead. +func (*RequireStorageSecuritySummaryByIdResponse) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{307} } -func (x *FilterTypeInput) GetFilterField_1() string { - if x != nil { - return x.FilterField_1 - } - return "" -} - -func (x *FilterTypeInput) GetFilterField_2() string { +func (x *RequireStorageSecuritySummaryByIdResponse) GetResult() []*RequireStorageSecuritySummaryByIdResult { if x != nil { - return x.FilterField_2 + return x.Result } - return "" + return nil } -type ComplexFilterTypeInput struct { - state protoimpl.MessageState `protogen:"open.v1"` - Filter *FilterType `protobuf:"bytes,1,opt,name=filter,proto3" json:"filter,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type RequireStorageSecuritySummaryByIdResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + SecuritySummary string `protobuf:"bytes,1,opt,name=security_summary,json=securitySummary,proto3" json:"security_summary,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *ComplexFilterTypeInput) Reset() { - *x = ComplexFilterTypeInput{} +func (x *RequireStorageSecuritySummaryByIdResult) Reset() { + *x = RequireStorageSecuritySummaryByIdResult{} mi := &file_product_proto_msgTypes[308] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ComplexFilterTypeInput) String() string { +func (x *RequireStorageSecuritySummaryByIdResult) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ComplexFilterTypeInput) ProtoMessage() {} +func (*RequireStorageSecuritySummaryByIdResult) ProtoMessage() {} -func (x *ComplexFilterTypeInput) ProtoReflect() protoreflect.Message { +func (x *RequireStorageSecuritySummaryByIdResult) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[308] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -14446,40 +14338,39 @@ func (x *ComplexFilterTypeInput) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ComplexFilterTypeInput.ProtoReflect.Descriptor instead. -func (*ComplexFilterTypeInput) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageSecuritySummaryByIdResult.ProtoReflect.Descriptor instead. +func (*RequireStorageSecuritySummaryByIdResult) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{308} } -func (x *ComplexFilterTypeInput) GetFilter() *FilterType { +func (x *RequireStorageSecuritySummaryByIdResult) GetSecuritySummary() string { if x != nil { - return x.Filter + return x.SecuritySummary } - return nil + return "" } -type TypeWithComplexFilterInput struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` +type RequireStorageSecuritySummaryByIdFields struct { + state protoimpl.MessageState `protogen:"open.v1"` + SecuritySetup *RequireStorageSecuritySummaryByIdFields_SecuritySetup `protobuf:"bytes,1,opt,name=security_setup,json=securitySetup,proto3" json:"security_setup,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *TypeWithComplexFilterInput) Reset() { - *x = TypeWithComplexFilterInput{} +func (x *RequireStorageSecuritySummaryByIdFields) Reset() { + *x = RequireStorageSecuritySummaryByIdFields{} mi := &file_product_proto_msgTypes[309] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *TypeWithComplexFilterInput) String() string { +func (x *RequireStorageSecuritySummaryByIdFields) String() string { return protoimpl.X.MessageStringOf(x) } -func (*TypeWithComplexFilterInput) ProtoMessage() {} +func (*RequireStorageSecuritySummaryByIdFields) ProtoMessage() {} -func (x *TypeWithComplexFilterInput) ProtoReflect() protoreflect.Message { +func (x *RequireStorageSecuritySummaryByIdFields) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[309] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -14491,48 +14382,40 @@ func (x *TypeWithComplexFilterInput) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use TypeWithComplexFilterInput.ProtoReflect.Descriptor instead. -func (*TypeWithComplexFilterInput) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageSecuritySummaryByIdFields.ProtoReflect.Descriptor instead. +func (*RequireStorageSecuritySummaryByIdFields) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{309} } -func (x *TypeWithComplexFilterInput) GetId() string { - if x != nil { - return x.Id - } - return "" -} - -func (x *TypeWithComplexFilterInput) GetName() string { +func (x *RequireStorageSecuritySummaryByIdFields) GetSecuritySetup() *RequireStorageSecuritySummaryByIdFields_SecuritySetup { if x != nil { - return x.Name + return x.SecuritySetup } - return "" + return nil } -type OrderInput struct { - state protoimpl.MessageState `protogen:"open.v1"` - OrderId string `protobuf:"bytes,1,opt,name=order_id,json=orderId,proto3" json:"order_id,omitempty"` - CustomerName string `protobuf:"bytes,2,opt,name=customer_name,json=customerName,proto3" json:"customer_name,omitempty"` - Lines []*OrderLineInput `protobuf:"bytes,3,rep,name=lines,proto3" json:"lines,omitempty"` +type RequireStorageItemHandlerInfoByIdRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // RequireStorageItemHandlerInfoByIdContext provides the context for the required fields method RequireStorageItemHandlerInfoById. + Context []*RequireStorageItemHandlerInfoByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *OrderInput) Reset() { - *x = OrderInput{} +func (x *RequireStorageItemHandlerInfoByIdRequest) Reset() { + *x = RequireStorageItemHandlerInfoByIdRequest{} mi := &file_product_proto_msgTypes[310] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *OrderInput) String() string { +func (x *RequireStorageItemHandlerInfoByIdRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*OrderInput) ProtoMessage() {} +func (*RequireStorageItemHandlerInfoByIdRequest) ProtoMessage() {} -func (x *OrderInput) ProtoReflect() protoreflect.Message { +func (x *RequireStorageItemHandlerInfoByIdRequest) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[310] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -14544,56 +14427,40 @@ func (x *OrderInput) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use OrderInput.ProtoReflect.Descriptor instead. -func (*OrderInput) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageItemHandlerInfoByIdRequest.ProtoReflect.Descriptor instead. +func (*RequireStorageItemHandlerInfoByIdRequest) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{310} } -func (x *OrderInput) GetOrderId() string { - if x != nil { - return x.OrderId - } - return "" -} - -func (x *OrderInput) GetCustomerName() string { - if x != nil { - return x.CustomerName - } - return "" -} - -func (x *OrderInput) GetLines() []*OrderLineInput { +func (x *RequireStorageItemHandlerInfoByIdRequest) GetContext() []*RequireStorageItemHandlerInfoByIdContext { if x != nil { - return x.Lines + return x.Context } return nil } -type Order struct { - state protoimpl.MessageState `protogen:"open.v1"` - OrderId string `protobuf:"bytes,1,opt,name=order_id,json=orderId,proto3" json:"order_id,omitempty"` - CustomerName string `protobuf:"bytes,2,opt,name=customer_name,json=customerName,proto3" json:"customer_name,omitempty"` - TotalItems int32 `protobuf:"varint,3,opt,name=total_items,json=totalItems,proto3" json:"total_items,omitempty"` - OrderLines *ListOfOrderLine `protobuf:"bytes,4,opt,name=order_lines,json=orderLines,proto3" json:"order_lines,omitempty"` +type RequireStorageItemHandlerInfoByIdContext struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Fields *RequireStorageItemHandlerInfoByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *Order) Reset() { - *x = Order{} +func (x *RequireStorageItemHandlerInfoByIdContext) Reset() { + *x = RequireStorageItemHandlerInfoByIdContext{} mi := &file_product_proto_msgTypes[311] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *Order) String() string { +func (x *RequireStorageItemHandlerInfoByIdContext) String() string { return protoimpl.X.MessageStringOf(x) } -func (*Order) ProtoMessage() {} +func (*RequireStorageItemHandlerInfoByIdContext) ProtoMessage() {} -func (x *Order) ProtoReflect() protoreflect.Message { +func (x *RequireStorageItemHandlerInfoByIdContext) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[311] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -14605,64 +14472,47 @@ func (x *Order) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use Order.ProtoReflect.Descriptor instead. -func (*Order) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageItemHandlerInfoByIdContext.ProtoReflect.Descriptor instead. +func (*RequireStorageItemHandlerInfoByIdContext) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{311} } -func (x *Order) GetOrderId() string { - if x != nil { - return x.OrderId - } - return "" -} - -func (x *Order) GetCustomerName() string { - if x != nil { - return x.CustomerName - } - return "" -} - -func (x *Order) GetTotalItems() int32 { +func (x *RequireStorageItemHandlerInfoByIdContext) GetKey() *LookupStorageByIdRequestKey { if x != nil { - return x.TotalItems + return x.Key } - return 0 + return nil } -func (x *Order) GetOrderLines() *ListOfOrderLine { +func (x *RequireStorageItemHandlerInfoByIdContext) GetFields() *RequireStorageItemHandlerInfoByIdFields { if x != nil { - return x.OrderLines + return x.Fields } return nil } -type Category struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` - Kind CategoryKind `protobuf:"varint,3,opt,name=kind,proto3,enum=productv1.CategoryKind" json:"kind,omitempty"` - Subcategories *ListOfSubcategory `protobuf:"bytes,4,opt,name=subcategories,proto3" json:"subcategories,omitempty"` - NullMetrics *CategoryMetrics `protobuf:"bytes,5,opt,name=null_metrics,json=nullMetrics,proto3" json:"null_metrics,omitempty"` +type RequireStorageItemHandlerInfoByIdResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // RequireStorageItemHandlerInfoByIdResult provides the result for the required fields method RequireStorageItemHandlerInfoById. + Result []*RequireStorageItemHandlerInfoByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *Category) Reset() { - *x = Category{} +func (x *RequireStorageItemHandlerInfoByIdResponse) Reset() { + *x = RequireStorageItemHandlerInfoByIdResponse{} mi := &file_product_proto_msgTypes[312] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *Category) String() string { +func (x *RequireStorageItemHandlerInfoByIdResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*Category) ProtoMessage() {} +func (*RequireStorageItemHandlerInfoByIdResponse) ProtoMessage() {} -func (x *Category) ProtoReflect() protoreflect.Message { +func (x *RequireStorageItemHandlerInfoByIdResponse) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[312] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -14674,69 +14524,84 @@ func (x *Category) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use Category.ProtoReflect.Descriptor instead. -func (*Category) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageItemHandlerInfoByIdResponse.ProtoReflect.Descriptor instead. +func (*RequireStorageItemHandlerInfoByIdResponse) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{312} } -func (x *Category) GetId() string { +func (x *RequireStorageItemHandlerInfoByIdResponse) GetResult() []*RequireStorageItemHandlerInfoByIdResult { if x != nil { - return x.Id + return x.Result } - return "" + return nil } -func (x *Category) GetName() string { - if x != nil { - return x.Name - } - return "" +type RequireStorageItemHandlerInfoByIdResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + ItemHandlerInfo string `protobuf:"bytes,1,opt,name=item_handler_info,json=itemHandlerInfo,proto3" json:"item_handler_info,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *Category) GetKind() CategoryKind { - if x != nil { - return x.Kind - } - return CategoryKind_CATEGORY_KIND_UNSPECIFIED +func (x *RequireStorageItemHandlerInfoByIdResult) Reset() { + *x = RequireStorageItemHandlerInfoByIdResult{} + mi := &file_product_proto_msgTypes[313] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } -func (x *Category) GetSubcategories() *ListOfSubcategory { +func (x *RequireStorageItemHandlerInfoByIdResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageItemHandlerInfoByIdResult) ProtoMessage() {} + +func (x *RequireStorageItemHandlerInfoByIdResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[313] if x != nil { - return x.Subcategories + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms } - return nil + return mi.MessageOf(x) } -func (x *Category) GetNullMetrics() *CategoryMetrics { +// Deprecated: Use RequireStorageItemHandlerInfoByIdResult.ProtoReflect.Descriptor instead. +func (*RequireStorageItemHandlerInfoByIdResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{313} +} + +func (x *RequireStorageItemHandlerInfoByIdResult) GetItemHandlerInfo() string { if x != nil { - return x.NullMetrics + return x.ItemHandlerInfo } - return nil + return "" } -type CategoryFilter struct { - state protoimpl.MessageState `protogen:"open.v1"` - Category CategoryKind `protobuf:"varint,1,opt,name=category,proto3,enum=productv1.CategoryKind" json:"category,omitempty"` - Pagination *Pagination `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"` +type RequireStorageItemHandlerInfoByIdFields struct { + state protoimpl.MessageState `protogen:"open.v1"` + PrimaryItem *RequireStorageItemHandlerInfoByIdFields_StorageItem `protobuf:"bytes,1,opt,name=primary_item,json=primaryItem,proto3" json:"primary_item,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *CategoryFilter) Reset() { - *x = CategoryFilter{} - mi := &file_product_proto_msgTypes[313] +func (x *RequireStorageItemHandlerInfoByIdFields) Reset() { + *x = RequireStorageItemHandlerInfoByIdFields{} + mi := &file_product_proto_msgTypes[314] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *CategoryFilter) String() string { +func (x *RequireStorageItemHandlerInfoByIdFields) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CategoryFilter) ProtoMessage() {} +func (*RequireStorageItemHandlerInfoByIdFields) ProtoMessage() {} -func (x *CategoryFilter) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[313] +func (x *RequireStorageItemHandlerInfoByIdFields) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[314] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14747,51 +14612,41 @@ func (x *CategoryFilter) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use CategoryFilter.ProtoReflect.Descriptor instead. -func (*CategoryFilter) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{313} +// Deprecated: Use RequireStorageItemHandlerInfoByIdFields.ProtoReflect.Descriptor instead. +func (*RequireStorageItemHandlerInfoByIdFields) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{314} } -func (x *CategoryFilter) GetCategory() CategoryKind { +func (x *RequireStorageItemHandlerInfoByIdFields) GetPrimaryItem() *RequireStorageItemHandlerInfoByIdFields_StorageItem { if x != nil { - return x.Category + return x.PrimaryItem } - return CategoryKind_CATEGORY_KIND_UNSPECIFIED + return nil } -func (x *CategoryFilter) GetPagination() *Pagination { - if x != nil { - return x.Pagination - } - return nil -} - -type Animal struct { +type RequireStorageItemSpecsInfoByIdRequest struct { state protoimpl.MessageState `protogen:"open.v1"` - // Types that are valid to be assigned to Instance: - // - // *Animal_Cat - // *Animal_Dog - Instance isAnimal_Instance `protobuf_oneof:"instance"` + // RequireStorageItemSpecsInfoByIdContext provides the context for the required fields method RequireStorageItemSpecsInfoById. + Context []*RequireStorageItemSpecsInfoByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *Animal) Reset() { - *x = Animal{} - mi := &file_product_proto_msgTypes[314] +func (x *RequireStorageItemSpecsInfoByIdRequest) Reset() { + *x = RequireStorageItemSpecsInfoByIdRequest{} + mi := &file_product_proto_msgTypes[315] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *Animal) String() string { +func (x *RequireStorageItemSpecsInfoByIdRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*Animal) ProtoMessage() {} +func (*RequireStorageItemSpecsInfoByIdRequest) ProtoMessage() {} -func (x *Animal) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[314] +func (x *RequireStorageItemSpecsInfoByIdRequest) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[315] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14802,75 +14657,41 @@ func (x *Animal) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use Animal.ProtoReflect.Descriptor instead. -func (*Animal) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{314} -} - -func (x *Animal) GetInstance() isAnimal_Instance { - if x != nil { - return x.Instance - } - return nil -} - -func (x *Animal) GetCat() *Cat { - if x != nil { - if x, ok := x.Instance.(*Animal_Cat); ok { - return x.Cat - } - } - return nil +// Deprecated: Use RequireStorageItemSpecsInfoByIdRequest.ProtoReflect.Descriptor instead. +func (*RequireStorageItemSpecsInfoByIdRequest) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{315} } -func (x *Animal) GetDog() *Dog { +func (x *RequireStorageItemSpecsInfoByIdRequest) GetContext() []*RequireStorageItemSpecsInfoByIdContext { if x != nil { - if x, ok := x.Instance.(*Animal_Dog); ok { - return x.Dog - } + return x.Context } return nil } -type isAnimal_Instance interface { - isAnimal_Instance() -} - -type Animal_Cat struct { - Cat *Cat `protobuf:"bytes,1,opt,name=cat,proto3,oneof"` -} - -type Animal_Dog struct { - Dog *Dog `protobuf:"bytes,2,opt,name=dog,proto3,oneof"` -} - -func (*Animal_Cat) isAnimal_Instance() {} - -func (*Animal_Dog) isAnimal_Instance() {} - -type SearchInput struct { - state protoimpl.MessageState `protogen:"open.v1"` - Query string `protobuf:"bytes,1,opt,name=query,proto3" json:"query,omitempty"` - Limit *wrapperspb.Int32Value `protobuf:"bytes,2,opt,name=limit,proto3" json:"limit,omitempty"` +type RequireStorageItemSpecsInfoByIdContext struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Fields *RequireStorageItemSpecsInfoByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *SearchInput) Reset() { - *x = SearchInput{} - mi := &file_product_proto_msgTypes[315] +func (x *RequireStorageItemSpecsInfoByIdContext) Reset() { + *x = RequireStorageItemSpecsInfoByIdContext{} + mi := &file_product_proto_msgTypes[316] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *SearchInput) String() string { +func (x *RequireStorageItemSpecsInfoByIdContext) String() string { return protoimpl.X.MessageStringOf(x) } -func (*SearchInput) ProtoMessage() {} +func (*RequireStorageItemSpecsInfoByIdContext) ProtoMessage() {} -func (x *SearchInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[315] +func (x *RequireStorageItemSpecsInfoByIdContext) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[316] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14881,52 +14702,48 @@ func (x *SearchInput) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use SearchInput.ProtoReflect.Descriptor instead. -func (*SearchInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{315} +// Deprecated: Use RequireStorageItemSpecsInfoByIdContext.ProtoReflect.Descriptor instead. +func (*RequireStorageItemSpecsInfoByIdContext) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{316} } -func (x *SearchInput) GetQuery() string { +func (x *RequireStorageItemSpecsInfoByIdContext) GetKey() *LookupStorageByIdRequestKey { if x != nil { - return x.Query + return x.Key } - return "" + return nil } -func (x *SearchInput) GetLimit() *wrapperspb.Int32Value { +func (x *RequireStorageItemSpecsInfoByIdContext) GetFields() *RequireStorageItemSpecsInfoByIdFields { if x != nil { - return x.Limit + return x.Fields } return nil } -type SearchResult struct { +type RequireStorageItemSpecsInfoByIdResponse struct { state protoimpl.MessageState `protogen:"open.v1"` - // Types that are valid to be assigned to Value: - // - // *SearchResult_Product - // *SearchResult_User - // *SearchResult_Category - Value isSearchResult_Value `protobuf_oneof:"value"` + // RequireStorageItemSpecsInfoByIdResult provides the result for the required fields method RequireStorageItemSpecsInfoById. + Result []*RequireStorageItemSpecsInfoByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *SearchResult) Reset() { - *x = SearchResult{} - mi := &file_product_proto_msgTypes[316] +func (x *RequireStorageItemSpecsInfoByIdResponse) Reset() { + *x = RequireStorageItemSpecsInfoByIdResponse{} + mi := &file_product_proto_msgTypes[317] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *SearchResult) String() string { +func (x *RequireStorageItemSpecsInfoByIdResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*SearchResult) ProtoMessage() {} +func (*RequireStorageItemSpecsInfoByIdResponse) ProtoMessage() {} -func (x *SearchResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[316] +func (x *RequireStorageItemSpecsInfoByIdResponse) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[317] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14937,96 +14754,129 @@ func (x *SearchResult) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use SearchResult.ProtoReflect.Descriptor instead. -func (*SearchResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{316} +// Deprecated: Use RequireStorageItemSpecsInfoByIdResponse.ProtoReflect.Descriptor instead. +func (*RequireStorageItemSpecsInfoByIdResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{317} } -func (x *SearchResult) GetValue() isSearchResult_Value { +func (x *RequireStorageItemSpecsInfoByIdResponse) GetResult() []*RequireStorageItemSpecsInfoByIdResult { if x != nil { - return x.Value + return x.Result } return nil } -func (x *SearchResult) GetProduct() *Product { - if x != nil { - if x, ok := x.Value.(*SearchResult_Product); ok { - return x.Product - } - } - return nil +type RequireStorageItemSpecsInfoByIdResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + ItemSpecsInfo string `protobuf:"bytes,1,opt,name=item_specs_info,json=itemSpecsInfo,proto3" json:"item_specs_info,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *SearchResult) GetUser() *User { +func (x *RequireStorageItemSpecsInfoByIdResult) Reset() { + *x = RequireStorageItemSpecsInfoByIdResult{} + mi := &file_product_proto_msgTypes[318] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireStorageItemSpecsInfoByIdResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageItemSpecsInfoByIdResult) ProtoMessage() {} + +func (x *RequireStorageItemSpecsInfoByIdResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[318] if x != nil { - if x, ok := x.Value.(*SearchResult_User); ok { - return x.User + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) } + return ms } - return nil + return mi.MessageOf(x) } -func (x *SearchResult) GetCategory() *Category { +// Deprecated: Use RequireStorageItemSpecsInfoByIdResult.ProtoReflect.Descriptor instead. +func (*RequireStorageItemSpecsInfoByIdResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{318} +} + +func (x *RequireStorageItemSpecsInfoByIdResult) GetItemSpecsInfo() string { if x != nil { - if x, ok := x.Value.(*SearchResult_Category); ok { - return x.Category - } + return x.ItemSpecsInfo } - return nil + return "" } -type isSearchResult_Value interface { - isSearchResult_Value() +type RequireStorageItemSpecsInfoByIdFields struct { + state protoimpl.MessageState `protogen:"open.v1"` + PrimaryItem *RequireStorageItemSpecsInfoByIdFields_StorageItem `protobuf:"bytes,1,opt,name=primary_item,json=primaryItem,proto3" json:"primary_item,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -type SearchResult_Product struct { - Product *Product `protobuf:"bytes,1,opt,name=product,proto3,oneof"` +func (x *RequireStorageItemSpecsInfoByIdFields) Reset() { + *x = RequireStorageItemSpecsInfoByIdFields{} + mi := &file_product_proto_msgTypes[319] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } -type SearchResult_User struct { - User *User `protobuf:"bytes,2,opt,name=user,proto3,oneof"` +func (x *RequireStorageItemSpecsInfoByIdFields) String() string { + return protoimpl.X.MessageStringOf(x) } -type SearchResult_Category struct { - Category *Category `protobuf:"bytes,3,opt,name=category,proto3,oneof"` -} +func (*RequireStorageItemSpecsInfoByIdFields) ProtoMessage() {} -func (*SearchResult_Product) isSearchResult_Value() {} +func (x *RequireStorageItemSpecsInfoByIdFields) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[319] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} -func (*SearchResult_User) isSearchResult_Value() {} +// Deprecated: Use RequireStorageItemSpecsInfoByIdFields.ProtoReflect.Descriptor instead. +func (*RequireStorageItemSpecsInfoByIdFields) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{319} +} -func (*SearchResult_Category) isSearchResult_Value() {} +func (x *RequireStorageItemSpecsInfoByIdFields) GetPrimaryItem() *RequireStorageItemSpecsInfoByIdFields_StorageItem { + if x != nil { + return x.PrimaryItem + } + return nil +} -type NullableFieldsType struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` - OptionalString *wrapperspb.StringValue `protobuf:"bytes,3,opt,name=optional_string,json=optionalString,proto3" json:"optional_string,omitempty"` - OptionalInt *wrapperspb.Int32Value `protobuf:"bytes,4,opt,name=optional_int,json=optionalInt,proto3" json:"optional_int,omitempty"` - OptionalFloat *wrapperspb.DoubleValue `protobuf:"bytes,5,opt,name=optional_float,json=optionalFloat,proto3" json:"optional_float,omitempty"` - OptionalBoolean *wrapperspb.BoolValue `protobuf:"bytes,6,opt,name=optional_boolean,json=optionalBoolean,proto3" json:"optional_boolean,omitempty"` - RequiredString string `protobuf:"bytes,7,opt,name=required_string,json=requiredString,proto3" json:"required_string,omitempty"` - RequiredInt int32 `protobuf:"varint,8,opt,name=required_int,json=requiredInt,proto3" json:"required_int,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type RequireStorageDeepItemInfoByIdRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // RequireStorageDeepItemInfoByIdContext provides the context for the required fields method RequireStorageDeepItemInfoById. + Context []*RequireStorageDeepItemInfoByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *NullableFieldsType) Reset() { - *x = NullableFieldsType{} - mi := &file_product_proto_msgTypes[317] +func (x *RequireStorageDeepItemInfoByIdRequest) Reset() { + *x = RequireStorageDeepItemInfoByIdRequest{} + mi := &file_product_proto_msgTypes[320] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *NullableFieldsType) String() string { +func (x *RequireStorageDeepItemInfoByIdRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*NullableFieldsType) ProtoMessage() {} +func (*RequireStorageDeepItemInfoByIdRequest) ProtoMessage() {} -func (x *NullableFieldsType) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[317] +func (x *RequireStorageDeepItemInfoByIdRequest) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[320] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15037,91 +14887,3719 @@ func (x *NullableFieldsType) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use NullableFieldsType.ProtoReflect.Descriptor instead. -func (*NullableFieldsType) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{317} +// Deprecated: Use RequireStorageDeepItemInfoByIdRequest.ProtoReflect.Descriptor instead. +func (*RequireStorageDeepItemInfoByIdRequest) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{320} } -func (x *NullableFieldsType) GetId() string { +func (x *RequireStorageDeepItemInfoByIdRequest) GetContext() []*RequireStorageDeepItemInfoByIdContext { if x != nil { - return x.Id + return x.Context } - return "" + return nil } -func (x *NullableFieldsType) GetName() string { - if x != nil { - return x.Name - } - return "" +type RequireStorageDeepItemInfoByIdContext struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Fields *RequireStorageDeepItemInfoByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *NullableFieldsType) GetOptionalString() *wrapperspb.StringValue { - if x != nil { - return x.OptionalString - } - return nil +func (x *RequireStorageDeepItemInfoByIdContext) Reset() { + *x = RequireStorageDeepItemInfoByIdContext{} + mi := &file_product_proto_msgTypes[321] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } -func (x *NullableFieldsType) GetOptionalInt() *wrapperspb.Int32Value { +func (x *RequireStorageDeepItemInfoByIdContext) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageDeepItemInfoByIdContext) ProtoMessage() {} + +func (x *RequireStorageDeepItemInfoByIdContext) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[321] if x != nil { - return x.OptionalInt + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms } - return nil + return mi.MessageOf(x) } -func (x *NullableFieldsType) GetOptionalFloat() *wrapperspb.DoubleValue { +// Deprecated: Use RequireStorageDeepItemInfoByIdContext.ProtoReflect.Descriptor instead. +func (*RequireStorageDeepItemInfoByIdContext) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{321} +} + +func (x *RequireStorageDeepItemInfoByIdContext) GetKey() *LookupStorageByIdRequestKey { if x != nil { - return x.OptionalFloat + return x.Key } return nil } -func (x *NullableFieldsType) GetOptionalBoolean() *wrapperspb.BoolValue { +func (x *RequireStorageDeepItemInfoByIdContext) GetFields() *RequireStorageDeepItemInfoByIdFields { if x != nil { - return x.OptionalBoolean + return x.Fields + } + return nil +} + +type RequireStorageDeepItemInfoByIdResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // RequireStorageDeepItemInfoByIdResult provides the result for the required fields method RequireStorageDeepItemInfoById. + Result []*RequireStorageDeepItemInfoByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RequireStorageDeepItemInfoByIdResponse) Reset() { + *x = RequireStorageDeepItemInfoByIdResponse{} + mi := &file_product_proto_msgTypes[322] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireStorageDeepItemInfoByIdResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageDeepItemInfoByIdResponse) ProtoMessage() {} + +func (x *RequireStorageDeepItemInfoByIdResponse) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[322] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RequireStorageDeepItemInfoByIdResponse.ProtoReflect.Descriptor instead. +func (*RequireStorageDeepItemInfoByIdResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{322} +} + +func (x *RequireStorageDeepItemInfoByIdResponse) GetResult() []*RequireStorageDeepItemInfoByIdResult { + if x != nil { + return x.Result + } + return nil +} + +type RequireStorageDeepItemInfoByIdResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + DeepItemInfo string `protobuf:"bytes,1,opt,name=deep_item_info,json=deepItemInfo,proto3" json:"deep_item_info,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RequireStorageDeepItemInfoByIdResult) Reset() { + *x = RequireStorageDeepItemInfoByIdResult{} + mi := &file_product_proto_msgTypes[323] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireStorageDeepItemInfoByIdResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageDeepItemInfoByIdResult) ProtoMessage() {} + +func (x *RequireStorageDeepItemInfoByIdResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[323] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RequireStorageDeepItemInfoByIdResult.ProtoReflect.Descriptor instead. +func (*RequireStorageDeepItemInfoByIdResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{323} +} + +func (x *RequireStorageDeepItemInfoByIdResult) GetDeepItemInfo() string { + if x != nil { + return x.DeepItemInfo + } + return "" +} + +type RequireStorageDeepItemInfoByIdFields struct { + state protoimpl.MessageState `protogen:"open.v1"` + PrimaryItem *RequireStorageDeepItemInfoByIdFields_StorageItem `protobuf:"bytes,1,opt,name=primary_item,json=primaryItem,proto3" json:"primary_item,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RequireStorageDeepItemInfoByIdFields) Reset() { + *x = RequireStorageDeepItemInfoByIdFields{} + mi := &file_product_proto_msgTypes[324] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireStorageDeepItemInfoByIdFields) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageDeepItemInfoByIdFields) ProtoMessage() {} + +func (x *RequireStorageDeepItemInfoByIdFields) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[324] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RequireStorageDeepItemInfoByIdFields.ProtoReflect.Descriptor instead. +func (*RequireStorageDeepItemInfoByIdFields) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{324} +} + +func (x *RequireStorageDeepItemInfoByIdFields) GetPrimaryItem() *RequireStorageDeepItemInfoByIdFields_StorageItem { + if x != nil { + return x.PrimaryItem + } + return nil +} + +type RequireWarehouseStockHealthScoreByIdRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // RequireWarehouseStockHealthScoreByIdContext provides the context for the required fields method RequireWarehouseStockHealthScoreById. + Context []*RequireWarehouseStockHealthScoreByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RequireWarehouseStockHealthScoreByIdRequest) Reset() { + *x = RequireWarehouseStockHealthScoreByIdRequest{} + mi := &file_product_proto_msgTypes[325] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireWarehouseStockHealthScoreByIdRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireWarehouseStockHealthScoreByIdRequest) ProtoMessage() {} + +func (x *RequireWarehouseStockHealthScoreByIdRequest) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[325] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RequireWarehouseStockHealthScoreByIdRequest.ProtoReflect.Descriptor instead. +func (*RequireWarehouseStockHealthScoreByIdRequest) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{325} +} + +func (x *RequireWarehouseStockHealthScoreByIdRequest) GetContext() []*RequireWarehouseStockHealthScoreByIdContext { + if x != nil { + return x.Context + } + return nil +} + +type RequireWarehouseStockHealthScoreByIdContext struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key *LookupWarehouseByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Fields *RequireWarehouseStockHealthScoreByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RequireWarehouseStockHealthScoreByIdContext) Reset() { + *x = RequireWarehouseStockHealthScoreByIdContext{} + mi := &file_product_proto_msgTypes[326] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireWarehouseStockHealthScoreByIdContext) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireWarehouseStockHealthScoreByIdContext) ProtoMessage() {} + +func (x *RequireWarehouseStockHealthScoreByIdContext) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[326] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RequireWarehouseStockHealthScoreByIdContext.ProtoReflect.Descriptor instead. +func (*RequireWarehouseStockHealthScoreByIdContext) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{326} +} + +func (x *RequireWarehouseStockHealthScoreByIdContext) GetKey() *LookupWarehouseByIdRequestKey { + if x != nil { + return x.Key + } + return nil +} + +func (x *RequireWarehouseStockHealthScoreByIdContext) GetFields() *RequireWarehouseStockHealthScoreByIdFields { + if x != nil { + return x.Fields + } + return nil +} + +type RequireWarehouseStockHealthScoreByIdResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // RequireWarehouseStockHealthScoreByIdResult provides the result for the required fields method RequireWarehouseStockHealthScoreById. + Result []*RequireWarehouseStockHealthScoreByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RequireWarehouseStockHealthScoreByIdResponse) Reset() { + *x = RequireWarehouseStockHealthScoreByIdResponse{} + mi := &file_product_proto_msgTypes[327] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireWarehouseStockHealthScoreByIdResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireWarehouseStockHealthScoreByIdResponse) ProtoMessage() {} + +func (x *RequireWarehouseStockHealthScoreByIdResponse) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[327] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RequireWarehouseStockHealthScoreByIdResponse.ProtoReflect.Descriptor instead. +func (*RequireWarehouseStockHealthScoreByIdResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{327} +} + +func (x *RequireWarehouseStockHealthScoreByIdResponse) GetResult() []*RequireWarehouseStockHealthScoreByIdResult { + if x != nil { + return x.Result + } + return nil +} + +type RequireWarehouseStockHealthScoreByIdResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + StockHealthScore float64 `protobuf:"fixed64,1,opt,name=stock_health_score,json=stockHealthScore,proto3" json:"stock_health_score,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RequireWarehouseStockHealthScoreByIdResult) Reset() { + *x = RequireWarehouseStockHealthScoreByIdResult{} + mi := &file_product_proto_msgTypes[328] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireWarehouseStockHealthScoreByIdResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireWarehouseStockHealthScoreByIdResult) ProtoMessage() {} + +func (x *RequireWarehouseStockHealthScoreByIdResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[328] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RequireWarehouseStockHealthScoreByIdResult.ProtoReflect.Descriptor instead. +func (*RequireWarehouseStockHealthScoreByIdResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{328} +} + +func (x *RequireWarehouseStockHealthScoreByIdResult) GetStockHealthScore() float64 { + if x != nil { + return x.StockHealthScore + } + return 0 +} + +type RequireWarehouseStockHealthScoreByIdFields struct { + state protoimpl.MessageState `protogen:"open.v1"` + InventoryCount int32 `protobuf:"varint,1,opt,name=inventory_count,json=inventoryCount,proto3" json:"inventory_count,omitempty"` + RestockData *RequireWarehouseStockHealthScoreByIdFields_RestockData `protobuf:"bytes,2,opt,name=restock_data,json=restockData,proto3" json:"restock_data,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RequireWarehouseStockHealthScoreByIdFields) Reset() { + *x = RequireWarehouseStockHealthScoreByIdFields{} + mi := &file_product_proto_msgTypes[329] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireWarehouseStockHealthScoreByIdFields) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireWarehouseStockHealthScoreByIdFields) ProtoMessage() {} + +func (x *RequireWarehouseStockHealthScoreByIdFields) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[329] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RequireWarehouseStockHealthScoreByIdFields.ProtoReflect.Descriptor instead. +func (*RequireWarehouseStockHealthScoreByIdFields) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{329} +} + +func (x *RequireWarehouseStockHealthScoreByIdFields) GetInventoryCount() int32 { + if x != nil { + return x.InventoryCount + } + return 0 +} + +func (x *RequireWarehouseStockHealthScoreByIdFields) GetRestockData() *RequireWarehouseStockHealthScoreByIdFields_RestockData { + if x != nil { + return x.RestockData + } + return nil +} + +type Product struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + Price float64 `protobuf:"fixed64,3,opt,name=price,proto3" json:"price,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *Product) Reset() { + *x = Product{} + mi := &file_product_proto_msgTypes[330] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *Product) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Product) ProtoMessage() {} + +func (x *Product) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[330] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Product.ProtoReflect.Descriptor instead. +func (*Product) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{330} +} + +func (x *Product) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *Product) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *Product) GetPrice() float64 { + if x != nil { + return x.Price + } + return 0 +} + +type Storage struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + Location string `protobuf:"bytes,3,opt,name=location,proto3" json:"location,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *Storage) Reset() { + *x = Storage{} + mi := &file_product_proto_msgTypes[331] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *Storage) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Storage) ProtoMessage() {} + +func (x *Storage) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[331] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Storage.ProtoReflect.Descriptor instead. +func (*Storage) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{331} +} + +func (x *Storage) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *Storage) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *Storage) GetLocation() string { + if x != nil { + return x.Location + } + return "" +} + +type Warehouse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + Location string `protobuf:"bytes,3,opt,name=location,proto3" json:"location,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *Warehouse) Reset() { + *x = Warehouse{} + mi := &file_product_proto_msgTypes[332] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *Warehouse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Warehouse) ProtoMessage() {} + +func (x *Warehouse) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[332] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Warehouse.ProtoReflect.Descriptor instead. +func (*Warehouse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{332} +} + +func (x *Warehouse) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *Warehouse) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *Warehouse) GetLocation() string { + if x != nil { + return x.Location + } + return "" +} + +type User struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *User) Reset() { + *x = User{} + mi := &file_product_proto_msgTypes[333] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *User) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*User) ProtoMessage() {} + +func (x *User) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[333] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use User.ProtoReflect.Descriptor instead. +func (*User) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{333} +} + +func (x *User) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *User) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +type NestedTypeA struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + B *NestedTypeB `protobuf:"bytes,3,opt,name=b,proto3" json:"b,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *NestedTypeA) Reset() { + *x = NestedTypeA{} + mi := &file_product_proto_msgTypes[334] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *NestedTypeA) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*NestedTypeA) ProtoMessage() {} + +func (x *NestedTypeA) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[334] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use NestedTypeA.ProtoReflect.Descriptor instead. +func (*NestedTypeA) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{334} +} + +func (x *NestedTypeA) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *NestedTypeA) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *NestedTypeA) GetB() *NestedTypeB { + if x != nil { + return x.B + } + return nil +} + +type RecursiveType struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + RecursiveType *RecursiveType `protobuf:"bytes,3,opt,name=recursive_type,json=recursiveType,proto3" json:"recursive_type,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RecursiveType) Reset() { + *x = RecursiveType{} + mi := &file_product_proto_msgTypes[335] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RecursiveType) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RecursiveType) ProtoMessage() {} + +func (x *RecursiveType) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[335] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RecursiveType.ProtoReflect.Descriptor instead. +func (*RecursiveType) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{335} +} + +func (x *RecursiveType) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *RecursiveType) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *RecursiveType) GetRecursiveType() *RecursiveType { + if x != nil { + return x.RecursiveType + } + return nil +} + +type TypeWithMultipleFilterFields struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + FilterField_1 string `protobuf:"bytes,3,opt,name=filter_field_1,json=filterField1,proto3" json:"filter_field_1,omitempty"` + FilterField_2 string `protobuf:"bytes,4,opt,name=filter_field_2,json=filterField2,proto3" json:"filter_field_2,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *TypeWithMultipleFilterFields) Reset() { + *x = TypeWithMultipleFilterFields{} + mi := &file_product_proto_msgTypes[336] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *TypeWithMultipleFilterFields) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TypeWithMultipleFilterFields) ProtoMessage() {} + +func (x *TypeWithMultipleFilterFields) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[336] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TypeWithMultipleFilterFields.ProtoReflect.Descriptor instead. +func (*TypeWithMultipleFilterFields) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{336} +} + +func (x *TypeWithMultipleFilterFields) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *TypeWithMultipleFilterFields) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *TypeWithMultipleFilterFields) GetFilterField_1() string { + if x != nil { + return x.FilterField_1 + } + return "" +} + +func (x *TypeWithMultipleFilterFields) GetFilterField_2() string { + if x != nil { + return x.FilterField_2 + } + return "" +} + +type FilterTypeInput struct { + state protoimpl.MessageState `protogen:"open.v1"` + FilterField_1 string `protobuf:"bytes,1,opt,name=filter_field_1,json=filterField1,proto3" json:"filter_field_1,omitempty"` + FilterField_2 string `protobuf:"bytes,2,opt,name=filter_field_2,json=filterField2,proto3" json:"filter_field_2,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *FilterTypeInput) Reset() { + *x = FilterTypeInput{} + mi := &file_product_proto_msgTypes[337] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *FilterTypeInput) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FilterTypeInput) ProtoMessage() {} + +func (x *FilterTypeInput) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[337] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use FilterTypeInput.ProtoReflect.Descriptor instead. +func (*FilterTypeInput) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{337} +} + +func (x *FilterTypeInput) GetFilterField_1() string { + if x != nil { + return x.FilterField_1 + } + return "" +} + +func (x *FilterTypeInput) GetFilterField_2() string { + if x != nil { + return x.FilterField_2 + } + return "" +} + +type ComplexFilterTypeInput struct { + state protoimpl.MessageState `protogen:"open.v1"` + Filter *FilterType `protobuf:"bytes,1,opt,name=filter,proto3" json:"filter,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ComplexFilterTypeInput) Reset() { + *x = ComplexFilterTypeInput{} + mi := &file_product_proto_msgTypes[338] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ComplexFilterTypeInput) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ComplexFilterTypeInput) ProtoMessage() {} + +func (x *ComplexFilterTypeInput) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[338] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ComplexFilterTypeInput.ProtoReflect.Descriptor instead. +func (*ComplexFilterTypeInput) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{338} +} + +func (x *ComplexFilterTypeInput) GetFilter() *FilterType { + if x != nil { + return x.Filter + } + return nil +} + +type TypeWithComplexFilterInput struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *TypeWithComplexFilterInput) Reset() { + *x = TypeWithComplexFilterInput{} + mi := &file_product_proto_msgTypes[339] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *TypeWithComplexFilterInput) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TypeWithComplexFilterInput) ProtoMessage() {} + +func (x *TypeWithComplexFilterInput) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[339] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TypeWithComplexFilterInput.ProtoReflect.Descriptor instead. +func (*TypeWithComplexFilterInput) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{339} +} + +func (x *TypeWithComplexFilterInput) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *TypeWithComplexFilterInput) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +type OrderInput struct { + state protoimpl.MessageState `protogen:"open.v1"` + OrderId string `protobuf:"bytes,1,opt,name=order_id,json=orderId,proto3" json:"order_id,omitempty"` + CustomerName string `protobuf:"bytes,2,opt,name=customer_name,json=customerName,proto3" json:"customer_name,omitempty"` + Lines []*OrderLineInput `protobuf:"bytes,3,rep,name=lines,proto3" json:"lines,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *OrderInput) Reset() { + *x = OrderInput{} + mi := &file_product_proto_msgTypes[340] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *OrderInput) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*OrderInput) ProtoMessage() {} + +func (x *OrderInput) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[340] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use OrderInput.ProtoReflect.Descriptor instead. +func (*OrderInput) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{340} +} + +func (x *OrderInput) GetOrderId() string { + if x != nil { + return x.OrderId + } + return "" +} + +func (x *OrderInput) GetCustomerName() string { + if x != nil { + return x.CustomerName + } + return "" +} + +func (x *OrderInput) GetLines() []*OrderLineInput { + if x != nil { + return x.Lines + } + return nil +} + +type Order struct { + state protoimpl.MessageState `protogen:"open.v1"` + OrderId string `protobuf:"bytes,1,opt,name=order_id,json=orderId,proto3" json:"order_id,omitempty"` + CustomerName string `protobuf:"bytes,2,opt,name=customer_name,json=customerName,proto3" json:"customer_name,omitempty"` + TotalItems int32 `protobuf:"varint,3,opt,name=total_items,json=totalItems,proto3" json:"total_items,omitempty"` + OrderLines *ListOfOrderLine `protobuf:"bytes,4,opt,name=order_lines,json=orderLines,proto3" json:"order_lines,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *Order) Reset() { + *x = Order{} + mi := &file_product_proto_msgTypes[341] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *Order) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Order) ProtoMessage() {} + +func (x *Order) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[341] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Order.ProtoReflect.Descriptor instead. +func (*Order) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{341} +} + +func (x *Order) GetOrderId() string { + if x != nil { + return x.OrderId + } + return "" +} + +func (x *Order) GetCustomerName() string { + if x != nil { + return x.CustomerName + } + return "" +} + +func (x *Order) GetTotalItems() int32 { + if x != nil { + return x.TotalItems + } + return 0 +} + +func (x *Order) GetOrderLines() *ListOfOrderLine { + if x != nil { + return x.OrderLines + } + return nil +} + +type Category struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + Kind CategoryKind `protobuf:"varint,3,opt,name=kind,proto3,enum=productv1.CategoryKind" json:"kind,omitempty"` + Subcategories *ListOfSubcategory `protobuf:"bytes,4,opt,name=subcategories,proto3" json:"subcategories,omitempty"` + NullMetrics *CategoryMetrics `protobuf:"bytes,5,opt,name=null_metrics,json=nullMetrics,proto3" json:"null_metrics,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *Category) Reset() { + *x = Category{} + mi := &file_product_proto_msgTypes[342] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *Category) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Category) ProtoMessage() {} + +func (x *Category) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[342] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Category.ProtoReflect.Descriptor instead. +func (*Category) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{342} +} + +func (x *Category) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *Category) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *Category) GetKind() CategoryKind { + if x != nil { + return x.Kind + } + return CategoryKind_CATEGORY_KIND_UNSPECIFIED +} + +func (x *Category) GetSubcategories() *ListOfSubcategory { + if x != nil { + return x.Subcategories + } + return nil +} + +func (x *Category) GetNullMetrics() *CategoryMetrics { + if x != nil { + return x.NullMetrics + } + return nil +} + +type CategoryFilter struct { + state protoimpl.MessageState `protogen:"open.v1"` + Category CategoryKind `protobuf:"varint,1,opt,name=category,proto3,enum=productv1.CategoryKind" json:"category,omitempty"` + Pagination *Pagination `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *CategoryFilter) Reset() { + *x = CategoryFilter{} + mi := &file_product_proto_msgTypes[343] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *CategoryFilter) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CategoryFilter) ProtoMessage() {} + +func (x *CategoryFilter) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[343] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CategoryFilter.ProtoReflect.Descriptor instead. +func (*CategoryFilter) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{343} +} + +func (x *CategoryFilter) GetCategory() CategoryKind { + if x != nil { + return x.Category + } + return CategoryKind_CATEGORY_KIND_UNSPECIFIED +} + +func (x *CategoryFilter) GetPagination() *Pagination { + if x != nil { + return x.Pagination + } + return nil +} + +type Animal struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Types that are valid to be assigned to Instance: + // + // *Animal_Cat + // *Animal_Dog + Instance isAnimal_Instance `protobuf_oneof:"instance"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *Animal) Reset() { + *x = Animal{} + mi := &file_product_proto_msgTypes[344] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *Animal) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Animal) ProtoMessage() {} + +func (x *Animal) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[344] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Animal.ProtoReflect.Descriptor instead. +func (*Animal) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{344} +} + +func (x *Animal) GetInstance() isAnimal_Instance { + if x != nil { + return x.Instance + } + return nil +} + +func (x *Animal) GetCat() *Cat { + if x != nil { + if x, ok := x.Instance.(*Animal_Cat); ok { + return x.Cat + } + } + return nil +} + +func (x *Animal) GetDog() *Dog { + if x != nil { + if x, ok := x.Instance.(*Animal_Dog); ok { + return x.Dog + } + } + return nil +} + +type isAnimal_Instance interface { + isAnimal_Instance() +} + +type Animal_Cat struct { + Cat *Cat `protobuf:"bytes,1,opt,name=cat,proto3,oneof"` +} + +type Animal_Dog struct { + Dog *Dog `protobuf:"bytes,2,opt,name=dog,proto3,oneof"` +} + +func (*Animal_Cat) isAnimal_Instance() {} + +func (*Animal_Dog) isAnimal_Instance() {} + +type SearchInput struct { + state protoimpl.MessageState `protogen:"open.v1"` + Query string `protobuf:"bytes,1,opt,name=query,proto3" json:"query,omitempty"` + Limit *wrapperspb.Int32Value `protobuf:"bytes,2,opt,name=limit,proto3" json:"limit,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SearchInput) Reset() { + *x = SearchInput{} + mi := &file_product_proto_msgTypes[345] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SearchInput) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SearchInput) ProtoMessage() {} + +func (x *SearchInput) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[345] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SearchInput.ProtoReflect.Descriptor instead. +func (*SearchInput) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{345} +} + +func (x *SearchInput) GetQuery() string { + if x != nil { + return x.Query + } + return "" +} + +func (x *SearchInput) GetLimit() *wrapperspb.Int32Value { + if x != nil { + return x.Limit + } + return nil +} + +type SearchResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Types that are valid to be assigned to Value: + // + // *SearchResult_Product + // *SearchResult_User + // *SearchResult_Category + Value isSearchResult_Value `protobuf_oneof:"value"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SearchResult) Reset() { + *x = SearchResult{} + mi := &file_product_proto_msgTypes[346] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SearchResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SearchResult) ProtoMessage() {} + +func (x *SearchResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[346] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SearchResult.ProtoReflect.Descriptor instead. +func (*SearchResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{346} +} + +func (x *SearchResult) GetValue() isSearchResult_Value { + if x != nil { + return x.Value + } + return nil +} + +func (x *SearchResult) GetProduct() *Product { + if x != nil { + if x, ok := x.Value.(*SearchResult_Product); ok { + return x.Product + } + } + return nil +} + +func (x *SearchResult) GetUser() *User { + if x != nil { + if x, ok := x.Value.(*SearchResult_User); ok { + return x.User + } + } + return nil +} + +func (x *SearchResult) GetCategory() *Category { + if x != nil { + if x, ok := x.Value.(*SearchResult_Category); ok { + return x.Category + } + } + return nil +} + +type isSearchResult_Value interface { + isSearchResult_Value() +} + +type SearchResult_Product struct { + Product *Product `protobuf:"bytes,1,opt,name=product,proto3,oneof"` +} + +type SearchResult_User struct { + User *User `protobuf:"bytes,2,opt,name=user,proto3,oneof"` +} + +type SearchResult_Category struct { + Category *Category `protobuf:"bytes,3,opt,name=category,proto3,oneof"` +} + +func (*SearchResult_Product) isSearchResult_Value() {} + +func (*SearchResult_User) isSearchResult_Value() {} + +func (*SearchResult_Category) isSearchResult_Value() {} + +type NullableFieldsType struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + OptionalString *wrapperspb.StringValue `protobuf:"bytes,3,opt,name=optional_string,json=optionalString,proto3" json:"optional_string,omitempty"` + OptionalInt *wrapperspb.Int32Value `protobuf:"bytes,4,opt,name=optional_int,json=optionalInt,proto3" json:"optional_int,omitempty"` + OptionalFloat *wrapperspb.DoubleValue `protobuf:"bytes,5,opt,name=optional_float,json=optionalFloat,proto3" json:"optional_float,omitempty"` + OptionalBoolean *wrapperspb.BoolValue `protobuf:"bytes,6,opt,name=optional_boolean,json=optionalBoolean,proto3" json:"optional_boolean,omitempty"` + RequiredString string `protobuf:"bytes,7,opt,name=required_string,json=requiredString,proto3" json:"required_string,omitempty"` + RequiredInt int32 `protobuf:"varint,8,opt,name=required_int,json=requiredInt,proto3" json:"required_int,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *NullableFieldsType) Reset() { + *x = NullableFieldsType{} + mi := &file_product_proto_msgTypes[347] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *NullableFieldsType) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*NullableFieldsType) ProtoMessage() {} + +func (x *NullableFieldsType) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[347] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use NullableFieldsType.ProtoReflect.Descriptor instead. +func (*NullableFieldsType) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{347} +} + +func (x *NullableFieldsType) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *NullableFieldsType) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *NullableFieldsType) GetOptionalString() *wrapperspb.StringValue { + if x != nil { + return x.OptionalString + } + return nil +} + +func (x *NullableFieldsType) GetOptionalInt() *wrapperspb.Int32Value { + if x != nil { + return x.OptionalInt + } + return nil +} + +func (x *NullableFieldsType) GetOptionalFloat() *wrapperspb.DoubleValue { + if x != nil { + return x.OptionalFloat + } + return nil +} + +func (x *NullableFieldsType) GetOptionalBoolean() *wrapperspb.BoolValue { + if x != nil { + return x.OptionalBoolean } return nil } func (x *NullableFieldsType) GetRequiredString() string { if x != nil { - return x.RequiredString + return x.RequiredString + } + return "" +} + +func (x *NullableFieldsType) GetRequiredInt() int32 { + if x != nil { + return x.RequiredInt + } + return 0 +} + +type NullableFieldsFilter struct { + state protoimpl.MessageState `protogen:"open.v1"` + Name *wrapperspb.StringValue `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + OptionalString *wrapperspb.StringValue `protobuf:"bytes,2,opt,name=optional_string,json=optionalString,proto3" json:"optional_string,omitempty"` + IncludeNulls *wrapperspb.BoolValue `protobuf:"bytes,3,opt,name=include_nulls,json=includeNulls,proto3" json:"include_nulls,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *NullableFieldsFilter) Reset() { + *x = NullableFieldsFilter{} + mi := &file_product_proto_msgTypes[348] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *NullableFieldsFilter) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*NullableFieldsFilter) ProtoMessage() {} + +func (x *NullableFieldsFilter) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[348] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use NullableFieldsFilter.ProtoReflect.Descriptor instead. +func (*NullableFieldsFilter) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{348} +} + +func (x *NullableFieldsFilter) GetName() *wrapperspb.StringValue { + if x != nil { + return x.Name + } + return nil +} + +func (x *NullableFieldsFilter) GetOptionalString() *wrapperspb.StringValue { + if x != nil { + return x.OptionalString + } + return nil +} + +func (x *NullableFieldsFilter) GetIncludeNulls() *wrapperspb.BoolValue { + if x != nil { + return x.IncludeNulls + } + return nil +} + +type BlogPost struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Title string `protobuf:"bytes,2,opt,name=title,proto3" json:"title,omitempty"` + Content string `protobuf:"bytes,3,opt,name=content,proto3" json:"content,omitempty"` + Tags []string `protobuf:"bytes,4,rep,name=tags,proto3" json:"tags,omitempty"` + OptionalTags *ListOfString `protobuf:"bytes,5,opt,name=optional_tags,json=optionalTags,proto3" json:"optional_tags,omitempty"` + Categories []string `protobuf:"bytes,6,rep,name=categories,proto3" json:"categories,omitempty"` + Keywords *ListOfString `protobuf:"bytes,7,opt,name=keywords,proto3" json:"keywords,omitempty"` + ViewCounts []int32 `protobuf:"varint,8,rep,packed,name=view_counts,json=viewCounts,proto3" json:"view_counts,omitempty"` + Ratings *ListOfFloat `protobuf:"bytes,9,opt,name=ratings,proto3" json:"ratings,omitempty"` + IsPublished *ListOfBoolean `protobuf:"bytes,10,opt,name=is_published,json=isPublished,proto3" json:"is_published,omitempty"` + TagGroups *ListOfListOfString `protobuf:"bytes,11,opt,name=tag_groups,json=tagGroups,proto3" json:"tag_groups,omitempty"` + RelatedTopics *ListOfListOfString `protobuf:"bytes,12,opt,name=related_topics,json=relatedTopics,proto3" json:"related_topics,omitempty"` + CommentThreads *ListOfListOfString `protobuf:"bytes,13,opt,name=comment_threads,json=commentThreads,proto3" json:"comment_threads,omitempty"` + Suggestions *ListOfListOfString `protobuf:"bytes,14,opt,name=suggestions,proto3" json:"suggestions,omitempty"` + RelatedCategories []*Category `protobuf:"bytes,15,rep,name=related_categories,json=relatedCategories,proto3" json:"related_categories,omitempty"` + Contributors []*User `protobuf:"bytes,16,rep,name=contributors,proto3" json:"contributors,omitempty"` + MentionedProducts *ListOfProduct `protobuf:"bytes,17,opt,name=mentioned_products,json=mentionedProducts,proto3" json:"mentioned_products,omitempty"` + MentionedUsers *ListOfUser `protobuf:"bytes,18,opt,name=mentioned_users,json=mentionedUsers,proto3" json:"mentioned_users,omitempty"` + CategoryGroups *ListOfListOfCategory `protobuf:"bytes,19,opt,name=category_groups,json=categoryGroups,proto3" json:"category_groups,omitempty"` + ContributorTeams *ListOfListOfUser `protobuf:"bytes,20,opt,name=contributor_teams,json=contributorTeams,proto3" json:"contributor_teams,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *BlogPost) Reset() { + *x = BlogPost{} + mi := &file_product_proto_msgTypes[349] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *BlogPost) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*BlogPost) ProtoMessage() {} + +func (x *BlogPost) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[349] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use BlogPost.ProtoReflect.Descriptor instead. +func (*BlogPost) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{349} +} + +func (x *BlogPost) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *BlogPost) GetTitle() string { + if x != nil { + return x.Title + } + return "" +} + +func (x *BlogPost) GetContent() string { + if x != nil { + return x.Content + } + return "" +} + +func (x *BlogPost) GetTags() []string { + if x != nil { + return x.Tags + } + return nil +} + +func (x *BlogPost) GetOptionalTags() *ListOfString { + if x != nil { + return x.OptionalTags + } + return nil +} + +func (x *BlogPost) GetCategories() []string { + if x != nil { + return x.Categories + } + return nil +} + +func (x *BlogPost) GetKeywords() *ListOfString { + if x != nil { + return x.Keywords + } + return nil +} + +func (x *BlogPost) GetViewCounts() []int32 { + if x != nil { + return x.ViewCounts + } + return nil +} + +func (x *BlogPost) GetRatings() *ListOfFloat { + if x != nil { + return x.Ratings + } + return nil +} + +func (x *BlogPost) GetIsPublished() *ListOfBoolean { + if x != nil { + return x.IsPublished + } + return nil +} + +func (x *BlogPost) GetTagGroups() *ListOfListOfString { + if x != nil { + return x.TagGroups + } + return nil +} + +func (x *BlogPost) GetRelatedTopics() *ListOfListOfString { + if x != nil { + return x.RelatedTopics + } + return nil +} + +func (x *BlogPost) GetCommentThreads() *ListOfListOfString { + if x != nil { + return x.CommentThreads + } + return nil +} + +func (x *BlogPost) GetSuggestions() *ListOfListOfString { + if x != nil { + return x.Suggestions + } + return nil +} + +func (x *BlogPost) GetRelatedCategories() []*Category { + if x != nil { + return x.RelatedCategories + } + return nil +} + +func (x *BlogPost) GetContributors() []*User { + if x != nil { + return x.Contributors + } + return nil +} + +func (x *BlogPost) GetMentionedProducts() *ListOfProduct { + if x != nil { + return x.MentionedProducts + } + return nil +} + +func (x *BlogPost) GetMentionedUsers() *ListOfUser { + if x != nil { + return x.MentionedUsers + } + return nil +} + +func (x *BlogPost) GetCategoryGroups() *ListOfListOfCategory { + if x != nil { + return x.CategoryGroups + } + return nil +} + +func (x *BlogPost) GetContributorTeams() *ListOfListOfUser { + if x != nil { + return x.ContributorTeams + } + return nil +} + +type BlogPostFilter struct { + state protoimpl.MessageState `protogen:"open.v1"` + Title *wrapperspb.StringValue `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"` + HasCategories *wrapperspb.BoolValue `protobuf:"bytes,2,opt,name=has_categories,json=hasCategories,proto3" json:"has_categories,omitempty"` + MinTags *wrapperspb.Int32Value `protobuf:"bytes,3,opt,name=min_tags,json=minTags,proto3" json:"min_tags,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *BlogPostFilter) Reset() { + *x = BlogPostFilter{} + mi := &file_product_proto_msgTypes[350] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *BlogPostFilter) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*BlogPostFilter) ProtoMessage() {} + +func (x *BlogPostFilter) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[350] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use BlogPostFilter.ProtoReflect.Descriptor instead. +func (*BlogPostFilter) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{350} +} + +func (x *BlogPostFilter) GetTitle() *wrapperspb.StringValue { + if x != nil { + return x.Title + } + return nil +} + +func (x *BlogPostFilter) GetHasCategories() *wrapperspb.BoolValue { + if x != nil { + return x.HasCategories + } + return nil +} + +func (x *BlogPostFilter) GetMinTags() *wrapperspb.Int32Value { + if x != nil { + return x.MinTags + } + return nil +} + +type Author struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + Email *wrapperspb.StringValue `protobuf:"bytes,3,opt,name=email,proto3" json:"email,omitempty"` + Skills []string `protobuf:"bytes,4,rep,name=skills,proto3" json:"skills,omitempty"` + Languages []string `protobuf:"bytes,5,rep,name=languages,proto3" json:"languages,omitempty"` + SocialLinks *ListOfString `protobuf:"bytes,6,opt,name=social_links,json=socialLinks,proto3" json:"social_links,omitempty"` + TeamsByProject *ListOfListOfString `protobuf:"bytes,7,opt,name=teams_by_project,json=teamsByProject,proto3" json:"teams_by_project,omitempty"` + Collaborations *ListOfListOfString `protobuf:"bytes,8,opt,name=collaborations,proto3" json:"collaborations,omitempty"` + WrittenPosts *ListOfBlogPost `protobuf:"bytes,9,opt,name=written_posts,json=writtenPosts,proto3" json:"written_posts,omitempty"` + FavoriteCategories []*Category `protobuf:"bytes,10,rep,name=favorite_categories,json=favoriteCategories,proto3" json:"favorite_categories,omitempty"` + RelatedAuthors *ListOfUser `protobuf:"bytes,11,opt,name=related_authors,json=relatedAuthors,proto3" json:"related_authors,omitempty"` + ProductReviews *ListOfProduct `protobuf:"bytes,12,opt,name=product_reviews,json=productReviews,proto3" json:"product_reviews,omitempty"` + AuthorGroups *ListOfListOfUser `protobuf:"bytes,13,opt,name=author_groups,json=authorGroups,proto3" json:"author_groups,omitempty"` + CategoryPreferences *ListOfListOfCategory `protobuf:"bytes,14,opt,name=category_preferences,json=categoryPreferences,proto3" json:"category_preferences,omitempty"` + ProjectTeams *ListOfListOfUser `protobuf:"bytes,15,opt,name=project_teams,json=projectTeams,proto3" json:"project_teams,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *Author) Reset() { + *x = Author{} + mi := &file_product_proto_msgTypes[351] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *Author) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Author) ProtoMessage() {} + +func (x *Author) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[351] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Author.ProtoReflect.Descriptor instead. +func (*Author) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{351} +} + +func (x *Author) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *Author) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *Author) GetEmail() *wrapperspb.StringValue { + if x != nil { + return x.Email + } + return nil +} + +func (x *Author) GetSkills() []string { + if x != nil { + return x.Skills + } + return nil +} + +func (x *Author) GetLanguages() []string { + if x != nil { + return x.Languages + } + return nil +} + +func (x *Author) GetSocialLinks() *ListOfString { + if x != nil { + return x.SocialLinks + } + return nil +} + +func (x *Author) GetTeamsByProject() *ListOfListOfString { + if x != nil { + return x.TeamsByProject + } + return nil +} + +func (x *Author) GetCollaborations() *ListOfListOfString { + if x != nil { + return x.Collaborations + } + return nil +} + +func (x *Author) GetWrittenPosts() *ListOfBlogPost { + if x != nil { + return x.WrittenPosts + } + return nil +} + +func (x *Author) GetFavoriteCategories() []*Category { + if x != nil { + return x.FavoriteCategories + } + return nil +} + +func (x *Author) GetRelatedAuthors() *ListOfUser { + if x != nil { + return x.RelatedAuthors + } + return nil +} + +func (x *Author) GetProductReviews() *ListOfProduct { + if x != nil { + return x.ProductReviews + } + return nil +} + +func (x *Author) GetAuthorGroups() *ListOfListOfUser { + if x != nil { + return x.AuthorGroups + } + return nil +} + +func (x *Author) GetCategoryPreferences() *ListOfListOfCategory { + if x != nil { + return x.CategoryPreferences + } + return nil +} + +func (x *Author) GetProjectTeams() *ListOfListOfUser { + if x != nil { + return x.ProjectTeams + } + return nil +} + +type AuthorFilter struct { + state protoimpl.MessageState `protogen:"open.v1"` + Name *wrapperspb.StringValue `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + HasTeams *wrapperspb.BoolValue `protobuf:"bytes,2,opt,name=has_teams,json=hasTeams,proto3" json:"has_teams,omitempty"` + SkillCount *wrapperspb.Int32Value `protobuf:"bytes,3,opt,name=skill_count,json=skillCount,proto3" json:"skill_count,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *AuthorFilter) Reset() { + *x = AuthorFilter{} + mi := &file_product_proto_msgTypes[352] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *AuthorFilter) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AuthorFilter) ProtoMessage() {} + +func (x *AuthorFilter) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[352] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AuthorFilter.ProtoReflect.Descriptor instead. +func (*AuthorFilter) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{352} +} + +func (x *AuthorFilter) GetName() *wrapperspb.StringValue { + if x != nil { + return x.Name + } + return nil +} + +func (x *AuthorFilter) GetHasTeams() *wrapperspb.BoolValue { + if x != nil { + return x.HasTeams + } + return nil +} + +func (x *AuthorFilter) GetSkillCount() *wrapperspb.Int32Value { + if x != nil { + return x.SkillCount + } + return nil +} + +type TestContainer struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + Description *wrapperspb.StringValue `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *TestContainer) Reset() { + *x = TestContainer{} + mi := &file_product_proto_msgTypes[353] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *TestContainer) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TestContainer) ProtoMessage() {} + +func (x *TestContainer) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[353] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TestContainer.ProtoReflect.Descriptor instead. +func (*TestContainer) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{353} +} + +func (x *TestContainer) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *TestContainer) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *TestContainer) GetDescription() *wrapperspb.StringValue { + if x != nil { + return x.Description + } + return nil +} + +type UserInput struct { + state protoimpl.MessageState `protogen:"open.v1"` + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *UserInput) Reset() { + *x = UserInput{} + mi := &file_product_proto_msgTypes[354] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *UserInput) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UserInput) ProtoMessage() {} + +func (x *UserInput) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[354] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UserInput.ProtoReflect.Descriptor instead. +func (*UserInput) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{354} +} + +func (x *UserInput) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +type ActionInput struct { + state protoimpl.MessageState `protogen:"open.v1"` + Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` + Payload string `protobuf:"bytes,2,opt,name=payload,proto3" json:"payload,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ActionInput) Reset() { + *x = ActionInput{} + mi := &file_product_proto_msgTypes[355] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ActionInput) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ActionInput) ProtoMessage() {} + +func (x *ActionInput) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[355] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ActionInput.ProtoReflect.Descriptor instead. +func (*ActionInput) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{355} +} + +func (x *ActionInput) GetType() string { + if x != nil { + return x.Type + } + return "" +} + +func (x *ActionInput) GetPayload() string { + if x != nil { + return x.Payload + } + return "" +} + +type ActionResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Types that are valid to be assigned to Value: + // + // *ActionResult_ActionSuccess + // *ActionResult_ActionError + Value isActionResult_Value `protobuf_oneof:"value"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ActionResult) Reset() { + *x = ActionResult{} + mi := &file_product_proto_msgTypes[356] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ActionResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ActionResult) ProtoMessage() {} + +func (x *ActionResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[356] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ActionResult.ProtoReflect.Descriptor instead. +func (*ActionResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{356} +} + +func (x *ActionResult) GetValue() isActionResult_Value { + if x != nil { + return x.Value + } + return nil +} + +func (x *ActionResult) GetActionSuccess() *ActionSuccess { + if x != nil { + if x, ok := x.Value.(*ActionResult_ActionSuccess); ok { + return x.ActionSuccess + } + } + return nil +} + +func (x *ActionResult) GetActionError() *ActionError { + if x != nil { + if x, ok := x.Value.(*ActionResult_ActionError); ok { + return x.ActionError + } + } + return nil +} + +type isActionResult_Value interface { + isActionResult_Value() +} + +type ActionResult_ActionSuccess struct { + ActionSuccess *ActionSuccess `protobuf:"bytes,1,opt,name=action_success,json=actionSuccess,proto3,oneof"` +} + +type ActionResult_ActionError struct { + ActionError *ActionError `protobuf:"bytes,2,opt,name=action_error,json=actionError,proto3,oneof"` +} + +func (*ActionResult_ActionSuccess) isActionResult_Value() {} + +func (*ActionResult_ActionError) isActionResult_Value() {} + +type NullableFieldsInput struct { + state protoimpl.MessageState `protogen:"open.v1"` + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + OptionalString *wrapperspb.StringValue `protobuf:"bytes,2,opt,name=optional_string,json=optionalString,proto3" json:"optional_string,omitempty"` + OptionalInt *wrapperspb.Int32Value `protobuf:"bytes,3,opt,name=optional_int,json=optionalInt,proto3" json:"optional_int,omitempty"` + OptionalFloat *wrapperspb.DoubleValue `protobuf:"bytes,4,opt,name=optional_float,json=optionalFloat,proto3" json:"optional_float,omitempty"` + OptionalBoolean *wrapperspb.BoolValue `protobuf:"bytes,5,opt,name=optional_boolean,json=optionalBoolean,proto3" json:"optional_boolean,omitempty"` + RequiredString string `protobuf:"bytes,6,opt,name=required_string,json=requiredString,proto3" json:"required_string,omitempty"` + RequiredInt int32 `protobuf:"varint,7,opt,name=required_int,json=requiredInt,proto3" json:"required_int,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *NullableFieldsInput) Reset() { + *x = NullableFieldsInput{} + mi := &file_product_proto_msgTypes[357] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *NullableFieldsInput) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*NullableFieldsInput) ProtoMessage() {} + +func (x *NullableFieldsInput) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[357] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use NullableFieldsInput.ProtoReflect.Descriptor instead. +func (*NullableFieldsInput) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{357} +} + +func (x *NullableFieldsInput) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *NullableFieldsInput) GetOptionalString() *wrapperspb.StringValue { + if x != nil { + return x.OptionalString + } + return nil +} + +func (x *NullableFieldsInput) GetOptionalInt() *wrapperspb.Int32Value { + if x != nil { + return x.OptionalInt + } + return nil +} + +func (x *NullableFieldsInput) GetOptionalFloat() *wrapperspb.DoubleValue { + if x != nil { + return x.OptionalFloat + } + return nil +} + +func (x *NullableFieldsInput) GetOptionalBoolean() *wrapperspb.BoolValue { + if x != nil { + return x.OptionalBoolean + } + return nil +} + +func (x *NullableFieldsInput) GetRequiredString() string { + if x != nil { + return x.RequiredString + } + return "" +} + +func (x *NullableFieldsInput) GetRequiredInt() int32 { + if x != nil { + return x.RequiredInt + } + return 0 +} + +type BlogPostInput struct { + state protoimpl.MessageState `protogen:"open.v1"` + Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"` + Content string `protobuf:"bytes,2,opt,name=content,proto3" json:"content,omitempty"` + Tags []string `protobuf:"bytes,3,rep,name=tags,proto3" json:"tags,omitempty"` + OptionalTags *ListOfString `protobuf:"bytes,4,opt,name=optional_tags,json=optionalTags,proto3" json:"optional_tags,omitempty"` + Categories []string `protobuf:"bytes,5,rep,name=categories,proto3" json:"categories,omitempty"` + Keywords *ListOfString `protobuf:"bytes,6,opt,name=keywords,proto3" json:"keywords,omitempty"` + ViewCounts []int32 `protobuf:"varint,7,rep,packed,name=view_counts,json=viewCounts,proto3" json:"view_counts,omitempty"` + Ratings *ListOfFloat `protobuf:"bytes,8,opt,name=ratings,proto3" json:"ratings,omitempty"` + IsPublished *ListOfBoolean `protobuf:"bytes,9,opt,name=is_published,json=isPublished,proto3" json:"is_published,omitempty"` + TagGroups *ListOfListOfString `protobuf:"bytes,10,opt,name=tag_groups,json=tagGroups,proto3" json:"tag_groups,omitempty"` + RelatedTopics *ListOfListOfString `protobuf:"bytes,11,opt,name=related_topics,json=relatedTopics,proto3" json:"related_topics,omitempty"` + CommentThreads *ListOfListOfString `protobuf:"bytes,12,opt,name=comment_threads,json=commentThreads,proto3" json:"comment_threads,omitempty"` + Suggestions *ListOfListOfString `protobuf:"bytes,13,opt,name=suggestions,proto3" json:"suggestions,omitempty"` + RelatedCategories *ListOfCategoryInput `protobuf:"bytes,14,opt,name=related_categories,json=relatedCategories,proto3" json:"related_categories,omitempty"` + Contributors *ListOfUserInput `protobuf:"bytes,15,opt,name=contributors,proto3" json:"contributors,omitempty"` + CategoryGroups *ListOfListOfCategoryInput `protobuf:"bytes,16,opt,name=category_groups,json=categoryGroups,proto3" json:"category_groups,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *BlogPostInput) Reset() { + *x = BlogPostInput{} + mi := &file_product_proto_msgTypes[358] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *BlogPostInput) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*BlogPostInput) ProtoMessage() {} + +func (x *BlogPostInput) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[358] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use BlogPostInput.ProtoReflect.Descriptor instead. +func (*BlogPostInput) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{358} +} + +func (x *BlogPostInput) GetTitle() string { + if x != nil { + return x.Title + } + return "" +} + +func (x *BlogPostInput) GetContent() string { + if x != nil { + return x.Content + } + return "" +} + +func (x *BlogPostInput) GetTags() []string { + if x != nil { + return x.Tags + } + return nil +} + +func (x *BlogPostInput) GetOptionalTags() *ListOfString { + if x != nil { + return x.OptionalTags + } + return nil +} + +func (x *BlogPostInput) GetCategories() []string { + if x != nil { + return x.Categories + } + return nil +} + +func (x *BlogPostInput) GetKeywords() *ListOfString { + if x != nil { + return x.Keywords + } + return nil +} + +func (x *BlogPostInput) GetViewCounts() []int32 { + if x != nil { + return x.ViewCounts + } + return nil +} + +func (x *BlogPostInput) GetRatings() *ListOfFloat { + if x != nil { + return x.Ratings + } + return nil +} + +func (x *BlogPostInput) GetIsPublished() *ListOfBoolean { + if x != nil { + return x.IsPublished + } + return nil +} + +func (x *BlogPostInput) GetTagGroups() *ListOfListOfString { + if x != nil { + return x.TagGroups + } + return nil +} + +func (x *BlogPostInput) GetRelatedTopics() *ListOfListOfString { + if x != nil { + return x.RelatedTopics + } + return nil +} + +func (x *BlogPostInput) GetCommentThreads() *ListOfListOfString { + if x != nil { + return x.CommentThreads + } + return nil +} + +func (x *BlogPostInput) GetSuggestions() *ListOfListOfString { + if x != nil { + return x.Suggestions + } + return nil +} + +func (x *BlogPostInput) GetRelatedCategories() *ListOfCategoryInput { + if x != nil { + return x.RelatedCategories + } + return nil +} + +func (x *BlogPostInput) GetContributors() *ListOfUserInput { + if x != nil { + return x.Contributors + } + return nil +} + +func (x *BlogPostInput) GetCategoryGroups() *ListOfListOfCategoryInput { + if x != nil { + return x.CategoryGroups + } + return nil +} + +type AuthorInput struct { + state protoimpl.MessageState `protogen:"open.v1"` + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Email *wrapperspb.StringValue `protobuf:"bytes,2,opt,name=email,proto3" json:"email,omitempty"` + Skills []string `protobuf:"bytes,3,rep,name=skills,proto3" json:"skills,omitempty"` + Languages []string `protobuf:"bytes,4,rep,name=languages,proto3" json:"languages,omitempty"` + SocialLinks *ListOfString `protobuf:"bytes,5,opt,name=social_links,json=socialLinks,proto3" json:"social_links,omitempty"` + TeamsByProject *ListOfListOfString `protobuf:"bytes,6,opt,name=teams_by_project,json=teamsByProject,proto3" json:"teams_by_project,omitempty"` + Collaborations *ListOfListOfString `protobuf:"bytes,7,opt,name=collaborations,proto3" json:"collaborations,omitempty"` + FavoriteCategories []*CategoryInput `protobuf:"bytes,8,rep,name=favorite_categories,json=favoriteCategories,proto3" json:"favorite_categories,omitempty"` + AuthorGroups *ListOfListOfUserInput `protobuf:"bytes,9,opt,name=author_groups,json=authorGroups,proto3" json:"author_groups,omitempty"` + ProjectTeams *ListOfListOfUserInput `protobuf:"bytes,10,opt,name=project_teams,json=projectTeams,proto3" json:"project_teams,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *AuthorInput) Reset() { + *x = AuthorInput{} + mi := &file_product_proto_msgTypes[359] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *AuthorInput) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AuthorInput) ProtoMessage() {} + +func (x *AuthorInput) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[359] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AuthorInput.ProtoReflect.Descriptor instead. +func (*AuthorInput) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{359} +} + +func (x *AuthorInput) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *AuthorInput) GetEmail() *wrapperspb.StringValue { + if x != nil { + return x.Email + } + return nil +} + +func (x *AuthorInput) GetSkills() []string { + if x != nil { + return x.Skills + } + return nil +} + +func (x *AuthorInput) GetLanguages() []string { + if x != nil { + return x.Languages + } + return nil +} + +func (x *AuthorInput) GetSocialLinks() *ListOfString { + if x != nil { + return x.SocialLinks + } + return nil +} + +func (x *AuthorInput) GetTeamsByProject() *ListOfListOfString { + if x != nil { + return x.TeamsByProject + } + return nil +} + +func (x *AuthorInput) GetCollaborations() *ListOfListOfString { + if x != nil { + return x.Collaborations + } + return nil +} + +func (x *AuthorInput) GetFavoriteCategories() []*CategoryInput { + if x != nil { + return x.FavoriteCategories + } + return nil +} + +func (x *AuthorInput) GetAuthorGroups() *ListOfListOfUserInput { + if x != nil { + return x.AuthorGroups + } + return nil +} + +func (x *AuthorInput) GetProjectTeams() *ListOfListOfUserInput { + if x != nil { + return x.ProjectTeams + } + return nil +} + +type ProductDetails struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"` + ReviewSummary *ActionResult `protobuf:"bytes,3,opt,name=review_summary,json=reviewSummary,proto3" json:"review_summary,omitempty"` + RecommendedPet *Animal `protobuf:"bytes,4,opt,name=recommended_pet,json=recommendedPet,proto3" json:"recommended_pet,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ProductDetails) Reset() { + *x = ProductDetails{} + mi := &file_product_proto_msgTypes[360] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ProductDetails) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ProductDetails) ProtoMessage() {} + +func (x *ProductDetails) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[360] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ProductDetails.ProtoReflect.Descriptor instead. +func (*ProductDetails) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{360} +} + +func (x *ProductDetails) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *ProductDetails) GetDescription() string { + if x != nil { + return x.Description + } + return "" +} + +func (x *ProductDetails) GetReviewSummary() *ActionResult { + if x != nil { + return x.ReviewSummary + } + return nil +} + +func (x *ProductDetails) GetRecommendedPet() *Animal { + if x != nil { + return x.RecommendedPet + } + return nil +} + +type RestockData struct { + state protoimpl.MessageState `protogen:"open.v1"` + LastRestockDate string `protobuf:"bytes,1,opt,name=last_restock_date,json=lastRestockDate,proto3" json:"last_restock_date,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RestockData) Reset() { + *x = RestockData{} + mi := &file_product_proto_msgTypes[361] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RestockData) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RestockData) ProtoMessage() {} + +func (x *RestockData) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[361] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RestockData.ProtoReflect.Descriptor instead. +func (*RestockData) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{361} +} + +func (x *RestockData) GetLastRestockDate() string { + if x != nil { + return x.LastRestockDate + } + return "" +} + +type StorageMetadata struct { + state protoimpl.MessageState `protogen:"open.v1"` + Capacity int32 `protobuf:"varint,1,opt,name=capacity,proto3" json:"capacity,omitempty"` + Zone string `protobuf:"bytes,2,opt,name=zone,proto3" json:"zone,omitempty"` + Priority int32 `protobuf:"varint,3,opt,name=priority,proto3" json:"priority,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *StorageMetadata) Reset() { + *x = StorageMetadata{} + mi := &file_product_proto_msgTypes[362] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *StorageMetadata) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*StorageMetadata) ProtoMessage() {} + +func (x *StorageMetadata) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[362] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use StorageMetadata.ProtoReflect.Descriptor instead. +func (*StorageMetadata) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{362} +} + +func (x *StorageMetadata) GetCapacity() int32 { + if x != nil { + return x.Capacity + } + return 0 +} + +func (x *StorageMetadata) GetZone() string { + if x != nil { + return x.Zone + } + return "" +} + +func (x *StorageMetadata) GetPriority() int32 { + if x != nil { + return x.Priority + } + return 0 +} + +type StorageCategoryInfo struct { + state protoimpl.MessageState `protogen:"open.v1"` + Kind CategoryKind `protobuf:"varint,1,opt,name=kind,proto3,enum=productv1.CategoryKind" json:"kind,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *StorageCategoryInfo) Reset() { + *x = StorageCategoryInfo{} + mi := &file_product_proto_msgTypes[363] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *StorageCategoryInfo) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*StorageCategoryInfo) ProtoMessage() {} + +func (x *StorageCategoryInfo) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[363] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use StorageCategoryInfo.ProtoReflect.Descriptor instead. +func (*StorageCategoryInfo) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{363} +} + +func (x *StorageCategoryInfo) GetKind() CategoryKind { + if x != nil { + return x.Kind + } + return CategoryKind_CATEGORY_KIND_UNSPECIFIED +} + +func (x *StorageCategoryInfo) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +type NestedTypeB struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + C *NestedTypeC `protobuf:"bytes,3,opt,name=c,proto3" json:"c,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *NestedTypeB) Reset() { + *x = NestedTypeB{} + mi := &file_product_proto_msgTypes[364] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *NestedTypeB) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*NestedTypeB) ProtoMessage() {} + +func (x *NestedTypeB) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[364] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use NestedTypeB.ProtoReflect.Descriptor instead. +func (*NestedTypeB) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{364} +} + +func (x *NestedTypeB) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *NestedTypeB) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *NestedTypeB) GetC() *NestedTypeC { + if x != nil { + return x.C + } + return nil +} + +type NestedTypeC struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *NestedTypeC) Reset() { + *x = NestedTypeC{} + mi := &file_product_proto_msgTypes[365] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *NestedTypeC) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*NestedTypeC) ProtoMessage() {} + +func (x *NestedTypeC) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[365] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use NestedTypeC.ProtoReflect.Descriptor instead. +func (*NestedTypeC) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{365} +} + +func (x *NestedTypeC) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *NestedTypeC) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +type FilterType struct { + state protoimpl.MessageState `protogen:"open.v1"` + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + FilterField_1 string `protobuf:"bytes,2,opt,name=filter_field_1,json=filterField1,proto3" json:"filter_field_1,omitempty"` + FilterField_2 string `protobuf:"bytes,3,opt,name=filter_field_2,json=filterField2,proto3" json:"filter_field_2,omitempty"` + Pagination *Pagination `protobuf:"bytes,4,opt,name=pagination,proto3" json:"pagination,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *FilterType) Reset() { + *x = FilterType{} + mi := &file_product_proto_msgTypes[366] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *FilterType) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FilterType) ProtoMessage() {} + +func (x *FilterType) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[366] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use FilterType.ProtoReflect.Descriptor instead. +func (*FilterType) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{366} +} + +func (x *FilterType) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *FilterType) GetFilterField_1() string { + if x != nil { + return x.FilterField_1 + } + return "" +} + +func (x *FilterType) GetFilterField_2() string { + if x != nil { + return x.FilterField_2 + } + return "" +} + +func (x *FilterType) GetPagination() *Pagination { + if x != nil { + return x.Pagination + } + return nil +} + +type Pagination struct { + state protoimpl.MessageState `protogen:"open.v1"` + Page int32 `protobuf:"varint,1,opt,name=page,proto3" json:"page,omitempty"` + PerPage int32 `protobuf:"varint,2,opt,name=per_page,json=perPage,proto3" json:"per_page,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *Pagination) Reset() { + *x = Pagination{} + mi := &file_product_proto_msgTypes[367] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *Pagination) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Pagination) ProtoMessage() {} + +func (x *Pagination) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[367] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Pagination.ProtoReflect.Descriptor instead. +func (*Pagination) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{367} +} + +func (x *Pagination) GetPage() int32 { + if x != nil { + return x.Page + } + return 0 +} + +func (x *Pagination) GetPerPage() int32 { + if x != nil { + return x.PerPage + } + return 0 +} + +type OrderLineInput struct { + state protoimpl.MessageState `protogen:"open.v1"` + ProductId string `protobuf:"bytes,1,opt,name=product_id,json=productId,proto3" json:"product_id,omitempty"` + Quantity int32 `protobuf:"varint,2,opt,name=quantity,proto3" json:"quantity,omitempty"` + Modifiers *ListOfString `protobuf:"bytes,3,opt,name=modifiers,proto3" json:"modifiers,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *OrderLineInput) Reset() { + *x = OrderLineInput{} + mi := &file_product_proto_msgTypes[368] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *OrderLineInput) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*OrderLineInput) ProtoMessage() {} + +func (x *OrderLineInput) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[368] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use OrderLineInput.ProtoReflect.Descriptor instead. +func (*OrderLineInput) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{368} +} + +func (x *OrderLineInput) GetProductId() string { + if x != nil { + return x.ProductId + } + return "" +} + +func (x *OrderLineInput) GetQuantity() int32 { + if x != nil { + return x.Quantity + } + return 0 +} + +func (x *OrderLineInput) GetModifiers() *ListOfString { + if x != nil { + return x.Modifiers + } + return nil +} + +type OrderLine struct { + state protoimpl.MessageState `protogen:"open.v1"` + ProductId string `protobuf:"bytes,1,opt,name=product_id,json=productId,proto3" json:"product_id,omitempty"` + Quantity int32 `protobuf:"varint,2,opt,name=quantity,proto3" json:"quantity,omitempty"` + Modifiers *ListOfString `protobuf:"bytes,3,opt,name=modifiers,proto3" json:"modifiers,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *OrderLine) Reset() { + *x = OrderLine{} + mi := &file_product_proto_msgTypes[369] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *OrderLine) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*OrderLine) ProtoMessage() {} + +func (x *OrderLine) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[369] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use OrderLine.ProtoReflect.Descriptor instead. +func (*OrderLine) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{369} +} + +func (x *OrderLine) GetProductId() string { + if x != nil { + return x.ProductId + } + return "" +} + +func (x *OrderLine) GetQuantity() int32 { + if x != nil { + return x.Quantity + } + return 0 +} + +func (x *OrderLine) GetModifiers() *ListOfString { + if x != nil { + return x.Modifiers + } + return nil +} + +type Subcategory struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + Description *wrapperspb.StringValue `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"` + IsActive bool `protobuf:"varint,4,opt,name=is_active,json=isActive,proto3" json:"is_active,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *Subcategory) Reset() { + *x = Subcategory{} + mi := &file_product_proto_msgTypes[370] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *Subcategory) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Subcategory) ProtoMessage() {} + +func (x *Subcategory) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[370] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Subcategory.ProtoReflect.Descriptor instead. +func (*Subcategory) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{370} +} + +func (x *Subcategory) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *Subcategory) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *Subcategory) GetDescription() *wrapperspb.StringValue { + if x != nil { + return x.Description + } + return nil +} + +func (x *Subcategory) GetIsActive() bool { + if x != nil { + return x.IsActive + } + return false +} + +type CategoryMetrics struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + MetricType string `protobuf:"bytes,2,opt,name=metric_type,json=metricType,proto3" json:"metric_type,omitempty"` + Value float64 `protobuf:"fixed64,3,opt,name=value,proto3" json:"value,omitempty"` + Timestamp string `protobuf:"bytes,4,opt,name=timestamp,proto3" json:"timestamp,omitempty"` + CategoryId string `protobuf:"bytes,5,opt,name=category_id,json=categoryId,proto3" json:"category_id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *CategoryMetrics) Reset() { + *x = CategoryMetrics{} + mi := &file_product_proto_msgTypes[371] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *CategoryMetrics) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CategoryMetrics) ProtoMessage() {} + +func (x *CategoryMetrics) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[371] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CategoryMetrics.ProtoReflect.Descriptor instead. +func (*CategoryMetrics) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{371} +} + +func (x *CategoryMetrics) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *CategoryMetrics) GetMetricType() string { + if x != nil { + return x.MetricType + } + return "" +} + +func (x *CategoryMetrics) GetValue() float64 { + if x != nil { + return x.Value + } + return 0 +} + +func (x *CategoryMetrics) GetTimestamp() string { + if x != nil { + return x.Timestamp + } + return "" +} + +func (x *CategoryMetrics) GetCategoryId() string { + if x != nil { + return x.CategoryId + } + return "" +} + +type Cat struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + Kind string `protobuf:"bytes,3,opt,name=kind,proto3" json:"kind,omitempty"` + MeowVolume int32 `protobuf:"varint,4,opt,name=meow_volume,json=meowVolume,proto3" json:"meow_volume,omitempty"` + Owner *Owner `protobuf:"bytes,5,opt,name=owner,proto3" json:"owner,omitempty"` + Breed *CatBreed `protobuf:"bytes,6,opt,name=breed,proto3" json:"breed,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *Cat) Reset() { + *x = Cat{} + mi := &file_product_proto_msgTypes[372] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *Cat) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Cat) ProtoMessage() {} + +func (x *Cat) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[372] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Cat.ProtoReflect.Descriptor instead. +func (*Cat) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{372} +} + +func (x *Cat) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *Cat) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *Cat) GetKind() string { + if x != nil { + return x.Kind + } + return "" +} + +func (x *Cat) GetMeowVolume() int32 { + if x != nil { + return x.MeowVolume + } + return 0 +} + +func (x *Cat) GetOwner() *Owner { + if x != nil { + return x.Owner + } + return nil +} + +func (x *Cat) GetBreed() *CatBreed { + if x != nil { + return x.Breed + } + return nil +} + +type Dog struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + Kind string `protobuf:"bytes,3,opt,name=kind,proto3" json:"kind,omitempty"` + BarkVolume int32 `protobuf:"varint,4,opt,name=bark_volume,json=barkVolume,proto3" json:"bark_volume,omitempty"` + Owner *Owner `protobuf:"bytes,5,opt,name=owner,proto3" json:"owner,omitempty"` + Breed *DogBreed `protobuf:"bytes,6,opt,name=breed,proto3" json:"breed,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *Dog) Reset() { + *x = Dog{} + mi := &file_product_proto_msgTypes[373] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *Dog) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Dog) ProtoMessage() {} + +func (x *Dog) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[373] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Dog.ProtoReflect.Descriptor instead. +func (*Dog) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{373} +} + +func (x *Dog) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *Dog) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *Dog) GetKind() string { + if x != nil { + return x.Kind + } + return "" +} + +func (x *Dog) GetBarkVolume() int32 { + if x != nil { + return x.BarkVolume + } + return 0 +} + +func (x *Dog) GetOwner() *Owner { + if x != nil { + return x.Owner + } + return nil +} + +func (x *Dog) GetBreed() *DogBreed { + if x != nil { + return x.Breed + } + return nil +} + +type Owner struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + Contact *ContactInfo `protobuf:"bytes,3,opt,name=contact,proto3" json:"contact,omitempty"` + Pet *Animal `protobuf:"bytes,4,opt,name=pet,proto3" json:"pet,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *Owner) Reset() { + *x = Owner{} + mi := &file_product_proto_msgTypes[374] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *Owner) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Owner) ProtoMessage() {} + +func (x *Owner) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[374] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Owner.ProtoReflect.Descriptor instead. +func (*Owner) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{374} +} + +func (x *Owner) GetId() string { + if x != nil { + return x.Id } return "" } -func (x *NullableFieldsType) GetRequiredInt() int32 { +func (x *Owner) GetName() string { if x != nil { - return x.RequiredInt + return x.Name } - return 0 + return "" } -type NullableFieldsFilter struct { - state protoimpl.MessageState `protogen:"open.v1"` - Name *wrapperspb.StringValue `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` - OptionalString *wrapperspb.StringValue `protobuf:"bytes,2,opt,name=optional_string,json=optionalString,proto3" json:"optional_string,omitempty"` - IncludeNulls *wrapperspb.BoolValue `protobuf:"bytes,3,opt,name=include_nulls,json=includeNulls,proto3" json:"include_nulls,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +func (x *Owner) GetContact() *ContactInfo { + if x != nil { + return x.Contact + } + return nil } -func (x *NullableFieldsFilter) Reset() { - *x = NullableFieldsFilter{} - mi := &file_product_proto_msgTypes[318] +func (x *Owner) GetPet() *Animal { + if x != nil { + return x.Pet + } + return nil +} + +type ContactInfo struct { + state protoimpl.MessageState `protogen:"open.v1"` + Email string `protobuf:"bytes,1,opt,name=email,proto3" json:"email,omitempty"` + Phone string `protobuf:"bytes,2,opt,name=phone,proto3" json:"phone,omitempty"` + Address *Address `protobuf:"bytes,3,opt,name=address,proto3" json:"address,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ContactInfo) Reset() { + *x = ContactInfo{} + mi := &file_product_proto_msgTypes[375] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *NullableFieldsFilter) String() string { +func (x *ContactInfo) String() string { return protoimpl.X.MessageStringOf(x) } -func (*NullableFieldsFilter) ProtoMessage() {} +func (*ContactInfo) ProtoMessage() {} -func (x *NullableFieldsFilter) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[318] +func (x *ContactInfo) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[375] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15132,73 +18610,57 @@ func (x *NullableFieldsFilter) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use NullableFieldsFilter.ProtoReflect.Descriptor instead. -func (*NullableFieldsFilter) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{318} +// Deprecated: Use ContactInfo.ProtoReflect.Descriptor instead. +func (*ContactInfo) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{375} } -func (x *NullableFieldsFilter) GetName() *wrapperspb.StringValue { +func (x *ContactInfo) GetEmail() string { if x != nil { - return x.Name + return x.Email } - return nil + return "" } -func (x *NullableFieldsFilter) GetOptionalString() *wrapperspb.StringValue { +func (x *ContactInfo) GetPhone() string { if x != nil { - return x.OptionalString + return x.Phone } - return nil + return "" } -func (x *NullableFieldsFilter) GetIncludeNulls() *wrapperspb.BoolValue { +func (x *ContactInfo) GetAddress() *Address { if x != nil { - return x.IncludeNulls + return x.Address } return nil } -type BlogPost struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Title string `protobuf:"bytes,2,opt,name=title,proto3" json:"title,omitempty"` - Content string `protobuf:"bytes,3,opt,name=content,proto3" json:"content,omitempty"` - Tags []string `protobuf:"bytes,4,rep,name=tags,proto3" json:"tags,omitempty"` - OptionalTags *ListOfString `protobuf:"bytes,5,opt,name=optional_tags,json=optionalTags,proto3" json:"optional_tags,omitempty"` - Categories []string `protobuf:"bytes,6,rep,name=categories,proto3" json:"categories,omitempty"` - Keywords *ListOfString `protobuf:"bytes,7,opt,name=keywords,proto3" json:"keywords,omitempty"` - ViewCounts []int32 `protobuf:"varint,8,rep,packed,name=view_counts,json=viewCounts,proto3" json:"view_counts,omitempty"` - Ratings *ListOfFloat `protobuf:"bytes,9,opt,name=ratings,proto3" json:"ratings,omitempty"` - IsPublished *ListOfBoolean `protobuf:"bytes,10,opt,name=is_published,json=isPublished,proto3" json:"is_published,omitempty"` - TagGroups *ListOfListOfString `protobuf:"bytes,11,opt,name=tag_groups,json=tagGroups,proto3" json:"tag_groups,omitempty"` - RelatedTopics *ListOfListOfString `protobuf:"bytes,12,opt,name=related_topics,json=relatedTopics,proto3" json:"related_topics,omitempty"` - CommentThreads *ListOfListOfString `protobuf:"bytes,13,opt,name=comment_threads,json=commentThreads,proto3" json:"comment_threads,omitempty"` - Suggestions *ListOfListOfString `protobuf:"bytes,14,opt,name=suggestions,proto3" json:"suggestions,omitempty"` - RelatedCategories []*Category `protobuf:"bytes,15,rep,name=related_categories,json=relatedCategories,proto3" json:"related_categories,omitempty"` - Contributors []*User `protobuf:"bytes,16,rep,name=contributors,proto3" json:"contributors,omitempty"` - MentionedProducts *ListOfProduct `protobuf:"bytes,17,opt,name=mentioned_products,json=mentionedProducts,proto3" json:"mentioned_products,omitempty"` - MentionedUsers *ListOfUser `protobuf:"bytes,18,opt,name=mentioned_users,json=mentionedUsers,proto3" json:"mentioned_users,omitempty"` - CategoryGroups *ListOfListOfCategory `protobuf:"bytes,19,opt,name=category_groups,json=categoryGroups,proto3" json:"category_groups,omitempty"` - ContributorTeams *ListOfListOfUser `protobuf:"bytes,20,opt,name=contributor_teams,json=contributorTeams,proto3" json:"contributor_teams,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type Address struct { + state protoimpl.MessageState `protogen:"open.v1"` + Street string `protobuf:"bytes,1,opt,name=street,proto3" json:"street,omitempty"` + City string `protobuf:"bytes,2,opt,name=city,proto3" json:"city,omitempty"` + Country string `protobuf:"bytes,3,opt,name=country,proto3" json:"country,omitempty"` + ZipCode string `protobuf:"bytes,4,opt,name=zip_code,json=zipCode,proto3" json:"zip_code,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *BlogPost) Reset() { - *x = BlogPost{} - mi := &file_product_proto_msgTypes[319] +func (x *Address) Reset() { + *x = Address{} + mi := &file_product_proto_msgTypes[376] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *BlogPost) String() string { +func (x *Address) String() string { return protoimpl.X.MessageStringOf(x) } -func (*BlogPost) ProtoMessage() {} +func (*Address) ProtoMessage() {} -func (x *BlogPost) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[319] +func (x *Address) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[376] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15209,175 +18671,261 @@ func (x *BlogPost) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use BlogPost.ProtoReflect.Descriptor instead. -func (*BlogPost) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{319} +// Deprecated: Use Address.ProtoReflect.Descriptor instead. +func (*Address) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{376} } -func (x *BlogPost) GetId() string { +func (x *Address) GetStreet() string { if x != nil { - return x.Id + return x.Street } return "" } -func (x *BlogPost) GetTitle() string { +func (x *Address) GetCity() string { if x != nil { - return x.Title + return x.City } return "" } -func (x *BlogPost) GetContent() string { +func (x *Address) GetCountry() string { if x != nil { - return x.Content + return x.Country } return "" } -func (x *BlogPost) GetTags() []string { +func (x *Address) GetZipCode() string { if x != nil { - return x.Tags + return x.ZipCode } - return nil + return "" } -func (x *BlogPost) GetOptionalTags() *ListOfString { +type CatBreed struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + Origin string `protobuf:"bytes,3,opt,name=origin,proto3" json:"origin,omitempty"` + Characteristics *BreedCharacteristics `protobuf:"bytes,4,opt,name=characteristics,proto3" json:"characteristics,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *CatBreed) Reset() { + *x = CatBreed{} + mi := &file_product_proto_msgTypes[377] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *CatBreed) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CatBreed) ProtoMessage() {} + +func (x *CatBreed) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[377] if x != nil { - return x.OptionalTags + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms } - return nil + return mi.MessageOf(x) } -func (x *BlogPost) GetCategories() []string { +// Deprecated: Use CatBreed.ProtoReflect.Descriptor instead. +func (*CatBreed) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{377} +} + +func (x *CatBreed) GetId() string { if x != nil { - return x.Categories + return x.Id } - return nil + return "" } -func (x *BlogPost) GetKeywords() *ListOfString { +func (x *CatBreed) GetName() string { if x != nil { - return x.Keywords + return x.Name } - return nil + return "" } -func (x *BlogPost) GetViewCounts() []int32 { +func (x *CatBreed) GetOrigin() string { if x != nil { - return x.ViewCounts + return x.Origin } - return nil + return "" } -func (x *BlogPost) GetRatings() *ListOfFloat { +func (x *CatBreed) GetCharacteristics() *BreedCharacteristics { if x != nil { - return x.Ratings + return x.Characteristics } return nil } -func (x *BlogPost) GetIsPublished() *ListOfBoolean { +type DogBreed struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + Origin string `protobuf:"bytes,3,opt,name=origin,proto3" json:"origin,omitempty"` + Characteristics *BreedCharacteristics `protobuf:"bytes,4,opt,name=characteristics,proto3" json:"characteristics,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *DogBreed) Reset() { + *x = DogBreed{} + mi := &file_product_proto_msgTypes[378] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *DogBreed) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DogBreed) ProtoMessage() {} + +func (x *DogBreed) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[378] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DogBreed.ProtoReflect.Descriptor instead. +func (*DogBreed) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{378} +} + +func (x *DogBreed) GetId() string { if x != nil { - return x.IsPublished + return x.Id } - return nil + return "" } -func (x *BlogPost) GetTagGroups() *ListOfListOfString { +func (x *DogBreed) GetName() string { if x != nil { - return x.TagGroups + return x.Name } - return nil + return "" } -func (x *BlogPost) GetRelatedTopics() *ListOfListOfString { +func (x *DogBreed) GetOrigin() string { if x != nil { - return x.RelatedTopics + return x.Origin } - return nil + return "" } -func (x *BlogPost) GetCommentThreads() *ListOfListOfString { +func (x *DogBreed) GetCharacteristics() *BreedCharacteristics { if x != nil { - return x.CommentThreads + return x.Characteristics } return nil } -func (x *BlogPost) GetSuggestions() *ListOfListOfString { - if x != nil { - return x.Suggestions - } - return nil +type BreedCharacteristics struct { + state protoimpl.MessageState `protogen:"open.v1"` + Size string `protobuf:"bytes,1,opt,name=size,proto3" json:"size,omitempty"` + Temperament string `protobuf:"bytes,2,opt,name=temperament,proto3" json:"temperament,omitempty"` + Lifespan string `protobuf:"bytes,3,opt,name=lifespan,proto3" json:"lifespan,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *BlogPost) GetRelatedCategories() []*Category { - if x != nil { - return x.RelatedCategories - } - return nil +func (x *BreedCharacteristics) Reset() { + *x = BreedCharacteristics{} + mi := &file_product_proto_msgTypes[379] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } -func (x *BlogPost) GetContributors() []*User { - if x != nil { - return x.Contributors - } - return nil +func (x *BreedCharacteristics) String() string { + return protoimpl.X.MessageStringOf(x) } -func (x *BlogPost) GetMentionedProducts() *ListOfProduct { +func (*BreedCharacteristics) ProtoMessage() {} + +func (x *BreedCharacteristics) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[379] if x != nil { - return x.MentionedProducts + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms } - return nil + return mi.MessageOf(x) } -func (x *BlogPost) GetMentionedUsers() *ListOfUser { +// Deprecated: Use BreedCharacteristics.ProtoReflect.Descriptor instead. +func (*BreedCharacteristics) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{379} +} + +func (x *BreedCharacteristics) GetSize() string { if x != nil { - return x.MentionedUsers + return x.Size } - return nil + return "" } -func (x *BlogPost) GetCategoryGroups() *ListOfListOfCategory { +func (x *BreedCharacteristics) GetTemperament() string { if x != nil { - return x.CategoryGroups + return x.Temperament } - return nil + return "" } -func (x *BlogPost) GetContributorTeams() *ListOfListOfUser { +func (x *BreedCharacteristics) GetLifespan() string { if x != nil { - return x.ContributorTeams + return x.Lifespan } - return nil + return "" } -type BlogPostFilter struct { - state protoimpl.MessageState `protogen:"open.v1"` - Title *wrapperspb.StringValue `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"` - HasCategories *wrapperspb.BoolValue `protobuf:"bytes,2,opt,name=has_categories,json=hasCategories,proto3" json:"has_categories,omitempty"` - MinTags *wrapperspb.Int32Value `protobuf:"bytes,3,opt,name=min_tags,json=minTags,proto3" json:"min_tags,omitempty"` +type StorageItem struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Types that are valid to be assigned to Instance: + // + // *StorageItem_PalletItem + // *StorageItem_ContainerItem + Instance isStorageItem_Instance `protobuf_oneof:"instance"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *BlogPostFilter) Reset() { - *x = BlogPostFilter{} - mi := &file_product_proto_msgTypes[320] +func (x *StorageItem) Reset() { + *x = StorageItem{} + mi := &file_product_proto_msgTypes[380] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *BlogPostFilter) String() string { +func (x *StorageItem) String() string { return protoimpl.X.MessageStringOf(x) } -func (*BlogPostFilter) ProtoMessage() {} +func (*StorageItem) ProtoMessage() {} -func (x *BlogPostFilter) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[320] +func (x *StorageItem) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[380] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15388,68 +18936,79 @@ func (x *BlogPostFilter) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use BlogPostFilter.ProtoReflect.Descriptor instead. -func (*BlogPostFilter) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{320} +// Deprecated: Use StorageItem.ProtoReflect.Descriptor instead. +func (*StorageItem) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{380} } -func (x *BlogPostFilter) GetTitle() *wrapperspb.StringValue { +func (x *StorageItem) GetInstance() isStorageItem_Instance { if x != nil { - return x.Title + return x.Instance } return nil } -func (x *BlogPostFilter) GetHasCategories() *wrapperspb.BoolValue { +func (x *StorageItem) GetPalletItem() *PalletItem { if x != nil { - return x.HasCategories + if x, ok := x.Instance.(*StorageItem_PalletItem); ok { + return x.PalletItem + } } return nil } -func (x *BlogPostFilter) GetMinTags() *wrapperspb.Int32Value { +func (x *StorageItem) GetContainerItem() *ContainerItem { if x != nil { - return x.MinTags + if x, ok := x.Instance.(*StorageItem_ContainerItem); ok { + return x.ContainerItem + } } return nil } -type Author struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` - Email *wrapperspb.StringValue `protobuf:"bytes,3,opt,name=email,proto3" json:"email,omitempty"` - Skills []string `protobuf:"bytes,4,rep,name=skills,proto3" json:"skills,omitempty"` - Languages []string `protobuf:"bytes,5,rep,name=languages,proto3" json:"languages,omitempty"` - SocialLinks *ListOfString `protobuf:"bytes,6,opt,name=social_links,json=socialLinks,proto3" json:"social_links,omitempty"` - TeamsByProject *ListOfListOfString `protobuf:"bytes,7,opt,name=teams_by_project,json=teamsByProject,proto3" json:"teams_by_project,omitempty"` - Collaborations *ListOfListOfString `protobuf:"bytes,8,opt,name=collaborations,proto3" json:"collaborations,omitempty"` - WrittenPosts *ListOfBlogPost `protobuf:"bytes,9,opt,name=written_posts,json=writtenPosts,proto3" json:"written_posts,omitempty"` - FavoriteCategories []*Category `protobuf:"bytes,10,rep,name=favorite_categories,json=favoriteCategories,proto3" json:"favorite_categories,omitempty"` - RelatedAuthors *ListOfUser `protobuf:"bytes,11,opt,name=related_authors,json=relatedAuthors,proto3" json:"related_authors,omitempty"` - ProductReviews *ListOfProduct `protobuf:"bytes,12,opt,name=product_reviews,json=productReviews,proto3" json:"product_reviews,omitempty"` - AuthorGroups *ListOfListOfUser `protobuf:"bytes,13,opt,name=author_groups,json=authorGroups,proto3" json:"author_groups,omitempty"` - CategoryPreferences *ListOfListOfCategory `protobuf:"bytes,14,opt,name=category_preferences,json=categoryPreferences,proto3" json:"category_preferences,omitempty"` - ProjectTeams *ListOfListOfUser `protobuf:"bytes,15,opt,name=project_teams,json=projectTeams,proto3" json:"project_teams,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type isStorageItem_Instance interface { + isStorageItem_Instance() } -func (x *Author) Reset() { - *x = Author{} - mi := &file_product_proto_msgTypes[321] +type StorageItem_PalletItem struct { + PalletItem *PalletItem `protobuf:"bytes,1,opt,name=pallet_item,json=palletItem,proto3,oneof"` +} + +type StorageItem_ContainerItem struct { + ContainerItem *ContainerItem `protobuf:"bytes,2,opt,name=container_item,json=containerItem,proto3,oneof"` +} + +func (*StorageItem_PalletItem) isStorageItem_Instance() {} + +func (*StorageItem_ContainerItem) isStorageItem_Instance() {} + +type PalletItem struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + Weight float64 `protobuf:"fixed64,3,opt,name=weight,proto3" json:"weight,omitempty"` + PalletCount int32 `protobuf:"varint,4,opt,name=pallet_count,json=palletCount,proto3" json:"pallet_count,omitempty"` + Handler *ItemHandler `protobuf:"bytes,5,opt,name=handler,proto3" json:"handler,omitempty"` + Specs *PalletSpecs `protobuf:"bytes,6,opt,name=specs,proto3" json:"specs,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *PalletItem) Reset() { + *x = PalletItem{} + mi := &file_product_proto_msgTypes[381] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *Author) String() string { +func (x *PalletItem) String() string { return protoimpl.X.MessageStringOf(x) } -func (*Author) ProtoMessage() {} +func (*PalletItem) ProtoMessage() {} -func (x *Author) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[321] +func (x *PalletItem) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[381] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15460,140 +19019,161 @@ func (x *Author) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use Author.ProtoReflect.Descriptor instead. -func (*Author) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{321} +// Deprecated: Use PalletItem.ProtoReflect.Descriptor instead. +func (*PalletItem) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{381} } -func (x *Author) GetId() string { +func (x *PalletItem) GetId() string { if x != nil { return x.Id } return "" } -func (x *Author) GetName() string { +func (x *PalletItem) GetName() string { if x != nil { return x.Name } return "" } -func (x *Author) GetEmail() *wrapperspb.StringValue { +func (x *PalletItem) GetWeight() float64 { if x != nil { - return x.Email + return x.Weight } - return nil + return 0 } -func (x *Author) GetSkills() []string { +func (x *PalletItem) GetPalletCount() int32 { if x != nil { - return x.Skills + return x.PalletCount } - return nil + return 0 } -func (x *Author) GetLanguages() []string { +func (x *PalletItem) GetHandler() *ItemHandler { if x != nil { - return x.Languages + return x.Handler } return nil } -func (x *Author) GetSocialLinks() *ListOfString { +func (x *PalletItem) GetSpecs() *PalletSpecs { if x != nil { - return x.SocialLinks + return x.Specs } return nil } -func (x *Author) GetTeamsByProject() *ListOfListOfString { - if x != nil { - return x.TeamsByProject - } - return nil +type ContainerItem struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + Weight float64 `protobuf:"fixed64,3,opt,name=weight,proto3" json:"weight,omitempty"` + ContainerSize string `protobuf:"bytes,4,opt,name=container_size,json=containerSize,proto3" json:"container_size,omitempty"` + Handler *ItemHandler `protobuf:"bytes,5,opt,name=handler,proto3" json:"handler,omitempty"` + Specs *ContainerSpecs `protobuf:"bytes,6,opt,name=specs,proto3" json:"specs,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *Author) GetCollaborations() *ListOfListOfString { - if x != nil { - return x.Collaborations - } - return nil +func (x *ContainerItem) Reset() { + *x = ContainerItem{} + mi := &file_product_proto_msgTypes[382] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } -func (x *Author) GetWrittenPosts() *ListOfBlogPost { +func (x *ContainerItem) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ContainerItem) ProtoMessage() {} + +func (x *ContainerItem) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[382] if x != nil { - return x.WrittenPosts + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms } - return nil + return mi.MessageOf(x) } -func (x *Author) GetFavoriteCategories() []*Category { +// Deprecated: Use ContainerItem.ProtoReflect.Descriptor instead. +func (*ContainerItem) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{382} +} + +func (x *ContainerItem) GetId() string { if x != nil { - return x.FavoriteCategories + return x.Id } - return nil + return "" } -func (x *Author) GetRelatedAuthors() *ListOfUser { +func (x *ContainerItem) GetName() string { if x != nil { - return x.RelatedAuthors + return x.Name } - return nil + return "" } -func (x *Author) GetProductReviews() *ListOfProduct { +func (x *ContainerItem) GetWeight() float64 { if x != nil { - return x.ProductReviews + return x.Weight } - return nil + return 0 } -func (x *Author) GetAuthorGroups() *ListOfListOfUser { +func (x *ContainerItem) GetContainerSize() string { if x != nil { - return x.AuthorGroups + return x.ContainerSize } - return nil + return "" } -func (x *Author) GetCategoryPreferences() *ListOfListOfCategory { +func (x *ContainerItem) GetHandler() *ItemHandler { if x != nil { - return x.CategoryPreferences + return x.Handler } return nil } -func (x *Author) GetProjectTeams() *ListOfListOfUser { +func (x *ContainerItem) GetSpecs() *ContainerSpecs { if x != nil { - return x.ProjectTeams + return x.Specs } return nil } -type AuthorFilter struct { - state protoimpl.MessageState `protogen:"open.v1"` - Name *wrapperspb.StringValue `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` - HasTeams *wrapperspb.BoolValue `protobuf:"bytes,2,opt,name=has_teams,json=hasTeams,proto3" json:"has_teams,omitempty"` - SkillCount *wrapperspb.Int32Value `protobuf:"bytes,3,opt,name=skill_count,json=skillCount,proto3" json:"skill_count,omitempty"` +type ItemHandler struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + AssignedItem *StorageItem `protobuf:"bytes,3,opt,name=assigned_item,json=assignedItem,proto3" json:"assigned_item,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *AuthorFilter) Reset() { - *x = AuthorFilter{} - mi := &file_product_proto_msgTypes[322] +func (x *ItemHandler) Reset() { + *x = ItemHandler{} + mi := &file_product_proto_msgTypes[383] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *AuthorFilter) String() string { +func (x *ItemHandler) String() string { return protoimpl.X.MessageStringOf(x) } -func (*AuthorFilter) ProtoMessage() {} +func (*ItemHandler) ProtoMessage() {} -func (x *AuthorFilter) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[322] +func (x *ItemHandler) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[383] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15604,56 +19184,56 @@ func (x *AuthorFilter) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use AuthorFilter.ProtoReflect.Descriptor instead. -func (*AuthorFilter) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{322} +// Deprecated: Use ItemHandler.ProtoReflect.Descriptor instead. +func (*ItemHandler) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{383} } -func (x *AuthorFilter) GetName() *wrapperspb.StringValue { +func (x *ItemHandler) GetId() string { if x != nil { - return x.Name + return x.Id } - return nil + return "" } -func (x *AuthorFilter) GetHasTeams() *wrapperspb.BoolValue { +func (x *ItemHandler) GetName() string { if x != nil { - return x.HasTeams + return x.Name } - return nil + return "" } -func (x *AuthorFilter) GetSkillCount() *wrapperspb.Int32Value { +func (x *ItemHandler) GetAssignedItem() *StorageItem { if x != nil { - return x.SkillCount + return x.AssignedItem } return nil } -type TestContainer struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` - Description *wrapperspb.StringValue `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"` +type PalletSpecs struct { + state protoimpl.MessageState `protogen:"open.v1"` + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + MaxWeight float64 `protobuf:"fixed64,2,opt,name=max_weight,json=maxWeight,proto3" json:"max_weight,omitempty"` + Dimensions *Dimensions `protobuf:"bytes,3,opt,name=dimensions,proto3" json:"dimensions,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *TestContainer) Reset() { - *x = TestContainer{} - mi := &file_product_proto_msgTypes[323] +func (x *PalletSpecs) Reset() { + *x = PalletSpecs{} + mi := &file_product_proto_msgTypes[384] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *TestContainer) String() string { +func (x *PalletSpecs) String() string { return protoimpl.X.MessageStringOf(x) } -func (*TestContainer) ProtoMessage() {} +func (*PalletSpecs) ProtoMessage() {} -func (x *TestContainer) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[323] +func (x *PalletSpecs) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[384] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15664,54 +19244,56 @@ func (x *TestContainer) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use TestContainer.ProtoReflect.Descriptor instead. -func (*TestContainer) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{323} +// Deprecated: Use PalletSpecs.ProtoReflect.Descriptor instead. +func (*PalletSpecs) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{384} } -func (x *TestContainer) GetId() string { +func (x *PalletSpecs) GetName() string { if x != nil { - return x.Id + return x.Name } return "" } -func (x *TestContainer) GetName() string { +func (x *PalletSpecs) GetMaxWeight() float64 { if x != nil { - return x.Name + return x.MaxWeight } - return "" + return 0 } -func (x *TestContainer) GetDescription() *wrapperspb.StringValue { +func (x *PalletSpecs) GetDimensions() *Dimensions { if x != nil { - return x.Description + return x.Dimensions } return nil } -type UserInput struct { +type ContainerSpecs struct { state protoimpl.MessageState `protogen:"open.v1"` Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Volume float64 `protobuf:"fixed64,2,opt,name=volume,proto3" json:"volume,omitempty"` + Dimensions *Dimensions `protobuf:"bytes,3,opt,name=dimensions,proto3" json:"dimensions,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *UserInput) Reset() { - *x = UserInput{} - mi := &file_product_proto_msgTypes[324] +func (x *ContainerSpecs) Reset() { + *x = ContainerSpecs{} + mi := &file_product_proto_msgTypes[385] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *UserInput) String() string { +func (x *ContainerSpecs) String() string { return protoimpl.X.MessageStringOf(x) } -func (*UserInput) ProtoMessage() {} +func (*ContainerSpecs) ProtoMessage() {} -func (x *UserInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[324] +func (x *ContainerSpecs) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[385] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15722,41 +19304,56 @@ func (x *UserInput) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use UserInput.ProtoReflect.Descriptor instead. -func (*UserInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{324} +// Deprecated: Use ContainerSpecs.ProtoReflect.Descriptor instead. +func (*ContainerSpecs) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{385} } -func (x *UserInput) GetName() string { +func (x *ContainerSpecs) GetName() string { if x != nil { return x.Name } return "" } -type ActionInput struct { +func (x *ContainerSpecs) GetVolume() float64 { + if x != nil { + return x.Volume + } + return 0 +} + +func (x *ContainerSpecs) GetDimensions() *Dimensions { + if x != nil { + return x.Dimensions + } + return nil +} + +type Dimensions struct { state protoimpl.MessageState `protogen:"open.v1"` - Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` - Payload string `protobuf:"bytes,2,opt,name=payload,proto3" json:"payload,omitempty"` + Length float64 `protobuf:"fixed64,1,opt,name=length,proto3" json:"length,omitempty"` + Width float64 `protobuf:"fixed64,2,opt,name=width,proto3" json:"width,omitempty"` + Height float64 `protobuf:"fixed64,3,opt,name=height,proto3" json:"height,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ActionInput) Reset() { - *x = ActionInput{} - mi := &file_product_proto_msgTypes[325] +func (x *Dimensions) Reset() { + *x = Dimensions{} + mi := &file_product_proto_msgTypes[386] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ActionInput) String() string { +func (x *Dimensions) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ActionInput) ProtoMessage() {} +func (*Dimensions) ProtoMessage() {} -func (x *ActionInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[325] +func (x *Dimensions) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[386] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15767,51 +19364,58 @@ func (x *ActionInput) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ActionInput.ProtoReflect.Descriptor instead. -func (*ActionInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{325} +// Deprecated: Use Dimensions.ProtoReflect.Descriptor instead. +func (*Dimensions) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{386} } -func (x *ActionInput) GetType() string { +func (x *Dimensions) GetLength() float64 { if x != nil { - return x.Type + return x.Length } - return "" + return 0 } -func (x *ActionInput) GetPayload() string { +func (x *Dimensions) GetWidth() float64 { if x != nil { - return x.Payload + return x.Width } - return "" + return 0 } -type ActionResult struct { +func (x *Dimensions) GetHeight() float64 { + if x != nil { + return x.Height + } + return 0 +} + +type StorageOperationResult struct { state protoimpl.MessageState `protogen:"open.v1"` // Types that are valid to be assigned to Value: // - // *ActionResult_ActionSuccess - // *ActionResult_ActionError - Value isActionResult_Value `protobuf_oneof:"value"` + // *StorageOperationResult_StorageSuccess + // *StorageOperationResult_StorageFailure + Value isStorageOperationResult_Value `protobuf_oneof:"value"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ActionResult) Reset() { - *x = ActionResult{} - mi := &file_product_proto_msgTypes[326] +func (x *StorageOperationResult) Reset() { + *x = StorageOperationResult{} + mi := &file_product_proto_msgTypes[387] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ActionResult) String() string { +func (x *StorageOperationResult) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ActionResult) ProtoMessage() {} +func (*StorageOperationResult) ProtoMessage() {} -func (x *ActionResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[326] +func (x *StorageOperationResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[387] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15822,80 +19426,75 @@ func (x *ActionResult) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ActionResult.ProtoReflect.Descriptor instead. -func (*ActionResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{326} +// Deprecated: Use StorageOperationResult.ProtoReflect.Descriptor instead. +func (*StorageOperationResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{387} } -func (x *ActionResult) GetValue() isActionResult_Value { +func (x *StorageOperationResult) GetValue() isStorageOperationResult_Value { if x != nil { return x.Value } return nil } -func (x *ActionResult) GetActionSuccess() *ActionSuccess { +func (x *StorageOperationResult) GetStorageSuccess() *StorageSuccess { if x != nil { - if x, ok := x.Value.(*ActionResult_ActionSuccess); ok { - return x.ActionSuccess + if x, ok := x.Value.(*StorageOperationResult_StorageSuccess); ok { + return x.StorageSuccess } } return nil } -func (x *ActionResult) GetActionError() *ActionError { +func (x *StorageOperationResult) GetStorageFailure() *StorageFailure { if x != nil { - if x, ok := x.Value.(*ActionResult_ActionError); ok { - return x.ActionError + if x, ok := x.Value.(*StorageOperationResult_StorageFailure); ok { + return x.StorageFailure } } return nil } -type isActionResult_Value interface { - isActionResult_Value() +type isStorageOperationResult_Value interface { + isStorageOperationResult_Value() } -type ActionResult_ActionSuccess struct { - ActionSuccess *ActionSuccess `protobuf:"bytes,1,opt,name=action_success,json=actionSuccess,proto3,oneof"` +type StorageOperationResult_StorageSuccess struct { + StorageSuccess *StorageSuccess `protobuf:"bytes,1,opt,name=storage_success,json=storageSuccess,proto3,oneof"` } -type ActionResult_ActionError struct { - ActionError *ActionError `protobuf:"bytes,2,opt,name=action_error,json=actionError,proto3,oneof"` +type StorageOperationResult_StorageFailure struct { + StorageFailure *StorageFailure `protobuf:"bytes,2,opt,name=storage_failure,json=storageFailure,proto3,oneof"` } -func (*ActionResult_ActionSuccess) isActionResult_Value() {} +func (*StorageOperationResult_StorageSuccess) isStorageOperationResult_Value() {} -func (*ActionResult_ActionError) isActionResult_Value() {} +func (*StorageOperationResult_StorageFailure) isStorageOperationResult_Value() {} -type NullableFieldsInput struct { - state protoimpl.MessageState `protogen:"open.v1"` - Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` - OptionalString *wrapperspb.StringValue `protobuf:"bytes,2,opt,name=optional_string,json=optionalString,proto3" json:"optional_string,omitempty"` - OptionalInt *wrapperspb.Int32Value `protobuf:"bytes,3,opt,name=optional_int,json=optionalInt,proto3" json:"optional_int,omitempty"` - OptionalFloat *wrapperspb.DoubleValue `protobuf:"bytes,4,opt,name=optional_float,json=optionalFloat,proto3" json:"optional_float,omitempty"` - OptionalBoolean *wrapperspb.BoolValue `protobuf:"bytes,5,opt,name=optional_boolean,json=optionalBoolean,proto3" json:"optional_boolean,omitempty"` - RequiredString string `protobuf:"bytes,6,opt,name=required_string,json=requiredString,proto3" json:"required_string,omitempty"` - RequiredInt int32 `protobuf:"varint,7,opt,name=required_int,json=requiredInt,proto3" json:"required_int,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type StorageSuccess struct { + state protoimpl.MessageState `protogen:"open.v1"` + Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"` + CompletedAt string `protobuf:"bytes,2,opt,name=completed_at,json=completedAt,proto3" json:"completed_at,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *NullableFieldsInput) Reset() { - *x = NullableFieldsInput{} - mi := &file_product_proto_msgTypes[327] +func (x *StorageSuccess) Reset() { + *x = StorageSuccess{} + mi := &file_product_proto_msgTypes[388] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *NullableFieldsInput) String() string { +func (x *StorageSuccess) String() string { return protoimpl.X.MessageStringOf(x) } -func (*NullableFieldsInput) ProtoMessage() {} +func (*StorageSuccess) ProtoMessage() {} -func (x *NullableFieldsInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[327] +func (x *StorageSuccess) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[388] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15906,97 +19505,100 @@ func (x *NullableFieldsInput) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use NullableFieldsInput.ProtoReflect.Descriptor instead. -func (*NullableFieldsInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{327} +// Deprecated: Use StorageSuccess.ProtoReflect.Descriptor instead. +func (*StorageSuccess) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{388} } -func (x *NullableFieldsInput) GetName() string { +func (x *StorageSuccess) GetMessage() string { if x != nil { - return x.Name + return x.Message } return "" } -func (x *NullableFieldsInput) GetOptionalString() *wrapperspb.StringValue { +func (x *StorageSuccess) GetCompletedAt() string { if x != nil { - return x.OptionalString + return x.CompletedAt } - return nil + return "" } -func (x *NullableFieldsInput) GetOptionalInt() *wrapperspb.Int32Value { - if x != nil { - return x.OptionalInt - } - return nil +type StorageFailure struct { + state protoimpl.MessageState `protogen:"open.v1"` + Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"` + ErrorCode string `protobuf:"bytes,2,opt,name=error_code,json=errorCode,proto3" json:"error_code,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *NullableFieldsInput) GetOptionalFloat() *wrapperspb.DoubleValue { - if x != nil { - return x.OptionalFloat - } - return nil +func (x *StorageFailure) Reset() { + *x = StorageFailure{} + mi := &file_product_proto_msgTypes[389] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } -func (x *NullableFieldsInput) GetOptionalBoolean() *wrapperspb.BoolValue { +func (x *StorageFailure) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*StorageFailure) ProtoMessage() {} + +func (x *StorageFailure) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[389] if x != nil { - return x.OptionalBoolean + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms } - return nil + return mi.MessageOf(x) } -func (x *NullableFieldsInput) GetRequiredString() string { +// Deprecated: Use StorageFailure.ProtoReflect.Descriptor instead. +func (*StorageFailure) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{389} +} + +func (x *StorageFailure) GetMessage() string { if x != nil { - return x.RequiredString + return x.Message } return "" } -func (x *NullableFieldsInput) GetRequiredInt() int32 { +func (x *StorageFailure) GetErrorCode() string { if x != nil { - return x.RequiredInt + return x.ErrorCode } - return 0 + return "" } -type BlogPostInput struct { - state protoimpl.MessageState `protogen:"open.v1"` - Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"` - Content string `protobuf:"bytes,2,opt,name=content,proto3" json:"content,omitempty"` - Tags []string `protobuf:"bytes,3,rep,name=tags,proto3" json:"tags,omitempty"` - OptionalTags *ListOfString `protobuf:"bytes,4,opt,name=optional_tags,json=optionalTags,proto3" json:"optional_tags,omitempty"` - Categories []string `protobuf:"bytes,5,rep,name=categories,proto3" json:"categories,omitempty"` - Keywords *ListOfString `protobuf:"bytes,6,opt,name=keywords,proto3" json:"keywords,omitempty"` - ViewCounts []int32 `protobuf:"varint,7,rep,packed,name=view_counts,json=viewCounts,proto3" json:"view_counts,omitempty"` - Ratings *ListOfFloat `protobuf:"bytes,8,opt,name=ratings,proto3" json:"ratings,omitempty"` - IsPublished *ListOfBoolean `protobuf:"bytes,9,opt,name=is_published,json=isPublished,proto3" json:"is_published,omitempty"` - TagGroups *ListOfListOfString `protobuf:"bytes,10,opt,name=tag_groups,json=tagGroups,proto3" json:"tag_groups,omitempty"` - RelatedTopics *ListOfListOfString `protobuf:"bytes,11,opt,name=related_topics,json=relatedTopics,proto3" json:"related_topics,omitempty"` - CommentThreads *ListOfListOfString `protobuf:"bytes,12,opt,name=comment_threads,json=commentThreads,proto3" json:"comment_threads,omitempty"` - Suggestions *ListOfListOfString `protobuf:"bytes,13,opt,name=suggestions,proto3" json:"suggestions,omitempty"` - RelatedCategories *ListOfCategoryInput `protobuf:"bytes,14,opt,name=related_categories,json=relatedCategories,proto3" json:"related_categories,omitempty"` - Contributors *ListOfUserInput `protobuf:"bytes,15,opt,name=contributors,proto3" json:"contributors,omitempty"` - CategoryGroups *ListOfListOfCategoryInput `protobuf:"bytes,16,opt,name=category_groups,json=categoryGroups,proto3" json:"category_groups,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type SecuritySetup struct { + state protoimpl.MessageState `protogen:"open.v1"` + SecurityLevel string `protobuf:"bytes,1,opt,name=security_level,json=securityLevel,proto3" json:"security_level,omitempty"` + PrimaryItem *StorageItem `protobuf:"bytes,2,opt,name=primary_item,json=primaryItem,proto3" json:"primary_item,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *BlogPostInput) Reset() { - *x = BlogPostInput{} - mi := &file_product_proto_msgTypes[328] +func (x *SecuritySetup) Reset() { + *x = SecuritySetup{} + mi := &file_product_proto_msgTypes[390] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *BlogPostInput) String() string { +func (x *SecuritySetup) String() string { return protoimpl.X.MessageStringOf(x) } -func (*BlogPostInput) ProtoMessage() {} +func (*SecuritySetup) ProtoMessage() {} -func (x *BlogPostInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[328] +func (x *SecuritySetup) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[390] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16007,154 +19609,154 @@ func (x *BlogPostInput) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use BlogPostInput.ProtoReflect.Descriptor instead. -func (*BlogPostInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{328} +// Deprecated: Use SecuritySetup.ProtoReflect.Descriptor instead. +func (*SecuritySetup) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{390} } -func (x *BlogPostInput) GetTitle() string { +func (x *SecuritySetup) GetSecurityLevel() string { if x != nil { - return x.Title + return x.SecurityLevel } return "" } -func (x *BlogPostInput) GetContent() string { +func (x *SecuritySetup) GetPrimaryItem() *StorageItem { if x != nil { - return x.Content + return x.PrimaryItem } - return "" + return nil } -func (x *BlogPostInput) GetTags() []string { - if x != nil { - return x.Tags - } - return nil +type ActionSuccess struct { + state protoimpl.MessageState `protogen:"open.v1"` + Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"` + Timestamp string `protobuf:"bytes,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *BlogPostInput) GetOptionalTags() *ListOfString { - if x != nil { - return x.OptionalTags - } - return nil +func (x *ActionSuccess) Reset() { + *x = ActionSuccess{} + mi := &file_product_proto_msgTypes[391] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } -func (x *BlogPostInput) GetCategories() []string { - if x != nil { - return x.Categories - } - return nil +func (x *ActionSuccess) String() string { + return protoimpl.X.MessageStringOf(x) } -func (x *BlogPostInput) GetKeywords() *ListOfString { +func (*ActionSuccess) ProtoMessage() {} + +func (x *ActionSuccess) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[391] if x != nil { - return x.Keywords + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms } - return nil + return mi.MessageOf(x) } -func (x *BlogPostInput) GetViewCounts() []int32 { - if x != nil { - return x.ViewCounts - } - return nil +// Deprecated: Use ActionSuccess.ProtoReflect.Descriptor instead. +func (*ActionSuccess) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{391} } -func (x *BlogPostInput) GetRatings() *ListOfFloat { +func (x *ActionSuccess) GetMessage() string { if x != nil { - return x.Ratings + return x.Message } - return nil + return "" } -func (x *BlogPostInput) GetIsPublished() *ListOfBoolean { +func (x *ActionSuccess) GetTimestamp() string { if x != nil { - return x.IsPublished + return x.Timestamp } - return nil + return "" } -func (x *BlogPostInput) GetTagGroups() *ListOfListOfString { - if x != nil { - return x.TagGroups - } - return nil +type ActionError struct { + state protoimpl.MessageState `protogen:"open.v1"` + Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"` + Code string `protobuf:"bytes,2,opt,name=code,proto3" json:"code,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *BlogPostInput) GetRelatedTopics() *ListOfListOfString { - if x != nil { - return x.RelatedTopics - } - return nil +func (x *ActionError) Reset() { + *x = ActionError{} + mi := &file_product_proto_msgTypes[392] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } -func (x *BlogPostInput) GetCommentThreads() *ListOfListOfString { - if x != nil { - return x.CommentThreads - } - return nil +func (x *ActionError) String() string { + return protoimpl.X.MessageStringOf(x) } -func (x *BlogPostInput) GetSuggestions() *ListOfListOfString { +func (*ActionError) ProtoMessage() {} + +func (x *ActionError) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[392] if x != nil { - return x.Suggestions + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms } - return nil + return mi.MessageOf(x) } -func (x *BlogPostInput) GetRelatedCategories() *ListOfCategoryInput { - if x != nil { - return x.RelatedCategories - } - return nil +// Deprecated: Use ActionError.ProtoReflect.Descriptor instead. +func (*ActionError) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{392} } -func (x *BlogPostInput) GetContributors() *ListOfUserInput { +func (x *ActionError) GetMessage() string { if x != nil { - return x.Contributors + return x.Message } - return nil + return "" } -func (x *BlogPostInput) GetCategoryGroups() *ListOfListOfCategoryInput { +func (x *ActionError) GetCode() string { if x != nil { - return x.CategoryGroups + return x.Code } - return nil + return "" } -type AuthorInput struct { - state protoimpl.MessageState `protogen:"open.v1"` - Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` - Email *wrapperspb.StringValue `protobuf:"bytes,2,opt,name=email,proto3" json:"email,omitempty"` - Skills []string `protobuf:"bytes,3,rep,name=skills,proto3" json:"skills,omitempty"` - Languages []string `protobuf:"bytes,4,rep,name=languages,proto3" json:"languages,omitempty"` - SocialLinks *ListOfString `protobuf:"bytes,5,opt,name=social_links,json=socialLinks,proto3" json:"social_links,omitempty"` - TeamsByProject *ListOfListOfString `protobuf:"bytes,6,opt,name=teams_by_project,json=teamsByProject,proto3" json:"teams_by_project,omitempty"` - Collaborations *ListOfListOfString `protobuf:"bytes,7,opt,name=collaborations,proto3" json:"collaborations,omitempty"` - FavoriteCategories []*CategoryInput `protobuf:"bytes,8,rep,name=favorite_categories,json=favoriteCategories,proto3" json:"favorite_categories,omitempty"` - AuthorGroups *ListOfListOfUserInput `protobuf:"bytes,9,opt,name=author_groups,json=authorGroups,proto3" json:"author_groups,omitempty"` - ProjectTeams *ListOfListOfUserInput `protobuf:"bytes,10,opt,name=project_teams,json=projectTeams,proto3" json:"project_teams,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type TestDetails struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Summary string `protobuf:"bytes,2,opt,name=summary,proto3" json:"summary,omitempty"` + Pet *Animal `protobuf:"bytes,3,opt,name=pet,proto3" json:"pet,omitempty"` + Status *ActionResult `protobuf:"bytes,4,opt,name=status,proto3" json:"status,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *AuthorInput) Reset() { - *x = AuthorInput{} - mi := &file_product_proto_msgTypes[329] +func (x *TestDetails) Reset() { + *x = TestDetails{} + mi := &file_product_proto_msgTypes[393] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *AuthorInput) String() string { +func (x *TestDetails) String() string { return protoimpl.X.MessageStringOf(x) } -func (*AuthorInput) ProtoMessage() {} +func (*TestDetails) ProtoMessage() {} -func (x *AuthorInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[329] +func (x *TestDetails) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[393] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16165,106 +19767,116 @@ func (x *AuthorInput) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use AuthorInput.ProtoReflect.Descriptor instead. -func (*AuthorInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{329} +// Deprecated: Use TestDetails.ProtoReflect.Descriptor instead. +func (*TestDetails) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{393} } -func (x *AuthorInput) GetName() string { +func (x *TestDetails) GetId() string { if x != nil { - return x.Name + return x.Id } return "" } -func (x *AuthorInput) GetEmail() *wrapperspb.StringValue { +func (x *TestDetails) GetSummary() string { if x != nil { - return x.Email + return x.Summary } - return nil + return "" } -func (x *AuthorInput) GetSkills() []string { +func (x *TestDetails) GetPet() *Animal { if x != nil { - return x.Skills + return x.Pet } return nil } -func (x *AuthorInput) GetLanguages() []string { +func (x *TestDetails) GetStatus() *ActionResult { if x != nil { - return x.Languages + return x.Status } return nil } -func (x *AuthorInput) GetSocialLinks() *ListOfString { - if x != nil { - return x.SocialLinks - } - return nil +type CategoryInput struct { + state protoimpl.MessageState `protogen:"open.v1"` + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Kind CategoryKind `protobuf:"varint,2,opt,name=kind,proto3,enum=productv1.CategoryKind" json:"kind,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *AuthorInput) GetTeamsByProject() *ListOfListOfString { - if x != nil { - return x.TeamsByProject - } - return nil +func (x *CategoryInput) Reset() { + *x = CategoryInput{} + mi := &file_product_proto_msgTypes[394] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } -func (x *AuthorInput) GetCollaborations() *ListOfListOfString { - if x != nil { - return x.Collaborations - } - return nil +func (x *CategoryInput) String() string { + return protoimpl.X.MessageStringOf(x) } -func (x *AuthorInput) GetFavoriteCategories() []*CategoryInput { +func (*CategoryInput) ProtoMessage() {} + +func (x *CategoryInput) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[394] if x != nil { - return x.FavoriteCategories + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms } - return nil + return mi.MessageOf(x) } -func (x *AuthorInput) GetAuthorGroups() *ListOfListOfUserInput { +// Deprecated: Use CategoryInput.ProtoReflect.Descriptor instead. +func (*CategoryInput) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{394} +} + +func (x *CategoryInput) GetName() string { if x != nil { - return x.AuthorGroups + return x.Name } - return nil + return "" } -func (x *AuthorInput) GetProjectTeams() *ListOfListOfUserInput { +func (x *CategoryInput) GetKind() CategoryKind { if x != nil { - return x.ProjectTeams + return x.Kind } - return nil + return CategoryKind_CATEGORY_KIND_UNSPECIFIED } -type ProductDetails struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"` - ReviewSummary *ActionResult `protobuf:"bytes,3,opt,name=review_summary,json=reviewSummary,proto3" json:"review_summary,omitempty"` - RecommendedPet *Animal `protobuf:"bytes,4,opt,name=recommended_pet,json=recommendedPet,proto3" json:"recommended_pet,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type ProductCountFilter struct { + state protoimpl.MessageState `protogen:"open.v1"` + MinPrice *wrapperspb.DoubleValue `protobuf:"bytes,1,opt,name=min_price,json=minPrice,proto3" json:"min_price,omitempty"` + MaxPrice *wrapperspb.DoubleValue `protobuf:"bytes,2,opt,name=max_price,json=maxPrice,proto3" json:"max_price,omitempty"` + InStock *wrapperspb.BoolValue `protobuf:"bytes,3,opt,name=in_stock,json=inStock,proto3" json:"in_stock,omitempty"` + SearchTerm *wrapperspb.StringValue `protobuf:"bytes,4,opt,name=search_term,json=searchTerm,proto3" json:"search_term,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *ProductDetails) Reset() { - *x = ProductDetails{} - mi := &file_product_proto_msgTypes[330] +func (x *ProductCountFilter) Reset() { + *x = ProductCountFilter{} + mi := &file_product_proto_msgTypes[395] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ProductDetails) String() string { +func (x *ProductCountFilter) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ProductDetails) ProtoMessage() {} +func (*ProductCountFilter) ProtoMessage() {} -func (x *ProductDetails) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[330] +func (x *ProductCountFilter) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[395] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16275,61 +19887,65 @@ func (x *ProductDetails) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ProductDetails.ProtoReflect.Descriptor instead. -func (*ProductDetails) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{330} +// Deprecated: Use ProductCountFilter.ProtoReflect.Descriptor instead. +func (*ProductCountFilter) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{395} } -func (x *ProductDetails) GetId() string { +func (x *ProductCountFilter) GetMinPrice() *wrapperspb.DoubleValue { if x != nil { - return x.Id + return x.MinPrice } - return "" + return nil } -func (x *ProductDetails) GetDescription() string { +func (x *ProductCountFilter) GetMaxPrice() *wrapperspb.DoubleValue { if x != nil { - return x.Description + return x.MaxPrice } - return "" + return nil } -func (x *ProductDetails) GetReviewSummary() *ActionResult { +func (x *ProductCountFilter) GetInStock() *wrapperspb.BoolValue { if x != nil { - return x.ReviewSummary + return x.InStock } return nil } -func (x *ProductDetails) GetRecommendedPet() *Animal { +func (x *ProductCountFilter) GetSearchTerm() *wrapperspb.StringValue { if x != nil { - return x.RecommendedPet + return x.SearchTerm } return nil } -type RestockData struct { - state protoimpl.MessageState `protogen:"open.v1"` - LastRestockDate string `protobuf:"bytes,1,opt,name=last_restock_date,json=lastRestockDate,proto3" json:"last_restock_date,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type SubcategoryItemFilter struct { + state protoimpl.MessageState `protogen:"open.v1"` + MinPrice *wrapperspb.DoubleValue `protobuf:"bytes,1,opt,name=min_price,json=minPrice,proto3" json:"min_price,omitempty"` + MaxPrice *wrapperspb.DoubleValue `protobuf:"bytes,2,opt,name=max_price,json=maxPrice,proto3" json:"max_price,omitempty"` + InStock *wrapperspb.BoolValue `protobuf:"bytes,3,opt,name=in_stock,json=inStock,proto3" json:"in_stock,omitempty"` + IsActive *wrapperspb.BoolValue `protobuf:"bytes,4,opt,name=is_active,json=isActive,proto3" json:"is_active,omitempty"` + SearchTerm *wrapperspb.StringValue `protobuf:"bytes,5,opt,name=search_term,json=searchTerm,proto3" json:"search_term,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *RestockData) Reset() { - *x = RestockData{} - mi := &file_product_proto_msgTypes[331] +func (x *SubcategoryItemFilter) Reset() { + *x = SubcategoryItemFilter{} + mi := &file_product_proto_msgTypes[396] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RestockData) String() string { +func (x *SubcategoryItemFilter) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RestockData) ProtoMessage() {} +func (*SubcategoryItemFilter) ProtoMessage() {} -func (x *RestockData) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[331] +func (x *SubcategoryItemFilter) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[396] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16340,42 +19956,70 @@ func (x *RestockData) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use RestockData.ProtoReflect.Descriptor instead. -func (*RestockData) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{331} +// Deprecated: Use SubcategoryItemFilter.ProtoReflect.Descriptor instead. +func (*SubcategoryItemFilter) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{396} } -func (x *RestockData) GetLastRestockDate() string { +func (x *SubcategoryItemFilter) GetMinPrice() *wrapperspb.DoubleValue { if x != nil { - return x.LastRestockDate + return x.MinPrice } - return "" + return nil } -type StorageMetadata struct { +func (x *SubcategoryItemFilter) GetMaxPrice() *wrapperspb.DoubleValue { + if x != nil { + return x.MaxPrice + } + return nil +} + +func (x *SubcategoryItemFilter) GetInStock() *wrapperspb.BoolValue { + if x != nil { + return x.InStock + } + return nil +} + +func (x *SubcategoryItemFilter) GetIsActive() *wrapperspb.BoolValue { + if x != nil { + return x.IsActive + } + return nil +} + +func (x *SubcategoryItemFilter) GetSearchTerm() *wrapperspb.StringValue { + if x != nil { + return x.SearchTerm + } + return nil +} + +type ShippingEstimateInput struct { state protoimpl.MessageState `protogen:"open.v1"` - Capacity int32 `protobuf:"varint,1,opt,name=capacity,proto3" json:"capacity,omitempty"` - Zone string `protobuf:"bytes,2,opt,name=zone,proto3" json:"zone,omitempty"` - Priority int32 `protobuf:"varint,3,opt,name=priority,proto3" json:"priority,omitempty"` + Destination ShippingDestination `protobuf:"varint,1,opt,name=destination,proto3,enum=productv1.ShippingDestination" json:"destination,omitempty"` + Weight float64 `protobuf:"fixed64,2,opt,name=weight,proto3" json:"weight,omitempty"` + Expedited *wrapperspb.BoolValue `protobuf:"bytes,3,opt,name=expedited,proto3" json:"expedited,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *StorageMetadata) Reset() { - *x = StorageMetadata{} - mi := &file_product_proto_msgTypes[332] +func (x *ShippingEstimateInput) Reset() { + *x = ShippingEstimateInput{} + mi := &file_product_proto_msgTypes[397] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *StorageMetadata) String() string { +func (x *ShippingEstimateInput) String() string { return protoimpl.X.MessageStringOf(x) } -func (*StorageMetadata) ProtoMessage() {} +func (*ShippingEstimateInput) ProtoMessage() {} -func (x *StorageMetadata) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[332] +func (x *ShippingEstimateInput) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[397] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16386,55 +20030,54 @@ func (x *StorageMetadata) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use StorageMetadata.ProtoReflect.Descriptor instead. -func (*StorageMetadata) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{332} +// Deprecated: Use ShippingEstimateInput.ProtoReflect.Descriptor instead. +func (*ShippingEstimateInput) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{397} } -func (x *StorageMetadata) GetCapacity() int32 { +func (x *ShippingEstimateInput) GetDestination() ShippingDestination { if x != nil { - return x.Capacity + return x.Destination } - return 0 + return ShippingDestination_SHIPPING_DESTINATION_UNSPECIFIED } -func (x *StorageMetadata) GetZone() string { +func (x *ShippingEstimateInput) GetWeight() float64 { if x != nil { - return x.Zone + return x.Weight } - return "" + return 0 } -func (x *StorageMetadata) GetPriority() int32 { +func (x *ShippingEstimateInput) GetExpedited() *wrapperspb.BoolValue { if x != nil { - return x.Priority + return x.Expedited } - return 0 + return nil } -type StorageCategoryInfo struct { +type ListOfAuthorFilter_List struct { state protoimpl.MessageState `protogen:"open.v1"` - Kind CategoryKind `protobuf:"varint,1,opt,name=kind,proto3,enum=productv1.CategoryKind" json:"kind,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + Items []*AuthorFilter `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *StorageCategoryInfo) Reset() { - *x = StorageCategoryInfo{} - mi := &file_product_proto_msgTypes[333] +func (x *ListOfAuthorFilter_List) Reset() { + *x = ListOfAuthorFilter_List{} + mi := &file_product_proto_msgTypes[398] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *StorageCategoryInfo) String() string { +func (x *ListOfAuthorFilter_List) String() string { return protoimpl.X.MessageStringOf(x) } -func (*StorageCategoryInfo) ProtoMessage() {} +func (*ListOfAuthorFilter_List) ProtoMessage() {} -func (x *StorageCategoryInfo) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[333] +func (x *ListOfAuthorFilter_List) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[398] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16445,49 +20088,40 @@ func (x *StorageCategoryInfo) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use StorageCategoryInfo.ProtoReflect.Descriptor instead. -func (*StorageCategoryInfo) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{333} -} - -func (x *StorageCategoryInfo) GetKind() CategoryKind { - if x != nil { - return x.Kind - } - return CategoryKind_CATEGORY_KIND_UNSPECIFIED +// Deprecated: Use ListOfAuthorFilter_List.ProtoReflect.Descriptor instead. +func (*ListOfAuthorFilter_List) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{0, 0} } -func (x *StorageCategoryInfo) GetName() string { +func (x *ListOfAuthorFilter_List) GetItems() []*AuthorFilter { if x != nil { - return x.Name + return x.Items } - return "" + return nil } -type NestedTypeB struct { +type ListOfAuthorInput_List struct { state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` - C *NestedTypeC `protobuf:"bytes,3,opt,name=c,proto3" json:"c,omitempty"` + Items []*AuthorInput `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *NestedTypeB) Reset() { - *x = NestedTypeB{} - mi := &file_product_proto_msgTypes[334] +func (x *ListOfAuthorInput_List) Reset() { + *x = ListOfAuthorInput_List{} + mi := &file_product_proto_msgTypes[399] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *NestedTypeB) String() string { +func (x *ListOfAuthorInput_List) String() string { return protoimpl.X.MessageStringOf(x) } -func (*NestedTypeB) ProtoMessage() {} +func (*ListOfAuthorInput_List) ProtoMessage() {} -func (x *NestedTypeB) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[334] +func (x *ListOfAuthorInput_List) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[399] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16498,55 +20132,40 @@ func (x *NestedTypeB) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use NestedTypeB.ProtoReflect.Descriptor instead. -func (*NestedTypeB) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{334} -} - -func (x *NestedTypeB) GetId() string { - if x != nil { - return x.Id - } - return "" -} - -func (x *NestedTypeB) GetName() string { - if x != nil { - return x.Name - } - return "" +// Deprecated: Use ListOfAuthorInput_List.ProtoReflect.Descriptor instead. +func (*ListOfAuthorInput_List) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{1, 0} } -func (x *NestedTypeB) GetC() *NestedTypeC { +func (x *ListOfAuthorInput_List) GetItems() []*AuthorInput { if x != nil { - return x.C + return x.Items } return nil } -type NestedTypeC struct { +type ListOfBlogPost_List struct { state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + Items []*BlogPost `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *NestedTypeC) Reset() { - *x = NestedTypeC{} - mi := &file_product_proto_msgTypes[335] +func (x *ListOfBlogPost_List) Reset() { + *x = ListOfBlogPost_List{} + mi := &file_product_proto_msgTypes[400] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *NestedTypeC) String() string { +func (x *ListOfBlogPost_List) String() string { return protoimpl.X.MessageStringOf(x) } -func (*NestedTypeC) ProtoMessage() {} +func (*ListOfBlogPost_List) ProtoMessage() {} -func (x *NestedTypeC) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[335] +func (x *ListOfBlogPost_List) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[400] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16557,50 +20176,40 @@ func (x *NestedTypeC) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use NestedTypeC.ProtoReflect.Descriptor instead. -func (*NestedTypeC) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{335} -} - -func (x *NestedTypeC) GetId() string { - if x != nil { - return x.Id - } - return "" +// Deprecated: Use ListOfBlogPost_List.ProtoReflect.Descriptor instead. +func (*ListOfBlogPost_List) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{2, 0} } -func (x *NestedTypeC) GetName() string { +func (x *ListOfBlogPost_List) GetItems() []*BlogPost { if x != nil { - return x.Name + return x.Items } - return "" + return nil } -type FilterType struct { +type ListOfBlogPostFilter_List struct { state protoimpl.MessageState `protogen:"open.v1"` - Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` - FilterField_1 string `protobuf:"bytes,2,opt,name=filter_field_1,json=filterField1,proto3" json:"filter_field_1,omitempty"` - FilterField_2 string `protobuf:"bytes,3,opt,name=filter_field_2,json=filterField2,proto3" json:"filter_field_2,omitempty"` - Pagination *Pagination `protobuf:"bytes,4,opt,name=pagination,proto3" json:"pagination,omitempty"` + Items []*BlogPostFilter `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *FilterType) Reset() { - *x = FilterType{} - mi := &file_product_proto_msgTypes[336] +func (x *ListOfBlogPostFilter_List) Reset() { + *x = ListOfBlogPostFilter_List{} + mi := &file_product_proto_msgTypes[401] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *FilterType) String() string { +func (x *ListOfBlogPostFilter_List) String() string { return protoimpl.X.MessageStringOf(x) } -func (*FilterType) ProtoMessage() {} +func (*ListOfBlogPostFilter_List) ProtoMessage() {} -func (x *FilterType) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[336] +func (x *ListOfBlogPostFilter_List) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[401] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16611,62 +20220,40 @@ func (x *FilterType) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use FilterType.ProtoReflect.Descriptor instead. -func (*FilterType) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{336} -} - -func (x *FilterType) GetName() string { - if x != nil { - return x.Name - } - return "" -} - -func (x *FilterType) GetFilterField_1() string { - if x != nil { - return x.FilterField_1 - } - return "" -} - -func (x *FilterType) GetFilterField_2() string { - if x != nil { - return x.FilterField_2 - } - return "" +// Deprecated: Use ListOfBlogPostFilter_List.ProtoReflect.Descriptor instead. +func (*ListOfBlogPostFilter_List) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{3, 0} } -func (x *FilterType) GetPagination() *Pagination { +func (x *ListOfBlogPostFilter_List) GetItems() []*BlogPostFilter { if x != nil { - return x.Pagination + return x.Items } return nil } -type Pagination struct { +type ListOfBlogPostInput_List struct { state protoimpl.MessageState `protogen:"open.v1"` - Page int32 `protobuf:"varint,1,opt,name=page,proto3" json:"page,omitempty"` - PerPage int32 `protobuf:"varint,2,opt,name=per_page,json=perPage,proto3" json:"per_page,omitempty"` + Items []*BlogPostInput `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *Pagination) Reset() { - *x = Pagination{} - mi := &file_product_proto_msgTypes[337] +func (x *ListOfBlogPostInput_List) Reset() { + *x = ListOfBlogPostInput_List{} + mi := &file_product_proto_msgTypes[402] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *Pagination) String() string { +func (x *ListOfBlogPostInput_List) String() string { return protoimpl.X.MessageStringOf(x) } -func (*Pagination) ProtoMessage() {} +func (*ListOfBlogPostInput_List) ProtoMessage() {} -func (x *Pagination) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[337] +func (x *ListOfBlogPostInput_List) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[402] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16677,49 +20264,40 @@ func (x *Pagination) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use Pagination.ProtoReflect.Descriptor instead. -func (*Pagination) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{337} -} - -func (x *Pagination) GetPage() int32 { - if x != nil { - return x.Page - } - return 0 +// Deprecated: Use ListOfBlogPostInput_List.ProtoReflect.Descriptor instead. +func (*ListOfBlogPostInput_List) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{4, 0} } -func (x *Pagination) GetPerPage() int32 { +func (x *ListOfBlogPostInput_List) GetItems() []*BlogPostInput { if x != nil { - return x.PerPage + return x.Items } - return 0 + return nil } -type OrderLineInput struct { +type ListOfBoolean_List struct { state protoimpl.MessageState `protogen:"open.v1"` - ProductId string `protobuf:"bytes,1,opt,name=product_id,json=productId,proto3" json:"product_id,omitempty"` - Quantity int32 `protobuf:"varint,2,opt,name=quantity,proto3" json:"quantity,omitempty"` - Modifiers *ListOfString `protobuf:"bytes,3,opt,name=modifiers,proto3" json:"modifiers,omitempty"` + Items []bool `protobuf:"varint,1,rep,packed,name=items,proto3" json:"items,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *OrderLineInput) Reset() { - *x = OrderLineInput{} - mi := &file_product_proto_msgTypes[338] +func (x *ListOfBoolean_List) Reset() { + *x = ListOfBoolean_List{} + mi := &file_product_proto_msgTypes[403] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *OrderLineInput) String() string { +func (x *ListOfBoolean_List) String() string { return protoimpl.X.MessageStringOf(x) } -func (*OrderLineInput) ProtoMessage() {} +func (*ListOfBoolean_List) ProtoMessage() {} -func (x *OrderLineInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[338] +func (x *ListOfBoolean_List) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[403] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16730,56 +20308,40 @@ func (x *OrderLineInput) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use OrderLineInput.ProtoReflect.Descriptor instead. -func (*OrderLineInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{338} -} - -func (x *OrderLineInput) GetProductId() string { - if x != nil { - return x.ProductId - } - return "" -} - -func (x *OrderLineInput) GetQuantity() int32 { - if x != nil { - return x.Quantity - } - return 0 +// Deprecated: Use ListOfBoolean_List.ProtoReflect.Descriptor instead. +func (*ListOfBoolean_List) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{5, 0} } -func (x *OrderLineInput) GetModifiers() *ListOfString { +func (x *ListOfBoolean_List) GetItems() []bool { if x != nil { - return x.Modifiers + return x.Items } return nil } -type OrderLine struct { +type ListOfCategory_List struct { state protoimpl.MessageState `protogen:"open.v1"` - ProductId string `protobuf:"bytes,1,opt,name=product_id,json=productId,proto3" json:"product_id,omitempty"` - Quantity int32 `protobuf:"varint,2,opt,name=quantity,proto3" json:"quantity,omitempty"` - Modifiers *ListOfString `protobuf:"bytes,3,opt,name=modifiers,proto3" json:"modifiers,omitempty"` + Items []*Category `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *OrderLine) Reset() { - *x = OrderLine{} - mi := &file_product_proto_msgTypes[339] +func (x *ListOfCategory_List) Reset() { + *x = ListOfCategory_List{} + mi := &file_product_proto_msgTypes[404] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *OrderLine) String() string { +func (x *ListOfCategory_List) String() string { return protoimpl.X.MessageStringOf(x) } -func (*OrderLine) ProtoMessage() {} +func (*ListOfCategory_List) ProtoMessage() {} -func (x *OrderLine) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[339] +func (x *ListOfCategory_List) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[404] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16790,57 +20352,40 @@ func (x *OrderLine) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use OrderLine.ProtoReflect.Descriptor instead. -func (*OrderLine) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{339} -} - -func (x *OrderLine) GetProductId() string { - if x != nil { - return x.ProductId - } - return "" -} - -func (x *OrderLine) GetQuantity() int32 { - if x != nil { - return x.Quantity - } - return 0 +// Deprecated: Use ListOfCategory_List.ProtoReflect.Descriptor instead. +func (*ListOfCategory_List) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{6, 0} } -func (x *OrderLine) GetModifiers() *ListOfString { +func (x *ListOfCategory_List) GetItems() []*Category { if x != nil { - return x.Modifiers + return x.Items } return nil } -type Subcategory struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` - Description *wrapperspb.StringValue `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"` - IsActive bool `protobuf:"varint,4,opt,name=is_active,json=isActive,proto3" json:"is_active,omitempty"` +type ListOfCategoryInput_List struct { + state protoimpl.MessageState `protogen:"open.v1"` + Items []*CategoryInput `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *Subcategory) Reset() { - *x = Subcategory{} - mi := &file_product_proto_msgTypes[340] +func (x *ListOfCategoryInput_List) Reset() { + *x = ListOfCategoryInput_List{} + mi := &file_product_proto_msgTypes[405] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *Subcategory) String() string { +func (x *ListOfCategoryInput_List) String() string { return protoimpl.X.MessageStringOf(x) } -func (*Subcategory) ProtoMessage() {} +func (*ListOfCategoryInput_List) ProtoMessage() {} -func (x *Subcategory) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[340] +func (x *ListOfCategoryInput_List) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[405] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16851,65 +20396,84 @@ func (x *Subcategory) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use Subcategory.ProtoReflect.Descriptor instead. -func (*Subcategory) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{340} +// Deprecated: Use ListOfCategoryInput_List.ProtoReflect.Descriptor instead. +func (*ListOfCategoryInput_List) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{7, 0} } -func (x *Subcategory) GetId() string { +func (x *ListOfCategoryInput_List) GetItems() []*CategoryInput { if x != nil { - return x.Id + return x.Items } - return "" + return nil } -func (x *Subcategory) GetName() string { - if x != nil { - return x.Name - } - return "" +type ListOfFloat_List struct { + state protoimpl.MessageState `protogen:"open.v1"` + Items []float64 `protobuf:"fixed64,1,rep,packed,name=items,proto3" json:"items,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *Subcategory) GetDescription() *wrapperspb.StringValue { +func (x *ListOfFloat_List) Reset() { + *x = ListOfFloat_List{} + mi := &file_product_proto_msgTypes[406] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListOfFloat_List) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListOfFloat_List) ProtoMessage() {} + +func (x *ListOfFloat_List) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[406] if x != nil { - return x.Description + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms } - return nil + return mi.MessageOf(x) } -func (x *Subcategory) GetIsActive() bool { +// Deprecated: Use ListOfFloat_List.ProtoReflect.Descriptor instead. +func (*ListOfFloat_List) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{8, 0} +} + +func (x *ListOfFloat_List) GetItems() []float64 { if x != nil { - return x.IsActive + return x.Items } - return false + return nil } -type CategoryMetrics struct { +type ListOfListOfCategory_List struct { state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - MetricType string `protobuf:"bytes,2,opt,name=metric_type,json=metricType,proto3" json:"metric_type,omitempty"` - Value float64 `protobuf:"fixed64,3,opt,name=value,proto3" json:"value,omitempty"` - Timestamp string `protobuf:"bytes,4,opt,name=timestamp,proto3" json:"timestamp,omitempty"` - CategoryId string `protobuf:"bytes,5,opt,name=category_id,json=categoryId,proto3" json:"category_id,omitempty"` + Items []*ListOfCategory `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *CategoryMetrics) Reset() { - *x = CategoryMetrics{} - mi := &file_product_proto_msgTypes[341] +func (x *ListOfListOfCategory_List) Reset() { + *x = ListOfListOfCategory_List{} + mi := &file_product_proto_msgTypes[407] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *CategoryMetrics) String() string { +func (x *ListOfListOfCategory_List) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CategoryMetrics) ProtoMessage() {} +func (*ListOfListOfCategory_List) ProtoMessage() {} -func (x *CategoryMetrics) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[341] +func (x *ListOfListOfCategory_List) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[407] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16920,73 +20484,84 @@ func (x *CategoryMetrics) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use CategoryMetrics.ProtoReflect.Descriptor instead. -func (*CategoryMetrics) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{341} +// Deprecated: Use ListOfListOfCategory_List.ProtoReflect.Descriptor instead. +func (*ListOfListOfCategory_List) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{9, 0} } -func (x *CategoryMetrics) GetId() string { +func (x *ListOfListOfCategory_List) GetItems() []*ListOfCategory { if x != nil { - return x.Id + return x.Items } - return "" + return nil } -func (x *CategoryMetrics) GetMetricType() string { - if x != nil { - return x.MetricType - } - return "" +type ListOfListOfCategoryInput_List struct { + state protoimpl.MessageState `protogen:"open.v1"` + Items []*ListOfCategoryInput `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListOfListOfCategoryInput_List) Reset() { + *x = ListOfListOfCategoryInput_List{} + mi := &file_product_proto_msgTypes[408] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListOfListOfCategoryInput_List) String() string { + return protoimpl.X.MessageStringOf(x) } -func (x *CategoryMetrics) GetValue() float64 { +func (*ListOfListOfCategoryInput_List) ProtoMessage() {} + +func (x *ListOfListOfCategoryInput_List) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[408] if x != nil { - return x.Value + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms } - return 0 + return mi.MessageOf(x) } -func (x *CategoryMetrics) GetTimestamp() string { - if x != nil { - return x.Timestamp - } - return "" +// Deprecated: Use ListOfListOfCategoryInput_List.ProtoReflect.Descriptor instead. +func (*ListOfListOfCategoryInput_List) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{10, 0} } -func (x *CategoryMetrics) GetCategoryId() string { +func (x *ListOfListOfCategoryInput_List) GetItems() []*ListOfCategoryInput { if x != nil { - return x.CategoryId + return x.Items } - return "" + return nil } -type Cat struct { +type ListOfListOfString_List struct { state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` - Kind string `protobuf:"bytes,3,opt,name=kind,proto3" json:"kind,omitempty"` - MeowVolume int32 `protobuf:"varint,4,opt,name=meow_volume,json=meowVolume,proto3" json:"meow_volume,omitempty"` - Owner *Owner `protobuf:"bytes,5,opt,name=owner,proto3" json:"owner,omitempty"` - Breed *CatBreed `protobuf:"bytes,6,opt,name=breed,proto3" json:"breed,omitempty"` + Items []*ListOfString `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *Cat) Reset() { - *x = Cat{} - mi := &file_product_proto_msgTypes[342] +func (x *ListOfListOfString_List) Reset() { + *x = ListOfListOfString_List{} + mi := &file_product_proto_msgTypes[409] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *Cat) String() string { +func (x *ListOfListOfString_List) String() string { return protoimpl.X.MessageStringOf(x) } -func (*Cat) ProtoMessage() {} +func (*ListOfListOfString_List) ProtoMessage() {} -func (x *Cat) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[342] +func (x *ListOfListOfString_List) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[409] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16997,80 +20572,84 @@ func (x *Cat) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use Cat.ProtoReflect.Descriptor instead. -func (*Cat) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{342} +// Deprecated: Use ListOfListOfString_List.ProtoReflect.Descriptor instead. +func (*ListOfListOfString_List) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{11, 0} } -func (x *Cat) GetId() string { +func (x *ListOfListOfString_List) GetItems() []*ListOfString { if x != nil { - return x.Id + return x.Items } - return "" + return nil } -func (x *Cat) GetName() string { - if x != nil { - return x.Name - } - return "" +type ListOfListOfUser_List struct { + state protoimpl.MessageState `protogen:"open.v1"` + Items []*ListOfUser `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *Cat) GetKind() string { - if x != nil { - return x.Kind - } - return "" +func (x *ListOfListOfUser_List) Reset() { + *x = ListOfListOfUser_List{} + mi := &file_product_proto_msgTypes[410] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } -func (x *Cat) GetMeowVolume() int32 { - if x != nil { - return x.MeowVolume - } - return 0 +func (x *ListOfListOfUser_List) String() string { + return protoimpl.X.MessageStringOf(x) } -func (x *Cat) GetOwner() *Owner { +func (*ListOfListOfUser_List) ProtoMessage() {} + +func (x *ListOfListOfUser_List) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[410] if x != nil { - return x.Owner + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms } - return nil + return mi.MessageOf(x) } -func (x *Cat) GetBreed() *CatBreed { +// Deprecated: Use ListOfListOfUser_List.ProtoReflect.Descriptor instead. +func (*ListOfListOfUser_List) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{12, 0} +} + +func (x *ListOfListOfUser_List) GetItems() []*ListOfUser { if x != nil { - return x.Breed + return x.Items } return nil } -type Dog struct { +type ListOfListOfUserInput_List struct { state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` - Kind string `protobuf:"bytes,3,opt,name=kind,proto3" json:"kind,omitempty"` - BarkVolume int32 `protobuf:"varint,4,opt,name=bark_volume,json=barkVolume,proto3" json:"bark_volume,omitempty"` - Owner *Owner `protobuf:"bytes,5,opt,name=owner,proto3" json:"owner,omitempty"` - Breed *DogBreed `protobuf:"bytes,6,opt,name=breed,proto3" json:"breed,omitempty"` + Items []*ListOfUserInput `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *Dog) Reset() { - *x = Dog{} - mi := &file_product_proto_msgTypes[343] +func (x *ListOfListOfUserInput_List) Reset() { + *x = ListOfListOfUserInput_List{} + mi := &file_product_proto_msgTypes[411] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *Dog) String() string { +func (x *ListOfListOfUserInput_List) String() string { return protoimpl.X.MessageStringOf(x) } -func (*Dog) ProtoMessage() {} +func (*ListOfListOfUserInput_List) ProtoMessage() {} -func (x *Dog) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[343] +func (x *ListOfListOfUserInput_List) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[411] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17081,78 +20660,84 @@ func (x *Dog) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use Dog.ProtoReflect.Descriptor instead. -func (*Dog) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{343} +// Deprecated: Use ListOfListOfUserInput_List.ProtoReflect.Descriptor instead. +func (*ListOfListOfUserInput_List) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{13, 0} } -func (x *Dog) GetId() string { +func (x *ListOfListOfUserInput_List) GetItems() []*ListOfUserInput { if x != nil { - return x.Id + return x.Items } - return "" + return nil } -func (x *Dog) GetName() string { - if x != nil { - return x.Name - } - return "" +type ListOfOrderLine_List struct { + state protoimpl.MessageState `protogen:"open.v1"` + Items []*OrderLine `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *Dog) GetKind() string { - if x != nil { - return x.Kind - } - return "" +func (x *ListOfOrderLine_List) Reset() { + *x = ListOfOrderLine_List{} + mi := &file_product_proto_msgTypes[412] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } -func (x *Dog) GetBarkVolume() int32 { - if x != nil { - return x.BarkVolume - } - return 0 +func (x *ListOfOrderLine_List) String() string { + return protoimpl.X.MessageStringOf(x) } -func (x *Dog) GetOwner() *Owner { +func (*ListOfOrderLine_List) ProtoMessage() {} + +func (x *ListOfOrderLine_List) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[412] if x != nil { - return x.Owner + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms } - return nil + return mi.MessageOf(x) } -func (x *Dog) GetBreed() *DogBreed { +// Deprecated: Use ListOfOrderLine_List.ProtoReflect.Descriptor instead. +func (*ListOfOrderLine_List) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{14, 0} +} + +func (x *ListOfOrderLine_List) GetItems() []*OrderLine { if x != nil { - return x.Breed + return x.Items } return nil } -type Owner struct { +type ListOfProduct_List struct { state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` - Contact *ContactInfo `protobuf:"bytes,3,opt,name=contact,proto3" json:"contact,omitempty"` - Pet *Animal `protobuf:"bytes,4,opt,name=pet,proto3" json:"pet,omitempty"` + Items []*Product `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *Owner) Reset() { - *x = Owner{} - mi := &file_product_proto_msgTypes[344] +func (x *ListOfProduct_List) Reset() { + *x = ListOfProduct_List{} + mi := &file_product_proto_msgTypes[413] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *Owner) String() string { +func (x *ListOfProduct_List) String() string { return protoimpl.X.MessageStringOf(x) } -func (*Owner) ProtoMessage() {} +func (*ListOfProduct_List) ProtoMessage() {} -func (x *Owner) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[344] +func (x *ListOfProduct_List) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[413] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17163,63 +20748,84 @@ func (x *Owner) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use Owner.ProtoReflect.Descriptor instead. -func (*Owner) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{344} +// Deprecated: Use ListOfProduct_List.ProtoReflect.Descriptor instead. +func (*ListOfProduct_List) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{15, 0} } -func (x *Owner) GetId() string { +func (x *ListOfProduct_List) GetItems() []*Product { if x != nil { - return x.Id + return x.Items } - return "" + return nil } -func (x *Owner) GetName() string { - if x != nil { - return x.Name - } - return "" +type ListOfStorage_List struct { + state protoimpl.MessageState `protogen:"open.v1"` + Items []*Storage `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *Owner) GetContact() *ContactInfo { +func (x *ListOfStorage_List) Reset() { + *x = ListOfStorage_List{} + mi := &file_product_proto_msgTypes[414] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListOfStorage_List) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListOfStorage_List) ProtoMessage() {} + +func (x *ListOfStorage_List) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[414] if x != nil { - return x.Contact + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms } - return nil + return mi.MessageOf(x) } -func (x *Owner) GetPet() *Animal { +// Deprecated: Use ListOfStorage_List.ProtoReflect.Descriptor instead. +func (*ListOfStorage_List) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{16, 0} +} + +func (x *ListOfStorage_List) GetItems() []*Storage { if x != nil { - return x.Pet + return x.Items } return nil } -type ContactInfo struct { +type ListOfString_List struct { state protoimpl.MessageState `protogen:"open.v1"` - Email string `protobuf:"bytes,1,opt,name=email,proto3" json:"email,omitempty"` - Phone string `protobuf:"bytes,2,opt,name=phone,proto3" json:"phone,omitempty"` - Address *Address `protobuf:"bytes,3,opt,name=address,proto3" json:"address,omitempty"` + Items []string `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ContactInfo) Reset() { - *x = ContactInfo{} - mi := &file_product_proto_msgTypes[345] +func (x *ListOfString_List) Reset() { + *x = ListOfString_List{} + mi := &file_product_proto_msgTypes[415] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ContactInfo) String() string { +func (x *ListOfString_List) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ContactInfo) ProtoMessage() {} +func (*ListOfString_List) ProtoMessage() {} -func (x *ContactInfo) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[345] +func (x *ListOfString_List) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[415] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17230,57 +20836,40 @@ func (x *ContactInfo) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ContactInfo.ProtoReflect.Descriptor instead. -func (*ContactInfo) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{345} -} - -func (x *ContactInfo) GetEmail() string { - if x != nil { - return x.Email - } - return "" -} - -func (x *ContactInfo) GetPhone() string { - if x != nil { - return x.Phone - } - return "" +// Deprecated: Use ListOfString_List.ProtoReflect.Descriptor instead. +func (*ListOfString_List) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{17, 0} } -func (x *ContactInfo) GetAddress() *Address { +func (x *ListOfString_List) GetItems() []string { if x != nil { - return x.Address + return x.Items } return nil } -type Address struct { +type ListOfSubcategory_List struct { state protoimpl.MessageState `protogen:"open.v1"` - Street string `protobuf:"bytes,1,opt,name=street,proto3" json:"street,omitempty"` - City string `protobuf:"bytes,2,opt,name=city,proto3" json:"city,omitempty"` - Country string `protobuf:"bytes,3,opt,name=country,proto3" json:"country,omitempty"` - ZipCode string `protobuf:"bytes,4,opt,name=zip_code,json=zipCode,proto3" json:"zip_code,omitempty"` + Items []*Subcategory `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *Address) Reset() { - *x = Address{} - mi := &file_product_proto_msgTypes[346] +func (x *ListOfSubcategory_List) Reset() { + *x = ListOfSubcategory_List{} + mi := &file_product_proto_msgTypes[416] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *Address) String() string { +func (x *ListOfSubcategory_List) String() string { return protoimpl.X.MessageStringOf(x) } -func (*Address) ProtoMessage() {} +func (*ListOfSubcategory_List) ProtoMessage() {} -func (x *Address) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[346] +func (x *ListOfSubcategory_List) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[416] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17291,64 +20880,40 @@ func (x *Address) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use Address.ProtoReflect.Descriptor instead. -func (*Address) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{346} -} - -func (x *Address) GetStreet() string { - if x != nil { - return x.Street - } - return "" -} - -func (x *Address) GetCity() string { - if x != nil { - return x.City - } - return "" -} - -func (x *Address) GetCountry() string { - if x != nil { - return x.Country - } - return "" +// Deprecated: Use ListOfSubcategory_List.ProtoReflect.Descriptor instead. +func (*ListOfSubcategory_List) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{18, 0} } -func (x *Address) GetZipCode() string { +func (x *ListOfSubcategory_List) GetItems() []*Subcategory { if x != nil { - return x.ZipCode + return x.Items } - return "" + return nil } -type CatBreed struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` - Origin string `protobuf:"bytes,3,opt,name=origin,proto3" json:"origin,omitempty"` - Characteristics *BreedCharacteristics `protobuf:"bytes,4,opt,name=characteristics,proto3" json:"characteristics,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type ListOfUser_List struct { + state protoimpl.MessageState `protogen:"open.v1"` + Items []*User `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *CatBreed) Reset() { - *x = CatBreed{} - mi := &file_product_proto_msgTypes[347] +func (x *ListOfUser_List) Reset() { + *x = ListOfUser_List{} + mi := &file_product_proto_msgTypes[417] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *CatBreed) String() string { +func (x *ListOfUser_List) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CatBreed) ProtoMessage() {} +func (*ListOfUser_List) ProtoMessage() {} -func (x *CatBreed) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[347] +func (x *ListOfUser_List) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[417] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17359,64 +20924,84 @@ func (x *CatBreed) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use CatBreed.ProtoReflect.Descriptor instead. -func (*CatBreed) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{347} +// Deprecated: Use ListOfUser_List.ProtoReflect.Descriptor instead. +func (*ListOfUser_List) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{19, 0} } -func (x *CatBreed) GetId() string { +func (x *ListOfUser_List) GetItems() []*User { if x != nil { - return x.Id + return x.Items } - return "" + return nil } -func (x *CatBreed) GetName() string { - if x != nil { - return x.Name - } - return "" +type ListOfUserInput_List struct { + state protoimpl.MessageState `protogen:"open.v1"` + Items []*UserInput `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *CatBreed) GetOrigin() string { +func (x *ListOfUserInput_List) Reset() { + *x = ListOfUserInput_List{} + mi := &file_product_proto_msgTypes[418] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListOfUserInput_List) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListOfUserInput_List) ProtoMessage() {} + +func (x *ListOfUserInput_List) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[418] if x != nil { - return x.Origin + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms } - return "" + return mi.MessageOf(x) } -func (x *CatBreed) GetCharacteristics() *BreedCharacteristics { +// Deprecated: Use ListOfUserInput_List.ProtoReflect.Descriptor instead. +func (*ListOfUserInput_List) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{20, 0} +} + +func (x *ListOfUserInput_List) GetItems() []*UserInput { if x != nil { - return x.Characteristics + return x.Items } return nil } -type DogBreed struct { +type RequireStorageStockHealthScoreByIdFields_RestockData struct { state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` - Origin string `protobuf:"bytes,3,opt,name=origin,proto3" json:"origin,omitempty"` - Characteristics *BreedCharacteristics `protobuf:"bytes,4,opt,name=characteristics,proto3" json:"characteristics,omitempty"` + LastRestockDate string `protobuf:"bytes,1,opt,name=last_restock_date,json=lastRestockDate,proto3" json:"last_restock_date,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *DogBreed) Reset() { - *x = DogBreed{} - mi := &file_product_proto_msgTypes[348] +func (x *RequireStorageStockHealthScoreByIdFields_RestockData) Reset() { + *x = RequireStorageStockHealthScoreByIdFields_RestockData{} + mi := &file_product_proto_msgTypes[419] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *DogBreed) String() string { +func (x *RequireStorageStockHealthScoreByIdFields_RestockData) String() string { return protoimpl.X.MessageStringOf(x) } -func (*DogBreed) ProtoMessage() {} +func (*RequireStorageStockHealthScoreByIdFields_RestockData) ProtoMessage() {} -func (x *DogBreed) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[348] +func (x *RequireStorageStockHealthScoreByIdFields_RestockData) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[419] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17427,63 +21012,41 @@ func (x *DogBreed) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use DogBreed.ProtoReflect.Descriptor instead. -func (*DogBreed) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{348} -} - -func (x *DogBreed) GetId() string { - if x != nil { - return x.Id - } - return "" -} - -func (x *DogBreed) GetName() string { - if x != nil { - return x.Name - } - return "" +// Deprecated: Use RequireStorageStockHealthScoreByIdFields_RestockData.ProtoReflect.Descriptor instead. +func (*RequireStorageStockHealthScoreByIdFields_RestockData) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{244, 0} } -func (x *DogBreed) GetOrigin() string { +func (x *RequireStorageStockHealthScoreByIdFields_RestockData) GetLastRestockDate() string { if x != nil { - return x.Origin + return x.LastRestockDate } return "" } -func (x *DogBreed) GetCharacteristics() *BreedCharacteristics { - if x != nil { - return x.Characteristics - } - return nil -} - -type BreedCharacteristics struct { +type RequireStorageMetadataScoreByIdFields_StorageMetadata struct { state protoimpl.MessageState `protogen:"open.v1"` - Size string `protobuf:"bytes,1,opt,name=size,proto3" json:"size,omitempty"` - Temperament string `protobuf:"bytes,2,opt,name=temperament,proto3" json:"temperament,omitempty"` - Lifespan string `protobuf:"bytes,3,opt,name=lifespan,proto3" json:"lifespan,omitempty"` + Capacity int32 `protobuf:"varint,1,opt,name=capacity,proto3" json:"capacity,omitempty"` + Zone string `protobuf:"bytes,2,opt,name=zone,proto3" json:"zone,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *BreedCharacteristics) Reset() { - *x = BreedCharacteristics{} - mi := &file_product_proto_msgTypes[349] +func (x *RequireStorageMetadataScoreByIdFields_StorageMetadata) Reset() { + *x = RequireStorageMetadataScoreByIdFields_StorageMetadata{} + mi := &file_product_proto_msgTypes[420] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *BreedCharacteristics) String() string { +func (x *RequireStorageMetadataScoreByIdFields_StorageMetadata) String() string { return protoimpl.X.MessageStringOf(x) } -func (*BreedCharacteristics) ProtoMessage() {} +func (*RequireStorageMetadataScoreByIdFields_StorageMetadata) ProtoMessage() {} -func (x *BreedCharacteristics) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[349] +func (x *RequireStorageMetadataScoreByIdFields_StorageMetadata) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[420] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17494,55 +21057,49 @@ func (x *BreedCharacteristics) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use BreedCharacteristics.ProtoReflect.Descriptor instead. -func (*BreedCharacteristics) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{349} -} - -func (x *BreedCharacteristics) GetSize() string { - if x != nil { - return x.Size - } - return "" +// Deprecated: Use RequireStorageMetadataScoreByIdFields_StorageMetadata.ProtoReflect.Descriptor instead. +func (*RequireStorageMetadataScoreByIdFields_StorageMetadata) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{259, 0} } -func (x *BreedCharacteristics) GetTemperament() string { +func (x *RequireStorageMetadataScoreByIdFields_StorageMetadata) GetCapacity() int32 { if x != nil { - return x.Temperament + return x.Capacity } - return "" + return 0 } -func (x *BreedCharacteristics) GetLifespan() string { +func (x *RequireStorageMetadataScoreByIdFields_StorageMetadata) GetZone() string { if x != nil { - return x.Lifespan + return x.Zone } return "" } -type ActionSuccess struct { +type RequireStorageProcessedMetadataByIdFields_StorageMetadata struct { state protoimpl.MessageState `protogen:"open.v1"` - Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"` - Timestamp string `protobuf:"bytes,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"` + Capacity int32 `protobuf:"varint,1,opt,name=capacity,proto3" json:"capacity,omitempty"` + Zone string `protobuf:"bytes,2,opt,name=zone,proto3" json:"zone,omitempty"` + Priority int32 `protobuf:"varint,3,opt,name=priority,proto3" json:"priority,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ActionSuccess) Reset() { - *x = ActionSuccess{} - mi := &file_product_proto_msgTypes[350] +func (x *RequireStorageProcessedMetadataByIdFields_StorageMetadata) Reset() { + *x = RequireStorageProcessedMetadataByIdFields_StorageMetadata{} + mi := &file_product_proto_msgTypes[421] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ActionSuccess) String() string { +func (x *RequireStorageProcessedMetadataByIdFields_StorageMetadata) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ActionSuccess) ProtoMessage() {} +func (*RequireStorageProcessedMetadataByIdFields_StorageMetadata) ProtoMessage() {} -func (x *ActionSuccess) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[350] +func (x *RequireStorageProcessedMetadataByIdFields_StorageMetadata) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[421] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17553,48 +21110,55 @@ func (x *ActionSuccess) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ActionSuccess.ProtoReflect.Descriptor instead. -func (*ActionSuccess) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{350} +// Deprecated: Use RequireStorageProcessedMetadataByIdFields_StorageMetadata.ProtoReflect.Descriptor instead. +func (*RequireStorageProcessedMetadataByIdFields_StorageMetadata) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{264, 0} } -func (x *ActionSuccess) GetMessage() string { +func (x *RequireStorageProcessedMetadataByIdFields_StorageMetadata) GetCapacity() int32 { if x != nil { - return x.Message + return x.Capacity } - return "" + return 0 } -func (x *ActionSuccess) GetTimestamp() string { +func (x *RequireStorageProcessedMetadataByIdFields_StorageMetadata) GetZone() string { if x != nil { - return x.Timestamp + return x.Zone } return "" } -type ActionError struct { +func (x *RequireStorageProcessedMetadataByIdFields_StorageMetadata) GetPriority() int32 { + if x != nil { + return x.Priority + } + return 0 +} + +type RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata struct { state protoimpl.MessageState `protogen:"open.v1"` - Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"` - Code string `protobuf:"bytes,2,opt,name=code,proto3" json:"code,omitempty"` + Capacity int32 `protobuf:"varint,1,opt,name=capacity,proto3" json:"capacity,omitempty"` + Zone string `protobuf:"bytes,2,opt,name=zone,proto3" json:"zone,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ActionError) Reset() { - *x = ActionError{} - mi := &file_product_proto_msgTypes[351] +func (x *RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata) Reset() { + *x = RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata{} + mi := &file_product_proto_msgTypes[422] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ActionError) String() string { +func (x *RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ActionError) ProtoMessage() {} +func (*RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata) ProtoMessage() {} -func (x *ActionError) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[351] +func (x *RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[422] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17605,50 +21169,48 @@ func (x *ActionError) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ActionError.ProtoReflect.Descriptor instead. -func (*ActionError) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{351} +// Deprecated: Use RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata.ProtoReflect.Descriptor instead. +func (*RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{269, 0} } -func (x *ActionError) GetMessage() string { +func (x *RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata) GetCapacity() int32 { if x != nil { - return x.Message + return x.Capacity } - return "" + return 0 } -func (x *ActionError) GetCode() string { +func (x *RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata) GetZone() string { if x != nil { - return x.Code + return x.Zone } return "" } -type TestDetails struct { +type RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata struct { state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Summary string `protobuf:"bytes,2,opt,name=summary,proto3" json:"summary,omitempty"` - Pet *Animal `protobuf:"bytes,3,opt,name=pet,proto3" json:"pet,omitempty"` - Status *ActionResult `protobuf:"bytes,4,opt,name=status,proto3" json:"status,omitempty"` + Capacity int32 `protobuf:"varint,1,opt,name=capacity,proto3" json:"capacity,omitempty"` + Zone string `protobuf:"bytes,2,opt,name=zone,proto3" json:"zone,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *TestDetails) Reset() { - *x = TestDetails{} - mi := &file_product_proto_msgTypes[352] +func (x *RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata) Reset() { + *x = RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata{} + mi := &file_product_proto_msgTypes[423] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *TestDetails) String() string { +func (x *RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata) String() string { return protoimpl.X.MessageStringOf(x) } -func (*TestDetails) ProtoMessage() {} +func (*RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata) ProtoMessage() {} -func (x *TestDetails) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[352] +func (x *RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[423] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17659,62 +21221,48 @@ func (x *TestDetails) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use TestDetails.ProtoReflect.Descriptor instead. -func (*TestDetails) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{352} +// Deprecated: Use RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata.ProtoReflect.Descriptor instead. +func (*RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{284, 0} } -func (x *TestDetails) GetId() string { +func (x *RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata) GetCapacity() int32 { if x != nil { - return x.Id + return x.Capacity } - return "" + return 0 } -func (x *TestDetails) GetSummary() string { +func (x *RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata) GetZone() string { if x != nil { - return x.Summary + return x.Zone } return "" } -func (x *TestDetails) GetPet() *Animal { - if x != nil { - return x.Pet - } - return nil -} - -func (x *TestDetails) GetStatus() *ActionResult { - if x != nil { - return x.Status - } - return nil -} - -type CategoryInput struct { +type RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo struct { state protoimpl.MessageState `protogen:"open.v1"` - Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` - Kind CategoryKind `protobuf:"varint,2,opt,name=kind,proto3,enum=productv1.CategoryKind" json:"kind,omitempty"` + Kind CategoryKind `protobuf:"varint,1,opt,name=kind,proto3,enum=productv1.CategoryKind" json:"kind,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *CategoryInput) Reset() { - *x = CategoryInput{} - mi := &file_product_proto_msgTypes[353] +func (x *RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo) Reset() { + *x = RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo{} + mi := &file_product_proto_msgTypes[424] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *CategoryInput) String() string { +func (x *RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CategoryInput) ProtoMessage() {} +func (*RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo) ProtoMessage() {} -func (x *CategoryInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[353] +func (x *RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[424] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17725,50 +21273,48 @@ func (x *CategoryInput) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use CategoryInput.ProtoReflect.Descriptor instead. -func (*CategoryInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{353} +// Deprecated: Use RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo.ProtoReflect.Descriptor instead. +func (*RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{294, 0} } -func (x *CategoryInput) GetName() string { +func (x *RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo) GetKind() CategoryKind { if x != nil { - return x.Name + return x.Kind } - return "" + return CategoryKind_CATEGORY_KIND_UNSPECIFIED } -func (x *CategoryInput) GetKind() CategoryKind { +func (x *RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo) GetName() string { if x != nil { - return x.Kind + return x.Name } - return CategoryKind_CATEGORY_KIND_UNSPECIFIED + return "" } -type ProductCountFilter struct { - state protoimpl.MessageState `protogen:"open.v1"` - MinPrice *wrapperspb.DoubleValue `protobuf:"bytes,1,opt,name=min_price,json=minPrice,proto3" json:"min_price,omitempty"` - MaxPrice *wrapperspb.DoubleValue `protobuf:"bytes,2,opt,name=max_price,json=maxPrice,proto3" json:"max_price,omitempty"` - InStock *wrapperspb.BoolValue `protobuf:"bytes,3,opt,name=in_stock,json=inStock,proto3" json:"in_stock,omitempty"` - SearchTerm *wrapperspb.StringValue `protobuf:"bytes,4,opt,name=search_term,json=searchTerm,proto3" json:"search_term,omitempty"` +type RequireStorageItemInfoByIdFields_PalletItem struct { + state protoimpl.MessageState `protogen:"open.v1"` + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + PalletCount int32 `protobuf:"varint,2,opt,name=pallet_count,json=palletCount,proto3" json:"pallet_count,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ProductCountFilter) Reset() { - *x = ProductCountFilter{} - mi := &file_product_proto_msgTypes[354] +func (x *RequireStorageItemInfoByIdFields_PalletItem) Reset() { + *x = RequireStorageItemInfoByIdFields_PalletItem{} + mi := &file_product_proto_msgTypes[425] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ProductCountFilter) String() string { +func (x *RequireStorageItemInfoByIdFields_PalletItem) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ProductCountFilter) ProtoMessage() {} +func (*RequireStorageItemInfoByIdFields_PalletItem) ProtoMessage() {} -func (x *ProductCountFilter) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[354] +func (x *RequireStorageItemInfoByIdFields_PalletItem) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[425] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17779,65 +21325,48 @@ func (x *ProductCountFilter) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ProductCountFilter.ProtoReflect.Descriptor instead. -func (*ProductCountFilter) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{354} -} - -func (x *ProductCountFilter) GetMinPrice() *wrapperspb.DoubleValue { - if x != nil { - return x.MinPrice - } - return nil -} - -func (x *ProductCountFilter) GetMaxPrice() *wrapperspb.DoubleValue { - if x != nil { - return x.MaxPrice - } - return nil +// Deprecated: Use RequireStorageItemInfoByIdFields_PalletItem.ProtoReflect.Descriptor instead. +func (*RequireStorageItemInfoByIdFields_PalletItem) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{299, 0} } -func (x *ProductCountFilter) GetInStock() *wrapperspb.BoolValue { +func (x *RequireStorageItemInfoByIdFields_PalletItem) GetName() string { if x != nil { - return x.InStock + return x.Name } - return nil + return "" } -func (x *ProductCountFilter) GetSearchTerm() *wrapperspb.StringValue { +func (x *RequireStorageItemInfoByIdFields_PalletItem) GetPalletCount() int32 { if x != nil { - return x.SearchTerm + return x.PalletCount } - return nil + return 0 } -type SubcategoryItemFilter struct { - state protoimpl.MessageState `protogen:"open.v1"` - MinPrice *wrapperspb.DoubleValue `protobuf:"bytes,1,opt,name=min_price,json=minPrice,proto3" json:"min_price,omitempty"` - MaxPrice *wrapperspb.DoubleValue `protobuf:"bytes,2,opt,name=max_price,json=maxPrice,proto3" json:"max_price,omitempty"` - InStock *wrapperspb.BoolValue `protobuf:"bytes,3,opt,name=in_stock,json=inStock,proto3" json:"in_stock,omitempty"` - IsActive *wrapperspb.BoolValue `protobuf:"bytes,4,opt,name=is_active,json=isActive,proto3" json:"is_active,omitempty"` - SearchTerm *wrapperspb.StringValue `protobuf:"bytes,5,opt,name=search_term,json=searchTerm,proto3" json:"search_term,omitempty"` +type RequireStorageItemInfoByIdFields_ContainerItem struct { + state protoimpl.MessageState `protogen:"open.v1"` + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + ContainerSize string `protobuf:"bytes,2,opt,name=container_size,json=containerSize,proto3" json:"container_size,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *SubcategoryItemFilter) Reset() { - *x = SubcategoryItemFilter{} - mi := &file_product_proto_msgTypes[355] +func (x *RequireStorageItemInfoByIdFields_ContainerItem) Reset() { + *x = RequireStorageItemInfoByIdFields_ContainerItem{} + mi := &file_product_proto_msgTypes[426] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *SubcategoryItemFilter) String() string { +func (x *RequireStorageItemInfoByIdFields_ContainerItem) String() string { return protoimpl.X.MessageStringOf(x) } -func (*SubcategoryItemFilter) ProtoMessage() {} +func (*RequireStorageItemInfoByIdFields_ContainerItem) ProtoMessage() {} -func (x *SubcategoryItemFilter) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[355] +func (x *RequireStorageItemInfoByIdFields_ContainerItem) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[426] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17848,70 +21377,51 @@ func (x *SubcategoryItemFilter) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use SubcategoryItemFilter.ProtoReflect.Descriptor instead. -func (*SubcategoryItemFilter) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{355} -} - -func (x *SubcategoryItemFilter) GetMinPrice() *wrapperspb.DoubleValue { - if x != nil { - return x.MinPrice - } - return nil -} - -func (x *SubcategoryItemFilter) GetMaxPrice() *wrapperspb.DoubleValue { - if x != nil { - return x.MaxPrice - } - return nil -} - -func (x *SubcategoryItemFilter) GetInStock() *wrapperspb.BoolValue { - if x != nil { - return x.InStock - } - return nil +// Deprecated: Use RequireStorageItemInfoByIdFields_ContainerItem.ProtoReflect.Descriptor instead. +func (*RequireStorageItemInfoByIdFields_ContainerItem) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{299, 1} } -func (x *SubcategoryItemFilter) GetIsActive() *wrapperspb.BoolValue { +func (x *RequireStorageItemInfoByIdFields_ContainerItem) GetName() string { if x != nil { - return x.IsActive + return x.Name } - return nil + return "" } -func (x *SubcategoryItemFilter) GetSearchTerm() *wrapperspb.StringValue { +func (x *RequireStorageItemInfoByIdFields_ContainerItem) GetContainerSize() string { if x != nil { - return x.SearchTerm + return x.ContainerSize } - return nil + return "" } -type ShippingEstimateInput struct { - state protoimpl.MessageState `protogen:"open.v1"` - Destination ShippingDestination `protobuf:"varint,1,opt,name=destination,proto3,enum=productv1.ShippingDestination" json:"destination,omitempty"` - Weight float64 `protobuf:"fixed64,2,opt,name=weight,proto3" json:"weight,omitempty"` - Expedited *wrapperspb.BoolValue `protobuf:"bytes,3,opt,name=expedited,proto3" json:"expedited,omitempty"` +type RequireStorageItemInfoByIdFields_StorageItem struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Types that are valid to be assigned to Instance: + // + // *RequireStorageItemInfoByIdFields_StorageItem_ContainerItem + // *RequireStorageItemInfoByIdFields_StorageItem_PalletItem + Instance isRequireStorageItemInfoByIdFields_StorageItem_Instance `protobuf_oneof:"instance"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ShippingEstimateInput) Reset() { - *x = ShippingEstimateInput{} - mi := &file_product_proto_msgTypes[356] +func (x *RequireStorageItemInfoByIdFields_StorageItem) Reset() { + *x = RequireStorageItemInfoByIdFields_StorageItem{} + mi := &file_product_proto_msgTypes[427] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ShippingEstimateInput) String() string { +func (x *RequireStorageItemInfoByIdFields_StorageItem) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ShippingEstimateInput) ProtoMessage() {} +func (*RequireStorageItemInfoByIdFields_StorageItem) ProtoMessage() {} -func (x *ShippingEstimateInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[356] +func (x *RequireStorageItemInfoByIdFields_StorageItem) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[427] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17922,54 +21432,77 @@ func (x *ShippingEstimateInput) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ShippingEstimateInput.ProtoReflect.Descriptor instead. -func (*ShippingEstimateInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{356} +// Deprecated: Use RequireStorageItemInfoByIdFields_StorageItem.ProtoReflect.Descriptor instead. +func (*RequireStorageItemInfoByIdFields_StorageItem) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{299, 2} } -func (x *ShippingEstimateInput) GetDestination() ShippingDestination { +func (x *RequireStorageItemInfoByIdFields_StorageItem) GetInstance() isRequireStorageItemInfoByIdFields_StorageItem_Instance { if x != nil { - return x.Destination + return x.Instance } - return ShippingDestination_SHIPPING_DESTINATION_UNSPECIFIED + return nil } -func (x *ShippingEstimateInput) GetWeight() float64 { +func (x *RequireStorageItemInfoByIdFields_StorageItem) GetContainerItem() *RequireStorageItemInfoByIdFields_ContainerItem { if x != nil { - return x.Weight + if x, ok := x.Instance.(*RequireStorageItemInfoByIdFields_StorageItem_ContainerItem); ok { + return x.ContainerItem + } } - return 0 + return nil } -func (x *ShippingEstimateInput) GetExpedited() *wrapperspb.BoolValue { +func (x *RequireStorageItemInfoByIdFields_StorageItem) GetPalletItem() *RequireStorageItemInfoByIdFields_PalletItem { if x != nil { - return x.Expedited + if x, ok := x.Instance.(*RequireStorageItemInfoByIdFields_StorageItem_PalletItem); ok { + return x.PalletItem + } } return nil } -type ListOfAuthorFilter_List struct { +type isRequireStorageItemInfoByIdFields_StorageItem_Instance interface { + isRequireStorageItemInfoByIdFields_StorageItem_Instance() +} + +type RequireStorageItemInfoByIdFields_StorageItem_ContainerItem struct { + ContainerItem *RequireStorageItemInfoByIdFields_ContainerItem `protobuf:"bytes,1,opt,name=container_item,json=containerItem,proto3,oneof"` +} + +type RequireStorageItemInfoByIdFields_StorageItem_PalletItem struct { + PalletItem *RequireStorageItemInfoByIdFields_PalletItem `protobuf:"bytes,2,opt,name=pallet_item,json=palletItem,proto3,oneof"` +} + +func (*RequireStorageItemInfoByIdFields_StorageItem_ContainerItem) isRequireStorageItemInfoByIdFields_StorageItem_Instance() { +} + +func (*RequireStorageItemInfoByIdFields_StorageItem_PalletItem) isRequireStorageItemInfoByIdFields_StorageItem_Instance() { +} + +type RequireStorageOperationReportByIdFields_StorageSuccess struct { state protoimpl.MessageState `protogen:"open.v1"` - Items []*AuthorFilter `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` + Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"` + CompletedAt string `protobuf:"bytes,2,opt,name=completed_at,json=completedAt,proto3" json:"completed_at,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ListOfAuthorFilter_List) Reset() { - *x = ListOfAuthorFilter_List{} - mi := &file_product_proto_msgTypes[357] +func (x *RequireStorageOperationReportByIdFields_StorageSuccess) Reset() { + *x = RequireStorageOperationReportByIdFields_StorageSuccess{} + mi := &file_product_proto_msgTypes[428] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ListOfAuthorFilter_List) String() string { +func (x *RequireStorageOperationReportByIdFields_StorageSuccess) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListOfAuthorFilter_List) ProtoMessage() {} +func (*RequireStorageOperationReportByIdFields_StorageSuccess) ProtoMessage() {} -func (x *ListOfAuthorFilter_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[357] +func (x *RequireStorageOperationReportByIdFields_StorageSuccess) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[428] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17980,40 +21513,48 @@ func (x *ListOfAuthorFilter_List) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ListOfAuthorFilter_List.ProtoReflect.Descriptor instead. -func (*ListOfAuthorFilter_List) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{0, 0} +// Deprecated: Use RequireStorageOperationReportByIdFields_StorageSuccess.ProtoReflect.Descriptor instead. +func (*RequireStorageOperationReportByIdFields_StorageSuccess) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{304, 0} } -func (x *ListOfAuthorFilter_List) GetItems() []*AuthorFilter { +func (x *RequireStorageOperationReportByIdFields_StorageSuccess) GetMessage() string { if x != nil { - return x.Items + return x.Message } - return nil + return "" } -type ListOfAuthorInput_List struct { +func (x *RequireStorageOperationReportByIdFields_StorageSuccess) GetCompletedAt() string { + if x != nil { + return x.CompletedAt + } + return "" +} + +type RequireStorageOperationReportByIdFields_StorageFailure struct { state protoimpl.MessageState `protogen:"open.v1"` - Items []*AuthorInput `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` + Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"` + ErrorCode string `protobuf:"bytes,2,opt,name=error_code,json=errorCode,proto3" json:"error_code,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ListOfAuthorInput_List) Reset() { - *x = ListOfAuthorInput_List{} - mi := &file_product_proto_msgTypes[358] +func (x *RequireStorageOperationReportByIdFields_StorageFailure) Reset() { + *x = RequireStorageOperationReportByIdFields_StorageFailure{} + mi := &file_product_proto_msgTypes[429] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ListOfAuthorInput_List) String() string { +func (x *RequireStorageOperationReportByIdFields_StorageFailure) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListOfAuthorInput_List) ProtoMessage() {} +func (*RequireStorageOperationReportByIdFields_StorageFailure) ProtoMessage() {} -func (x *ListOfAuthorInput_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[358] +func (x *RequireStorageOperationReportByIdFields_StorageFailure) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[429] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18024,40 +21565,51 @@ func (x *ListOfAuthorInput_List) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ListOfAuthorInput_List.ProtoReflect.Descriptor instead. -func (*ListOfAuthorInput_List) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{1, 0} +// Deprecated: Use RequireStorageOperationReportByIdFields_StorageFailure.ProtoReflect.Descriptor instead. +func (*RequireStorageOperationReportByIdFields_StorageFailure) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{304, 1} } -func (x *ListOfAuthorInput_List) GetItems() []*AuthorInput { +func (x *RequireStorageOperationReportByIdFields_StorageFailure) GetMessage() string { if x != nil { - return x.Items + return x.Message } - return nil + return "" } -type ListOfBlogPost_List struct { - state protoimpl.MessageState `protogen:"open.v1"` - Items []*BlogPost `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` +func (x *RequireStorageOperationReportByIdFields_StorageFailure) GetErrorCode() string { + if x != nil { + return x.ErrorCode + } + return "" +} + +type RequireStorageOperationReportByIdFields_StorageOperationResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Types that are valid to be assigned to Value: + // + // *RequireStorageOperationReportByIdFields_StorageOperationResult_StorageFailure + // *RequireStorageOperationReportByIdFields_StorageOperationResult_StorageSuccess + Value isRequireStorageOperationReportByIdFields_StorageOperationResult_Value `protobuf_oneof:"value"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ListOfBlogPost_List) Reset() { - *x = ListOfBlogPost_List{} - mi := &file_product_proto_msgTypes[359] +func (x *RequireStorageOperationReportByIdFields_StorageOperationResult) Reset() { + *x = RequireStorageOperationReportByIdFields_StorageOperationResult{} + mi := &file_product_proto_msgTypes[430] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ListOfBlogPost_List) String() string { +func (x *RequireStorageOperationReportByIdFields_StorageOperationResult) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListOfBlogPost_List) ProtoMessage() {} +func (*RequireStorageOperationReportByIdFields_StorageOperationResult) ProtoMessage() {} -func (x *ListOfBlogPost_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[359] +func (x *RequireStorageOperationReportByIdFields_StorageOperationResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[430] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18068,40 +21620,77 @@ func (x *ListOfBlogPost_List) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ListOfBlogPost_List.ProtoReflect.Descriptor instead. -func (*ListOfBlogPost_List) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{2, 0} +// Deprecated: Use RequireStorageOperationReportByIdFields_StorageOperationResult.ProtoReflect.Descriptor instead. +func (*RequireStorageOperationReportByIdFields_StorageOperationResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{304, 2} } -func (x *ListOfBlogPost_List) GetItems() []*BlogPost { +func (x *RequireStorageOperationReportByIdFields_StorageOperationResult) GetValue() isRequireStorageOperationReportByIdFields_StorageOperationResult_Value { if x != nil { - return x.Items + return x.Value } return nil } -type ListOfBlogPostFilter_List struct { - state protoimpl.MessageState `protogen:"open.v1"` - Items []*BlogPostFilter `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` +func (x *RequireStorageOperationReportByIdFields_StorageOperationResult) GetStorageFailure() *RequireStorageOperationReportByIdFields_StorageFailure { + if x != nil { + if x, ok := x.Value.(*RequireStorageOperationReportByIdFields_StorageOperationResult_StorageFailure); ok { + return x.StorageFailure + } + } + return nil +} + +func (x *RequireStorageOperationReportByIdFields_StorageOperationResult) GetStorageSuccess() *RequireStorageOperationReportByIdFields_StorageSuccess { + if x != nil { + if x, ok := x.Value.(*RequireStorageOperationReportByIdFields_StorageOperationResult_StorageSuccess); ok { + return x.StorageSuccess + } + } + return nil +} + +type isRequireStorageOperationReportByIdFields_StorageOperationResult_Value interface { + isRequireStorageOperationReportByIdFields_StorageOperationResult_Value() +} + +type RequireStorageOperationReportByIdFields_StorageOperationResult_StorageFailure struct { + StorageFailure *RequireStorageOperationReportByIdFields_StorageFailure `protobuf:"bytes,1,opt,name=storage_failure,json=storageFailure,proto3,oneof"` +} + +type RequireStorageOperationReportByIdFields_StorageOperationResult_StorageSuccess struct { + StorageSuccess *RequireStorageOperationReportByIdFields_StorageSuccess `protobuf:"bytes,2,opt,name=storage_success,json=storageSuccess,proto3,oneof"` +} + +func (*RequireStorageOperationReportByIdFields_StorageOperationResult_StorageFailure) isRequireStorageOperationReportByIdFields_StorageOperationResult_Value() { +} + +func (*RequireStorageOperationReportByIdFields_StorageOperationResult_StorageSuccess) isRequireStorageOperationReportByIdFields_StorageOperationResult_Value() { +} + +type RequireStorageSecuritySummaryByIdFields_SecuritySetup struct { + state protoimpl.MessageState `protogen:"open.v1"` + SecurityLevel string `protobuf:"bytes,1,opt,name=security_level,json=securityLevel,proto3" json:"security_level,omitempty"` + PrimaryItem *RequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem `protobuf:"bytes,2,opt,name=primary_item,json=primaryItem,proto3" json:"primary_item,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ListOfBlogPostFilter_List) Reset() { - *x = ListOfBlogPostFilter_List{} - mi := &file_product_proto_msgTypes[360] +func (x *RequireStorageSecuritySummaryByIdFields_SecuritySetup) Reset() { + *x = RequireStorageSecuritySummaryByIdFields_SecuritySetup{} + mi := &file_product_proto_msgTypes[431] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ListOfBlogPostFilter_List) String() string { +func (x *RequireStorageSecuritySummaryByIdFields_SecuritySetup) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListOfBlogPostFilter_List) ProtoMessage() {} +func (*RequireStorageSecuritySummaryByIdFields_SecuritySetup) ProtoMessage() {} -func (x *ListOfBlogPostFilter_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[360] +func (x *RequireStorageSecuritySummaryByIdFields_SecuritySetup) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[431] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18112,40 +21701,48 @@ func (x *ListOfBlogPostFilter_List) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ListOfBlogPostFilter_List.ProtoReflect.Descriptor instead. -func (*ListOfBlogPostFilter_List) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{3, 0} +// Deprecated: Use RequireStorageSecuritySummaryByIdFields_SecuritySetup.ProtoReflect.Descriptor instead. +func (*RequireStorageSecuritySummaryByIdFields_SecuritySetup) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{309, 0} } -func (x *ListOfBlogPostFilter_List) GetItems() []*BlogPostFilter { +func (x *RequireStorageSecuritySummaryByIdFields_SecuritySetup) GetSecurityLevel() string { if x != nil { - return x.Items + return x.SecurityLevel + } + return "" +} + +func (x *RequireStorageSecuritySummaryByIdFields_SecuritySetup) GetPrimaryItem() *RequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem { + if x != nil { + return x.PrimaryItem } return nil } -type ListOfBlogPostInput_List struct { +type RequireStorageSecuritySummaryByIdFields_SecuritySetup_PalletItem struct { state protoimpl.MessageState `protogen:"open.v1"` - Items []*BlogPostInput `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + PalletCount int32 `protobuf:"varint,2,opt,name=pallet_count,json=palletCount,proto3" json:"pallet_count,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ListOfBlogPostInput_List) Reset() { - *x = ListOfBlogPostInput_List{} - mi := &file_product_proto_msgTypes[361] +func (x *RequireStorageSecuritySummaryByIdFields_SecuritySetup_PalletItem) Reset() { + *x = RequireStorageSecuritySummaryByIdFields_SecuritySetup_PalletItem{} + mi := &file_product_proto_msgTypes[432] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ListOfBlogPostInput_List) String() string { +func (x *RequireStorageSecuritySummaryByIdFields_SecuritySetup_PalletItem) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListOfBlogPostInput_List) ProtoMessage() {} +func (*RequireStorageSecuritySummaryByIdFields_SecuritySetup_PalletItem) ProtoMessage() {} -func (x *ListOfBlogPostInput_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[361] +func (x *RequireStorageSecuritySummaryByIdFields_SecuritySetup_PalletItem) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[432] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18156,40 +21753,48 @@ func (x *ListOfBlogPostInput_List) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ListOfBlogPostInput_List.ProtoReflect.Descriptor instead. -func (*ListOfBlogPostInput_List) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{4, 0} +// Deprecated: Use RequireStorageSecuritySummaryByIdFields_SecuritySetup_PalletItem.ProtoReflect.Descriptor instead. +func (*RequireStorageSecuritySummaryByIdFields_SecuritySetup_PalletItem) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{309, 0, 0} } -func (x *ListOfBlogPostInput_List) GetItems() []*BlogPostInput { +func (x *RequireStorageSecuritySummaryByIdFields_SecuritySetup_PalletItem) GetName() string { if x != nil { - return x.Items + return x.Name } - return nil + return "" } -type ListOfBoolean_List struct { +func (x *RequireStorageSecuritySummaryByIdFields_SecuritySetup_PalletItem) GetPalletCount() int32 { + if x != nil { + return x.PalletCount + } + return 0 +} + +type RequireStorageSecuritySummaryByIdFields_SecuritySetup_ContainerItem struct { state protoimpl.MessageState `protogen:"open.v1"` - Items []bool `protobuf:"varint,1,rep,packed,name=items,proto3" json:"items,omitempty"` + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + ContainerSize string `protobuf:"bytes,2,opt,name=container_size,json=containerSize,proto3" json:"container_size,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ListOfBoolean_List) Reset() { - *x = ListOfBoolean_List{} - mi := &file_product_proto_msgTypes[362] +func (x *RequireStorageSecuritySummaryByIdFields_SecuritySetup_ContainerItem) Reset() { + *x = RequireStorageSecuritySummaryByIdFields_SecuritySetup_ContainerItem{} + mi := &file_product_proto_msgTypes[433] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ListOfBoolean_List) String() string { +func (x *RequireStorageSecuritySummaryByIdFields_SecuritySetup_ContainerItem) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListOfBoolean_List) ProtoMessage() {} +func (*RequireStorageSecuritySummaryByIdFields_SecuritySetup_ContainerItem) ProtoMessage() {} -func (x *ListOfBoolean_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[362] +func (x *RequireStorageSecuritySummaryByIdFields_SecuritySetup_ContainerItem) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[433] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18200,40 +21805,51 @@ func (x *ListOfBoolean_List) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ListOfBoolean_List.ProtoReflect.Descriptor instead. -func (*ListOfBoolean_List) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{5, 0} +// Deprecated: Use RequireStorageSecuritySummaryByIdFields_SecuritySetup_ContainerItem.ProtoReflect.Descriptor instead. +func (*RequireStorageSecuritySummaryByIdFields_SecuritySetup_ContainerItem) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{309, 0, 1} } -func (x *ListOfBoolean_List) GetItems() []bool { +func (x *RequireStorageSecuritySummaryByIdFields_SecuritySetup_ContainerItem) GetName() string { if x != nil { - return x.Items + return x.Name } - return nil + return "" } -type ListOfCategory_List struct { - state protoimpl.MessageState `protogen:"open.v1"` - Items []*Category `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` +func (x *RequireStorageSecuritySummaryByIdFields_SecuritySetup_ContainerItem) GetContainerSize() string { + if x != nil { + return x.ContainerSize + } + return "" +} + +type RequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Types that are valid to be assigned to Instance: + // + // *RequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem_ContainerItem + // *RequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem_PalletItem + Instance isRequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem_Instance `protobuf_oneof:"instance"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ListOfCategory_List) Reset() { - *x = ListOfCategory_List{} - mi := &file_product_proto_msgTypes[363] +func (x *RequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem) Reset() { + *x = RequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem{} + mi := &file_product_proto_msgTypes[434] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ListOfCategory_List) String() string { +func (x *RequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListOfCategory_List) ProtoMessage() {} +func (*RequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem) ProtoMessage() {} -func (x *ListOfCategory_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[363] +func (x *RequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[434] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18244,40 +21860,76 @@ func (x *ListOfCategory_List) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ListOfCategory_List.ProtoReflect.Descriptor instead. -func (*ListOfCategory_List) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{6, 0} +// Deprecated: Use RequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem.ProtoReflect.Descriptor instead. +func (*RequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{309, 0, 2} } -func (x *ListOfCategory_List) GetItems() []*Category { +func (x *RequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem) GetInstance() isRequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem_Instance { if x != nil { - return x.Items + return x.Instance } return nil } -type ListOfCategoryInput_List struct { - state protoimpl.MessageState `protogen:"open.v1"` - Items []*CategoryInput `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` +func (x *RequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem) GetContainerItem() *RequireStorageSecuritySummaryByIdFields_SecuritySetup_ContainerItem { + if x != nil { + if x, ok := x.Instance.(*RequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem_ContainerItem); ok { + return x.ContainerItem + } + } + return nil +} + +func (x *RequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem) GetPalletItem() *RequireStorageSecuritySummaryByIdFields_SecuritySetup_PalletItem { + if x != nil { + if x, ok := x.Instance.(*RequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem_PalletItem); ok { + return x.PalletItem + } + } + return nil +} + +type isRequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem_Instance interface { + isRequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem_Instance() +} + +type RequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem_ContainerItem struct { + ContainerItem *RequireStorageSecuritySummaryByIdFields_SecuritySetup_ContainerItem `protobuf:"bytes,1,opt,name=container_item,json=containerItem,proto3,oneof"` +} + +type RequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem_PalletItem struct { + PalletItem *RequireStorageSecuritySummaryByIdFields_SecuritySetup_PalletItem `protobuf:"bytes,2,opt,name=pallet_item,json=palletItem,proto3,oneof"` +} + +func (*RequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem_ContainerItem) isRequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem_Instance() { +} + +func (*RequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem_PalletItem) isRequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem_Instance() { +} + +type RequireStorageItemHandlerInfoByIdFields_PalletItem struct { + state protoimpl.MessageState `protogen:"open.v1"` + Handler *RequireStorageItemHandlerInfoByIdFields_PalletItem_ItemHandler `protobuf:"bytes,1,opt,name=handler,proto3" json:"handler,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ListOfCategoryInput_List) Reset() { - *x = ListOfCategoryInput_List{} - mi := &file_product_proto_msgTypes[364] +func (x *RequireStorageItemHandlerInfoByIdFields_PalletItem) Reset() { + *x = RequireStorageItemHandlerInfoByIdFields_PalletItem{} + mi := &file_product_proto_msgTypes[435] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ListOfCategoryInput_List) String() string { +func (x *RequireStorageItemHandlerInfoByIdFields_PalletItem) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListOfCategoryInput_List) ProtoMessage() {} +func (*RequireStorageItemHandlerInfoByIdFields_PalletItem) ProtoMessage() {} -func (x *ListOfCategoryInput_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[364] +func (x *RequireStorageItemHandlerInfoByIdFields_PalletItem) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[435] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18288,40 +21940,40 @@ func (x *ListOfCategoryInput_List) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ListOfCategoryInput_List.ProtoReflect.Descriptor instead. -func (*ListOfCategoryInput_List) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{7, 0} +// Deprecated: Use RequireStorageItemHandlerInfoByIdFields_PalletItem.ProtoReflect.Descriptor instead. +func (*RequireStorageItemHandlerInfoByIdFields_PalletItem) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{314, 0} } -func (x *ListOfCategoryInput_List) GetItems() []*CategoryInput { +func (x *RequireStorageItemHandlerInfoByIdFields_PalletItem) GetHandler() *RequireStorageItemHandlerInfoByIdFields_PalletItem_ItemHandler { if x != nil { - return x.Items + return x.Handler } return nil } -type ListOfFloat_List struct { - state protoimpl.MessageState `protogen:"open.v1"` - Items []float64 `protobuf:"fixed64,1,rep,packed,name=items,proto3" json:"items,omitempty"` +type RequireStorageItemHandlerInfoByIdFields_ContainerItem struct { + state protoimpl.MessageState `protogen:"open.v1"` + Handler *RequireStorageItemHandlerInfoByIdFields_ContainerItem_ItemHandler `protobuf:"bytes,1,opt,name=handler,proto3" json:"handler,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ListOfFloat_List) Reset() { - *x = ListOfFloat_List{} - mi := &file_product_proto_msgTypes[365] +func (x *RequireStorageItemHandlerInfoByIdFields_ContainerItem) Reset() { + *x = RequireStorageItemHandlerInfoByIdFields_ContainerItem{} + mi := &file_product_proto_msgTypes[436] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ListOfFloat_List) String() string { +func (x *RequireStorageItemHandlerInfoByIdFields_ContainerItem) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListOfFloat_List) ProtoMessage() {} +func (*RequireStorageItemHandlerInfoByIdFields_ContainerItem) ProtoMessage() {} -func (x *ListOfFloat_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[365] +func (x *RequireStorageItemHandlerInfoByIdFields_ContainerItem) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[436] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18332,40 +21984,44 @@ func (x *ListOfFloat_List) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ListOfFloat_List.ProtoReflect.Descriptor instead. -func (*ListOfFloat_List) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{8, 0} +// Deprecated: Use RequireStorageItemHandlerInfoByIdFields_ContainerItem.ProtoReflect.Descriptor instead. +func (*RequireStorageItemHandlerInfoByIdFields_ContainerItem) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{314, 1} } -func (x *ListOfFloat_List) GetItems() []float64 { +func (x *RequireStorageItemHandlerInfoByIdFields_ContainerItem) GetHandler() *RequireStorageItemHandlerInfoByIdFields_ContainerItem_ItemHandler { if x != nil { - return x.Items + return x.Handler } return nil } -type ListOfListOfCategory_List struct { - state protoimpl.MessageState `protogen:"open.v1"` - Items []*ListOfCategory `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` +type RequireStorageItemHandlerInfoByIdFields_StorageItem struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Types that are valid to be assigned to Instance: + // + // *RequireStorageItemHandlerInfoByIdFields_StorageItem_ContainerItem + // *RequireStorageItemHandlerInfoByIdFields_StorageItem_PalletItem + Instance isRequireStorageItemHandlerInfoByIdFields_StorageItem_Instance `protobuf_oneof:"instance"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ListOfListOfCategory_List) Reset() { - *x = ListOfListOfCategory_List{} - mi := &file_product_proto_msgTypes[366] +func (x *RequireStorageItemHandlerInfoByIdFields_StorageItem) Reset() { + *x = RequireStorageItemHandlerInfoByIdFields_StorageItem{} + mi := &file_product_proto_msgTypes[437] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ListOfListOfCategory_List) String() string { +func (x *RequireStorageItemHandlerInfoByIdFields_StorageItem) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListOfListOfCategory_List) ProtoMessage() {} +func (*RequireStorageItemHandlerInfoByIdFields_StorageItem) ProtoMessage() {} -func (x *ListOfListOfCategory_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[366] +func (x *RequireStorageItemHandlerInfoByIdFields_StorageItem) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[437] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18376,40 +22032,76 @@ func (x *ListOfListOfCategory_List) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ListOfListOfCategory_List.ProtoReflect.Descriptor instead. -func (*ListOfListOfCategory_List) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{9, 0} +// Deprecated: Use RequireStorageItemHandlerInfoByIdFields_StorageItem.ProtoReflect.Descriptor instead. +func (*RequireStorageItemHandlerInfoByIdFields_StorageItem) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{314, 2} } -func (x *ListOfListOfCategory_List) GetItems() []*ListOfCategory { +func (x *RequireStorageItemHandlerInfoByIdFields_StorageItem) GetInstance() isRequireStorageItemHandlerInfoByIdFields_StorageItem_Instance { if x != nil { - return x.Items + return x.Instance } return nil } -type ListOfListOfCategoryInput_List struct { +func (x *RequireStorageItemHandlerInfoByIdFields_StorageItem) GetContainerItem() *RequireStorageItemHandlerInfoByIdFields_ContainerItem { + if x != nil { + if x, ok := x.Instance.(*RequireStorageItemHandlerInfoByIdFields_StorageItem_ContainerItem); ok { + return x.ContainerItem + } + } + return nil +} + +func (x *RequireStorageItemHandlerInfoByIdFields_StorageItem) GetPalletItem() *RequireStorageItemHandlerInfoByIdFields_PalletItem { + if x != nil { + if x, ok := x.Instance.(*RequireStorageItemHandlerInfoByIdFields_StorageItem_PalletItem); ok { + return x.PalletItem + } + } + return nil +} + +type isRequireStorageItemHandlerInfoByIdFields_StorageItem_Instance interface { + isRequireStorageItemHandlerInfoByIdFields_StorageItem_Instance() +} + +type RequireStorageItemHandlerInfoByIdFields_StorageItem_ContainerItem struct { + ContainerItem *RequireStorageItemHandlerInfoByIdFields_ContainerItem `protobuf:"bytes,1,opt,name=container_item,json=containerItem,proto3,oneof"` +} + +type RequireStorageItemHandlerInfoByIdFields_StorageItem_PalletItem struct { + PalletItem *RequireStorageItemHandlerInfoByIdFields_PalletItem `protobuf:"bytes,2,opt,name=pallet_item,json=palletItem,proto3,oneof"` +} + +func (*RequireStorageItemHandlerInfoByIdFields_StorageItem_ContainerItem) isRequireStorageItemHandlerInfoByIdFields_StorageItem_Instance() { +} + +func (*RequireStorageItemHandlerInfoByIdFields_StorageItem_PalletItem) isRequireStorageItemHandlerInfoByIdFields_StorageItem_Instance() { +} + +type RequireStorageItemHandlerInfoByIdFields_PalletItem_ItemHandler struct { state protoimpl.MessageState `protogen:"open.v1"` - Items []*ListOfCategoryInput `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ListOfListOfCategoryInput_List) Reset() { - *x = ListOfListOfCategoryInput_List{} - mi := &file_product_proto_msgTypes[367] +func (x *RequireStorageItemHandlerInfoByIdFields_PalletItem_ItemHandler) Reset() { + *x = RequireStorageItemHandlerInfoByIdFields_PalletItem_ItemHandler{} + mi := &file_product_proto_msgTypes[438] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ListOfListOfCategoryInput_List) String() string { +func (x *RequireStorageItemHandlerInfoByIdFields_PalletItem_ItemHandler) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListOfListOfCategoryInput_List) ProtoMessage() {} +func (*RequireStorageItemHandlerInfoByIdFields_PalletItem_ItemHandler) ProtoMessage() {} -func (x *ListOfListOfCategoryInput_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[367] +func (x *RequireStorageItemHandlerInfoByIdFields_PalletItem_ItemHandler) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[438] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18420,40 +22112,40 @@ func (x *ListOfListOfCategoryInput_List) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ListOfListOfCategoryInput_List.ProtoReflect.Descriptor instead. -func (*ListOfListOfCategoryInput_List) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{10, 0} +// Deprecated: Use RequireStorageItemHandlerInfoByIdFields_PalletItem_ItemHandler.ProtoReflect.Descriptor instead. +func (*RequireStorageItemHandlerInfoByIdFields_PalletItem_ItemHandler) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{314, 0, 0} } -func (x *ListOfListOfCategoryInput_List) GetItems() []*ListOfCategoryInput { +func (x *RequireStorageItemHandlerInfoByIdFields_PalletItem_ItemHandler) GetName() string { if x != nil { - return x.Items + return x.Name } - return nil + return "" } -type ListOfListOfString_List struct { +type RequireStorageItemHandlerInfoByIdFields_ContainerItem_ItemHandler struct { state protoimpl.MessageState `protogen:"open.v1"` - Items []*ListOfString `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ListOfListOfString_List) Reset() { - *x = ListOfListOfString_List{} - mi := &file_product_proto_msgTypes[368] +func (x *RequireStorageItemHandlerInfoByIdFields_ContainerItem_ItemHandler) Reset() { + *x = RequireStorageItemHandlerInfoByIdFields_ContainerItem_ItemHandler{} + mi := &file_product_proto_msgTypes[439] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ListOfListOfString_List) String() string { +func (x *RequireStorageItemHandlerInfoByIdFields_ContainerItem_ItemHandler) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListOfListOfString_List) ProtoMessage() {} +func (*RequireStorageItemHandlerInfoByIdFields_ContainerItem_ItemHandler) ProtoMessage() {} -func (x *ListOfListOfString_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[368] +func (x *RequireStorageItemHandlerInfoByIdFields_ContainerItem_ItemHandler) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[439] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18464,40 +22156,40 @@ func (x *ListOfListOfString_List) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ListOfListOfString_List.ProtoReflect.Descriptor instead. -func (*ListOfListOfString_List) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{11, 0} +// Deprecated: Use RequireStorageItemHandlerInfoByIdFields_ContainerItem_ItemHandler.ProtoReflect.Descriptor instead. +func (*RequireStorageItemHandlerInfoByIdFields_ContainerItem_ItemHandler) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{314, 1, 0} } -func (x *ListOfListOfString_List) GetItems() []*ListOfString { +func (x *RequireStorageItemHandlerInfoByIdFields_ContainerItem_ItemHandler) GetName() string { if x != nil { - return x.Items + return x.Name } - return nil + return "" } -type ListOfListOfUser_List struct { - state protoimpl.MessageState `protogen:"open.v1"` - Items []*ListOfUser `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` +type RequireStorageItemSpecsInfoByIdFields_PalletItem struct { + state protoimpl.MessageState `protogen:"open.v1"` + Specs *RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs `protobuf:"bytes,1,opt,name=specs,proto3" json:"specs,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ListOfListOfUser_List) Reset() { - *x = ListOfListOfUser_List{} - mi := &file_product_proto_msgTypes[369] +func (x *RequireStorageItemSpecsInfoByIdFields_PalletItem) Reset() { + *x = RequireStorageItemSpecsInfoByIdFields_PalletItem{} + mi := &file_product_proto_msgTypes[440] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ListOfListOfUser_List) String() string { +func (x *RequireStorageItemSpecsInfoByIdFields_PalletItem) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListOfListOfUser_List) ProtoMessage() {} +func (*RequireStorageItemSpecsInfoByIdFields_PalletItem) ProtoMessage() {} -func (x *ListOfListOfUser_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[369] +func (x *RequireStorageItemSpecsInfoByIdFields_PalletItem) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[440] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18508,40 +22200,40 @@ func (x *ListOfListOfUser_List) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ListOfListOfUser_List.ProtoReflect.Descriptor instead. -func (*ListOfListOfUser_List) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{12, 0} +// Deprecated: Use RequireStorageItemSpecsInfoByIdFields_PalletItem.ProtoReflect.Descriptor instead. +func (*RequireStorageItemSpecsInfoByIdFields_PalletItem) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{319, 0} } -func (x *ListOfListOfUser_List) GetItems() []*ListOfUser { +func (x *RequireStorageItemSpecsInfoByIdFields_PalletItem) GetSpecs() *RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs { if x != nil { - return x.Items + return x.Specs } return nil } -type ListOfListOfUserInput_List struct { - state protoimpl.MessageState `protogen:"open.v1"` - Items []*ListOfUserInput `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` +type RequireStorageItemSpecsInfoByIdFields_ContainerItem struct { + state protoimpl.MessageState `protogen:"open.v1"` + Specs *RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs `protobuf:"bytes,1,opt,name=specs,proto3" json:"specs,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ListOfListOfUserInput_List) Reset() { - *x = ListOfListOfUserInput_List{} - mi := &file_product_proto_msgTypes[370] +func (x *RequireStorageItemSpecsInfoByIdFields_ContainerItem) Reset() { + *x = RequireStorageItemSpecsInfoByIdFields_ContainerItem{} + mi := &file_product_proto_msgTypes[441] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ListOfListOfUserInput_List) String() string { +func (x *RequireStorageItemSpecsInfoByIdFields_ContainerItem) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListOfListOfUserInput_List) ProtoMessage() {} +func (*RequireStorageItemSpecsInfoByIdFields_ContainerItem) ProtoMessage() {} -func (x *ListOfListOfUserInput_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[370] +func (x *RequireStorageItemSpecsInfoByIdFields_ContainerItem) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[441] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18552,40 +22244,44 @@ func (x *ListOfListOfUserInput_List) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ListOfListOfUserInput_List.ProtoReflect.Descriptor instead. -func (*ListOfListOfUserInput_List) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{13, 0} +// Deprecated: Use RequireStorageItemSpecsInfoByIdFields_ContainerItem.ProtoReflect.Descriptor instead. +func (*RequireStorageItemSpecsInfoByIdFields_ContainerItem) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{319, 1} } -func (x *ListOfListOfUserInput_List) GetItems() []*ListOfUserInput { +func (x *RequireStorageItemSpecsInfoByIdFields_ContainerItem) GetSpecs() *RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs { if x != nil { - return x.Items + return x.Specs } return nil } -type ListOfOrderLine_List struct { - state protoimpl.MessageState `protogen:"open.v1"` - Items []*OrderLine `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` +type RequireStorageItemSpecsInfoByIdFields_StorageItem struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Types that are valid to be assigned to Instance: + // + // *RequireStorageItemSpecsInfoByIdFields_StorageItem_ContainerItem + // *RequireStorageItemSpecsInfoByIdFields_StorageItem_PalletItem + Instance isRequireStorageItemSpecsInfoByIdFields_StorageItem_Instance `protobuf_oneof:"instance"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ListOfOrderLine_List) Reset() { - *x = ListOfOrderLine_List{} - mi := &file_product_proto_msgTypes[371] +func (x *RequireStorageItemSpecsInfoByIdFields_StorageItem) Reset() { + *x = RequireStorageItemSpecsInfoByIdFields_StorageItem{} + mi := &file_product_proto_msgTypes[442] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ListOfOrderLine_List) String() string { +func (x *RequireStorageItemSpecsInfoByIdFields_StorageItem) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListOfOrderLine_List) ProtoMessage() {} +func (*RequireStorageItemSpecsInfoByIdFields_StorageItem) ProtoMessage() {} -func (x *ListOfOrderLine_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[371] +func (x *RequireStorageItemSpecsInfoByIdFields_StorageItem) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[442] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18596,40 +22292,77 @@ func (x *ListOfOrderLine_List) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ListOfOrderLine_List.ProtoReflect.Descriptor instead. -func (*ListOfOrderLine_List) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{14, 0} +// Deprecated: Use RequireStorageItemSpecsInfoByIdFields_StorageItem.ProtoReflect.Descriptor instead. +func (*RequireStorageItemSpecsInfoByIdFields_StorageItem) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{319, 2} } -func (x *ListOfOrderLine_List) GetItems() []*OrderLine { +func (x *RequireStorageItemSpecsInfoByIdFields_StorageItem) GetInstance() isRequireStorageItemSpecsInfoByIdFields_StorageItem_Instance { if x != nil { - return x.Items + return x.Instance } return nil } -type ListOfProduct_List struct { - state protoimpl.MessageState `protogen:"open.v1"` - Items []*Product `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` +func (x *RequireStorageItemSpecsInfoByIdFields_StorageItem) GetContainerItem() *RequireStorageItemSpecsInfoByIdFields_ContainerItem { + if x != nil { + if x, ok := x.Instance.(*RequireStorageItemSpecsInfoByIdFields_StorageItem_ContainerItem); ok { + return x.ContainerItem + } + } + return nil +} + +func (x *RequireStorageItemSpecsInfoByIdFields_StorageItem) GetPalletItem() *RequireStorageItemSpecsInfoByIdFields_PalletItem { + if x != nil { + if x, ok := x.Instance.(*RequireStorageItemSpecsInfoByIdFields_StorageItem_PalletItem); ok { + return x.PalletItem + } + } + return nil +} + +type isRequireStorageItemSpecsInfoByIdFields_StorageItem_Instance interface { + isRequireStorageItemSpecsInfoByIdFields_StorageItem_Instance() +} + +type RequireStorageItemSpecsInfoByIdFields_StorageItem_ContainerItem struct { + ContainerItem *RequireStorageItemSpecsInfoByIdFields_ContainerItem `protobuf:"bytes,1,opt,name=container_item,json=containerItem,proto3,oneof"` +} + +type RequireStorageItemSpecsInfoByIdFields_StorageItem_PalletItem struct { + PalletItem *RequireStorageItemSpecsInfoByIdFields_PalletItem `protobuf:"bytes,2,opt,name=pallet_item,json=palletItem,proto3,oneof"` +} + +func (*RequireStorageItemSpecsInfoByIdFields_StorageItem_ContainerItem) isRequireStorageItemSpecsInfoByIdFields_StorageItem_Instance() { +} + +func (*RequireStorageItemSpecsInfoByIdFields_StorageItem_PalletItem) isRequireStorageItemSpecsInfoByIdFields_StorageItem_Instance() { +} + +type RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs struct { + state protoimpl.MessageState `protogen:"open.v1"` + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Dimensions *RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs_Dimensions `protobuf:"bytes,2,opt,name=dimensions,proto3" json:"dimensions,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ListOfProduct_List) Reset() { - *x = ListOfProduct_List{} - mi := &file_product_proto_msgTypes[372] +func (x *RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs) Reset() { + *x = RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs{} + mi := &file_product_proto_msgTypes[443] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ListOfProduct_List) String() string { +func (x *RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListOfProduct_List) ProtoMessage() {} +func (*RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs) ProtoMessage() {} -func (x *ListOfProduct_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[372] +func (x *RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[443] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18640,40 +22373,48 @@ func (x *ListOfProduct_List) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ListOfProduct_List.ProtoReflect.Descriptor instead. -func (*ListOfProduct_List) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{15, 0} +// Deprecated: Use RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs.ProtoReflect.Descriptor instead. +func (*RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{319, 0, 0} } -func (x *ListOfProduct_List) GetItems() []*Product { +func (x *RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs) GetName() string { if x != nil { - return x.Items + return x.Name + } + return "" +} + +func (x *RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs) GetDimensions() *RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs_Dimensions { + if x != nil { + return x.Dimensions } return nil } -type ListOfStorage_List struct { +type RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs_Dimensions struct { state protoimpl.MessageState `protogen:"open.v1"` - Items []*Storage `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` + Length float64 `protobuf:"fixed64,1,opt,name=length,proto3" json:"length,omitempty"` + Width float64 `protobuf:"fixed64,2,opt,name=width,proto3" json:"width,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ListOfStorage_List) Reset() { - *x = ListOfStorage_List{} - mi := &file_product_proto_msgTypes[373] +func (x *RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs_Dimensions) Reset() { + *x = RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs_Dimensions{} + mi := &file_product_proto_msgTypes[444] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ListOfStorage_List) String() string { +func (x *RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs_Dimensions) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListOfStorage_List) ProtoMessage() {} +func (*RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs_Dimensions) ProtoMessage() {} -func (x *ListOfStorage_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[373] +func (x *RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs_Dimensions) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[444] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18684,40 +22425,48 @@ func (x *ListOfStorage_List) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ListOfStorage_List.ProtoReflect.Descriptor instead. -func (*ListOfStorage_List) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{16, 0} +// Deprecated: Use RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs_Dimensions.ProtoReflect.Descriptor instead. +func (*RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs_Dimensions) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{319, 0, 0, 0} } -func (x *ListOfStorage_List) GetItems() []*Storage { +func (x *RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs_Dimensions) GetLength() float64 { if x != nil { - return x.Items + return x.Length } - return nil + return 0 } -type ListOfString_List struct { - state protoimpl.MessageState `protogen:"open.v1"` - Items []string `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` +func (x *RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs_Dimensions) GetWidth() float64 { + if x != nil { + return x.Width + } + return 0 +} + +type RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs struct { + state protoimpl.MessageState `protogen:"open.v1"` + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Dimensions *RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs_Dimensions `protobuf:"bytes,2,opt,name=dimensions,proto3" json:"dimensions,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ListOfString_List) Reset() { - *x = ListOfString_List{} - mi := &file_product_proto_msgTypes[374] +func (x *RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs) Reset() { + *x = RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs{} + mi := &file_product_proto_msgTypes[445] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ListOfString_List) String() string { +func (x *RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListOfString_List) ProtoMessage() {} +func (*RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs) ProtoMessage() {} -func (x *ListOfString_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[374] +func (x *RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[445] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18728,40 +22477,49 @@ func (x *ListOfString_List) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ListOfString_List.ProtoReflect.Descriptor instead. -func (*ListOfString_List) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{17, 0} +// Deprecated: Use RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs.ProtoReflect.Descriptor instead. +func (*RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{319, 1, 0} } -func (x *ListOfString_List) GetItems() []string { +func (x *RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs) GetName() string { if x != nil { - return x.Items + return x.Name + } + return "" +} + +func (x *RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs) GetDimensions() *RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs_Dimensions { + if x != nil { + return x.Dimensions } return nil } -type ListOfSubcategory_List struct { +type RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs_Dimensions struct { state protoimpl.MessageState `protogen:"open.v1"` - Items []*Subcategory `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` + Length float64 `protobuf:"fixed64,1,opt,name=length,proto3" json:"length,omitempty"` + Width float64 `protobuf:"fixed64,2,opt,name=width,proto3" json:"width,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ListOfSubcategory_List) Reset() { - *x = ListOfSubcategory_List{} - mi := &file_product_proto_msgTypes[375] +func (x *RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs_Dimensions) Reset() { + *x = RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs_Dimensions{} + mi := &file_product_proto_msgTypes[446] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ListOfSubcategory_List) String() string { +func (x *RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs_Dimensions) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListOfSubcategory_List) ProtoMessage() {} +func (*RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs_Dimensions) ProtoMessage() { +} -func (x *ListOfSubcategory_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[375] +func (x *RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs_Dimensions) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[446] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18772,40 +22530,47 @@ func (x *ListOfSubcategory_List) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ListOfSubcategory_List.ProtoReflect.Descriptor instead. -func (*ListOfSubcategory_List) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{18, 0} +// Deprecated: Use RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs_Dimensions.ProtoReflect.Descriptor instead. +func (*RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs_Dimensions) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{319, 1, 0, 0} } -func (x *ListOfSubcategory_List) GetItems() []*Subcategory { +func (x *RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs_Dimensions) GetLength() float64 { if x != nil { - return x.Items + return x.Length } - return nil + return 0 } -type ListOfUser_List struct { - state protoimpl.MessageState `protogen:"open.v1"` - Items []*User `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` +func (x *RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs_Dimensions) GetWidth() float64 { + if x != nil { + return x.Width + } + return 0 +} + +type RequireStorageDeepItemInfoByIdFields_PalletItem struct { + state protoimpl.MessageState `protogen:"open.v1"` + Handler *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler `protobuf:"bytes,1,opt,name=handler,proto3" json:"handler,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } - -func (x *ListOfUser_List) Reset() { - *x = ListOfUser_List{} - mi := &file_product_proto_msgTypes[376] + +func (x *RequireStorageDeepItemInfoByIdFields_PalletItem) Reset() { + *x = RequireStorageDeepItemInfoByIdFields_PalletItem{} + mi := &file_product_proto_msgTypes[447] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ListOfUser_List) String() string { +func (x *RequireStorageDeepItemInfoByIdFields_PalletItem) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListOfUser_List) ProtoMessage() {} +func (*RequireStorageDeepItemInfoByIdFields_PalletItem) ProtoMessage() {} -func (x *ListOfUser_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[376] +func (x *RequireStorageDeepItemInfoByIdFields_PalletItem) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[447] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18816,40 +22581,40 @@ func (x *ListOfUser_List) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ListOfUser_List.ProtoReflect.Descriptor instead. -func (*ListOfUser_List) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{19, 0} +// Deprecated: Use RequireStorageDeepItemInfoByIdFields_PalletItem.ProtoReflect.Descriptor instead. +func (*RequireStorageDeepItemInfoByIdFields_PalletItem) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{324, 0} } -func (x *ListOfUser_List) GetItems() []*User { +func (x *RequireStorageDeepItemInfoByIdFields_PalletItem) GetHandler() *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler { if x != nil { - return x.Items + return x.Handler } return nil } -type ListOfUserInput_List struct { - state protoimpl.MessageState `protogen:"open.v1"` - Items []*UserInput `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` +type RequireStorageDeepItemInfoByIdFields_ContainerItem struct { + state protoimpl.MessageState `protogen:"open.v1"` + Handler *RequireStorageDeepItemInfoByIdFields_ContainerItem_ItemHandler `protobuf:"bytes,1,opt,name=handler,proto3" json:"handler,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ListOfUserInput_List) Reset() { - *x = ListOfUserInput_List{} - mi := &file_product_proto_msgTypes[377] +func (x *RequireStorageDeepItemInfoByIdFields_ContainerItem) Reset() { + *x = RequireStorageDeepItemInfoByIdFields_ContainerItem{} + mi := &file_product_proto_msgTypes[448] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ListOfUserInput_List) String() string { +func (x *RequireStorageDeepItemInfoByIdFields_ContainerItem) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListOfUserInput_List) ProtoMessage() {} +func (*RequireStorageDeepItemInfoByIdFields_ContainerItem) ProtoMessage() {} -func (x *ListOfUserInput_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[377] +func (x *RequireStorageDeepItemInfoByIdFields_ContainerItem) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[448] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18860,40 +22625,44 @@ func (x *ListOfUserInput_List) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ListOfUserInput_List.ProtoReflect.Descriptor instead. -func (*ListOfUserInput_List) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{20, 0} +// Deprecated: Use RequireStorageDeepItemInfoByIdFields_ContainerItem.ProtoReflect.Descriptor instead. +func (*RequireStorageDeepItemInfoByIdFields_ContainerItem) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{324, 1} } -func (x *ListOfUserInput_List) GetItems() []*UserInput { +func (x *RequireStorageDeepItemInfoByIdFields_ContainerItem) GetHandler() *RequireStorageDeepItemInfoByIdFields_ContainerItem_ItemHandler { if x != nil { - return x.Items + return x.Handler } return nil } -type RequireStorageStockHealthScoreByIdFields_RestockData struct { - state protoimpl.MessageState `protogen:"open.v1"` - LastRestockDate string `protobuf:"bytes,1,opt,name=last_restock_date,json=lastRestockDate,proto3" json:"last_restock_date,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type RequireStorageDeepItemInfoByIdFields_StorageItem struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Types that are valid to be assigned to Instance: + // + // *RequireStorageDeepItemInfoByIdFields_StorageItem_ContainerItem + // *RequireStorageDeepItemInfoByIdFields_StorageItem_PalletItem + Instance isRequireStorageDeepItemInfoByIdFields_StorageItem_Instance `protobuf_oneof:"instance"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *RequireStorageStockHealthScoreByIdFields_RestockData) Reset() { - *x = RequireStorageStockHealthScoreByIdFields_RestockData{} - mi := &file_product_proto_msgTypes[378] +func (x *RequireStorageDeepItemInfoByIdFields_StorageItem) Reset() { + *x = RequireStorageDeepItemInfoByIdFields_StorageItem{} + mi := &file_product_proto_msgTypes[449] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageStockHealthScoreByIdFields_RestockData) String() string { +func (x *RequireStorageDeepItemInfoByIdFields_StorageItem) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageStockHealthScoreByIdFields_RestockData) ProtoMessage() {} +func (*RequireStorageDeepItemInfoByIdFields_StorageItem) ProtoMessage() {} -func (x *RequireStorageStockHealthScoreByIdFields_RestockData) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[378] +func (x *RequireStorageDeepItemInfoByIdFields_StorageItem) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[449] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18904,41 +22673,76 @@ func (x *RequireStorageStockHealthScoreByIdFields_RestockData) ProtoReflect() pr return mi.MessageOf(x) } -// Deprecated: Use RequireStorageStockHealthScoreByIdFields_RestockData.ProtoReflect.Descriptor instead. -func (*RequireStorageStockHealthScoreByIdFields_RestockData) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{244, 0} +// Deprecated: Use RequireStorageDeepItemInfoByIdFields_StorageItem.ProtoReflect.Descriptor instead. +func (*RequireStorageDeepItemInfoByIdFields_StorageItem) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{324, 2} } -func (x *RequireStorageStockHealthScoreByIdFields_RestockData) GetLastRestockDate() string { +func (x *RequireStorageDeepItemInfoByIdFields_StorageItem) GetInstance() isRequireStorageDeepItemInfoByIdFields_StorageItem_Instance { if x != nil { - return x.LastRestockDate + return x.Instance } - return "" + return nil } -type RequireStorageMetadataScoreByIdFields_StorageMetadata struct { - state protoimpl.MessageState `protogen:"open.v1"` - Capacity int32 `protobuf:"varint,1,opt,name=capacity,proto3" json:"capacity,omitempty"` - Zone string `protobuf:"bytes,2,opt,name=zone,proto3" json:"zone,omitempty"` +func (x *RequireStorageDeepItemInfoByIdFields_StorageItem) GetContainerItem() *RequireStorageDeepItemInfoByIdFields_ContainerItem { + if x != nil { + if x, ok := x.Instance.(*RequireStorageDeepItemInfoByIdFields_StorageItem_ContainerItem); ok { + return x.ContainerItem + } + } + return nil +} + +func (x *RequireStorageDeepItemInfoByIdFields_StorageItem) GetPalletItem() *RequireStorageDeepItemInfoByIdFields_PalletItem { + if x != nil { + if x, ok := x.Instance.(*RequireStorageDeepItemInfoByIdFields_StorageItem_PalletItem); ok { + return x.PalletItem + } + } + return nil +} + +type isRequireStorageDeepItemInfoByIdFields_StorageItem_Instance interface { + isRequireStorageDeepItemInfoByIdFields_StorageItem_Instance() +} + +type RequireStorageDeepItemInfoByIdFields_StorageItem_ContainerItem struct { + ContainerItem *RequireStorageDeepItemInfoByIdFields_ContainerItem `protobuf:"bytes,1,opt,name=container_item,json=containerItem,proto3,oneof"` +} + +type RequireStorageDeepItemInfoByIdFields_StorageItem_PalletItem struct { + PalletItem *RequireStorageDeepItemInfoByIdFields_PalletItem `protobuf:"bytes,2,opt,name=pallet_item,json=palletItem,proto3,oneof"` +} + +func (*RequireStorageDeepItemInfoByIdFields_StorageItem_ContainerItem) isRequireStorageDeepItemInfoByIdFields_StorageItem_Instance() { +} + +func (*RequireStorageDeepItemInfoByIdFields_StorageItem_PalletItem) isRequireStorageDeepItemInfoByIdFields_StorageItem_Instance() { +} + +type RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler struct { + state protoimpl.MessageState `protogen:"open.v1"` + AssignedItem *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem `protobuf:"bytes,1,opt,name=assigned_item,json=assignedItem,proto3" json:"assigned_item,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageMetadataScoreByIdFields_StorageMetadata) Reset() { - *x = RequireStorageMetadataScoreByIdFields_StorageMetadata{} - mi := &file_product_proto_msgTypes[379] +func (x *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler) Reset() { + *x = RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler{} + mi := &file_product_proto_msgTypes[450] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageMetadataScoreByIdFields_StorageMetadata) String() string { +func (x *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageMetadataScoreByIdFields_StorageMetadata) ProtoMessage() {} +func (*RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler) ProtoMessage() {} -func (x *RequireStorageMetadataScoreByIdFields_StorageMetadata) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[379] +func (x *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[450] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18949,49 +22753,41 @@ func (x *RequireStorageMetadataScoreByIdFields_StorageMetadata) ProtoReflect() p return mi.MessageOf(x) } -// Deprecated: Use RequireStorageMetadataScoreByIdFields_StorageMetadata.ProtoReflect.Descriptor instead. -func (*RequireStorageMetadataScoreByIdFields_StorageMetadata) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{259, 0} -} - -func (x *RequireStorageMetadataScoreByIdFields_StorageMetadata) GetCapacity() int32 { - if x != nil { - return x.Capacity - } - return 0 +// Deprecated: Use RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler.ProtoReflect.Descriptor instead. +func (*RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{324, 0, 0} } -func (x *RequireStorageMetadataScoreByIdFields_StorageMetadata) GetZone() string { +func (x *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler) GetAssignedItem() *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem { if x != nil { - return x.Zone + return x.AssignedItem } - return "" + return nil } -type RequireStorageProcessedMetadataByIdFields_StorageMetadata struct { +type RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_ContainerItem struct { state protoimpl.MessageState `protogen:"open.v1"` - Capacity int32 `protobuf:"varint,1,opt,name=capacity,proto3" json:"capacity,omitempty"` - Zone string `protobuf:"bytes,2,opt,name=zone,proto3" json:"zone,omitempty"` - Priority int32 `protobuf:"varint,3,opt,name=priority,proto3" json:"priority,omitempty"` + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + ContainerSize string `protobuf:"bytes,2,opt,name=container_size,json=containerSize,proto3" json:"container_size,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageProcessedMetadataByIdFields_StorageMetadata) Reset() { - *x = RequireStorageProcessedMetadataByIdFields_StorageMetadata{} - mi := &file_product_proto_msgTypes[380] +func (x *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_ContainerItem) Reset() { + *x = RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_ContainerItem{} + mi := &file_product_proto_msgTypes[451] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageProcessedMetadataByIdFields_StorageMetadata) String() string { +func (x *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_ContainerItem) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageProcessedMetadataByIdFields_StorageMetadata) ProtoMessage() {} +func (*RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_ContainerItem) ProtoMessage() {} -func (x *RequireStorageProcessedMetadataByIdFields_StorageMetadata) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[380] +func (x *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_ContainerItem) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[451] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -19002,55 +22798,48 @@ func (x *RequireStorageProcessedMetadataByIdFields_StorageMetadata) ProtoReflect return mi.MessageOf(x) } -// Deprecated: Use RequireStorageProcessedMetadataByIdFields_StorageMetadata.ProtoReflect.Descriptor instead. -func (*RequireStorageProcessedMetadataByIdFields_StorageMetadata) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{264, 0} -} - -func (x *RequireStorageProcessedMetadataByIdFields_StorageMetadata) GetCapacity() int32 { - if x != nil { - return x.Capacity - } - return 0 +// Deprecated: Use RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_ContainerItem.ProtoReflect.Descriptor instead. +func (*RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_ContainerItem) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{324, 0, 0, 0} } -func (x *RequireStorageProcessedMetadataByIdFields_StorageMetadata) GetZone() string { +func (x *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_ContainerItem) GetName() string { if x != nil { - return x.Zone + return x.Name } return "" } -func (x *RequireStorageProcessedMetadataByIdFields_StorageMetadata) GetPriority() int32 { +func (x *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_ContainerItem) GetContainerSize() string { if x != nil { - return x.Priority + return x.ContainerSize } - return 0 + return "" } -type RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata struct { +type RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_PalletItem struct { state protoimpl.MessageState `protogen:"open.v1"` - Capacity int32 `protobuf:"varint,1,opt,name=capacity,proto3" json:"capacity,omitempty"` - Zone string `protobuf:"bytes,2,opt,name=zone,proto3" json:"zone,omitempty"` + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + PalletCount int32 `protobuf:"varint,2,opt,name=pallet_count,json=palletCount,proto3" json:"pallet_count,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata) Reset() { - *x = RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata{} - mi := &file_product_proto_msgTypes[381] +func (x *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_PalletItem) Reset() { + *x = RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_PalletItem{} + mi := &file_product_proto_msgTypes[452] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata) String() string { +func (x *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_PalletItem) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata) ProtoMessage() {} +func (*RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_PalletItem) ProtoMessage() {} -func (x *RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[381] +func (x *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_PalletItem) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[452] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -19061,48 +22850,51 @@ func (x *RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata) Prot return mi.MessageOf(x) } -// Deprecated: Use RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata.ProtoReflect.Descriptor instead. -func (*RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{269, 0} +// Deprecated: Use RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_PalletItem.ProtoReflect.Descriptor instead. +func (*RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_PalletItem) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{324, 0, 0, 1} } -func (x *RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata) GetCapacity() int32 { +func (x *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_PalletItem) GetName() string { if x != nil { - return x.Capacity + return x.Name } - return 0 + return "" } -func (x *RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata) GetZone() string { +func (x *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_PalletItem) GetPalletCount() int32 { if x != nil { - return x.Zone + return x.PalletCount } - return "" + return 0 } -type RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata struct { - state protoimpl.MessageState `protogen:"open.v1"` - Capacity int32 `protobuf:"varint,1,opt,name=capacity,proto3" json:"capacity,omitempty"` - Zone string `protobuf:"bytes,2,opt,name=zone,proto3" json:"zone,omitempty"` +type RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Types that are valid to be assigned to Instance: + // + // *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem_ContainerItem + // *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem_PalletItem + Instance isRequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem_Instance `protobuf_oneof:"instance"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata) Reset() { - *x = RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata{} - mi := &file_product_proto_msgTypes[382] +func (x *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem) Reset() { + *x = RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem{} + mi := &file_product_proto_msgTypes[453] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata) String() string { +func (x *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata) ProtoMessage() {} +func (*RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem) ProtoMessage() {} -func (x *RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[382] +func (x *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[453] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -19113,48 +22905,76 @@ func (x *RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata) Proto return mi.MessageOf(x) } -// Deprecated: Use RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata.ProtoReflect.Descriptor instead. -func (*RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{284, 0} +// Deprecated: Use RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem.ProtoReflect.Descriptor instead. +func (*RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{324, 0, 0, 2} } -func (x *RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata) GetCapacity() int32 { +func (x *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem) GetInstance() isRequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem_Instance { if x != nil { - return x.Capacity + return x.Instance } - return 0 + return nil } -func (x *RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata) GetZone() string { +func (x *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem) GetContainerItem() *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_ContainerItem { if x != nil { - return x.Zone + if x, ok := x.Instance.(*RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem_ContainerItem); ok { + return x.ContainerItem + } } - return "" + return nil } -type RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo struct { +func (x *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem) GetPalletItem() *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_PalletItem { + if x != nil { + if x, ok := x.Instance.(*RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem_PalletItem); ok { + return x.PalletItem + } + } + return nil +} + +type isRequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem_Instance interface { + isRequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem_Instance() +} + +type RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem_ContainerItem struct { + ContainerItem *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_ContainerItem `protobuf:"bytes,1,opt,name=container_item,json=containerItem,proto3,oneof"` +} + +type RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem_PalletItem struct { + PalletItem *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_PalletItem `protobuf:"bytes,2,opt,name=pallet_item,json=palletItem,proto3,oneof"` +} + +func (*RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem_ContainerItem) isRequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem_Instance() { +} + +func (*RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem_PalletItem) isRequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem_Instance() { +} + +type RequireStorageDeepItemInfoByIdFields_ContainerItem_ItemHandler struct { state protoimpl.MessageState `protogen:"open.v1"` - Kind CategoryKind `protobuf:"varint,1,opt,name=kind,proto3,enum=productv1.CategoryKind" json:"kind,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo) Reset() { - *x = RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo{} - mi := &file_product_proto_msgTypes[383] +func (x *RequireStorageDeepItemInfoByIdFields_ContainerItem_ItemHandler) Reset() { + *x = RequireStorageDeepItemInfoByIdFields_ContainerItem_ItemHandler{} + mi := &file_product_proto_msgTypes[454] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo) String() string { +func (x *RequireStorageDeepItemInfoByIdFields_ContainerItem_ItemHandler) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo) ProtoMessage() {} +func (*RequireStorageDeepItemInfoByIdFields_ContainerItem_ItemHandler) ProtoMessage() {} -func (x *RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[383] +func (x *RequireStorageDeepItemInfoByIdFields_ContainerItem_ItemHandler) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[454] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -19165,19 +22985,12 @@ func (x *RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo) ProtoR return mi.MessageOf(x) } -// Deprecated: Use RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo.ProtoReflect.Descriptor instead. -func (*RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{294, 0} -} - -func (x *RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo) GetKind() CategoryKind { - if x != nil { - return x.Kind - } - return CategoryKind_CATEGORY_KIND_UNSPECIFIED +// Deprecated: Use RequireStorageDeepItemInfoByIdFields_ContainerItem_ItemHandler.ProtoReflect.Descriptor instead. +func (*RequireStorageDeepItemInfoByIdFields_ContainerItem_ItemHandler) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{324, 1, 0} } -func (x *RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo) GetName() string { +func (x *RequireStorageDeepItemInfoByIdFields_ContainerItem_ItemHandler) GetName() string { if x != nil { return x.Name } @@ -19193,7 +23006,7 @@ type RequireWarehouseStockHealthScoreByIdFields_RestockData struct { func (x *RequireWarehouseStockHealthScoreByIdFields_RestockData) Reset() { *x = RequireWarehouseStockHealthScoreByIdFields_RestockData{} - mi := &file_product_proto_msgTypes[384] + mi := &file_product_proto_msgTypes[455] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -19205,7 +23018,7 @@ func (x *RequireWarehouseStockHealthScoreByIdFields_RestockData) String() string func (*RequireWarehouseStockHealthScoreByIdFields_RestockData) ProtoMessage() {} func (x *RequireWarehouseStockHealthScoreByIdFields_RestockData) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[384] + mi := &file_product_proto_msgTypes[455] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -19218,7 +23031,7 @@ func (x *RequireWarehouseStockHealthScoreByIdFields_RestockData) ProtoReflect() // Deprecated: Use RequireWarehouseStockHealthScoreByIdFields_RestockData.ProtoReflect.Descriptor instead. func (*RequireWarehouseStockHealthScoreByIdFields_RestockData) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{299, 0} + return file_product_proto_rawDescGZIP(), []int{329, 0} } func (x *RequireWarehouseStockHealthScoreByIdFields_RestockData) GetLastRestockDate() string { @@ -19964,7 +23777,185 @@ const file_product_proto_rawDesc = "" + "\rcategory_info\x18\x01 \x01(\v2J.productv1.RequireStorageCategoryInfoSummaryByIdFields.StorageCategoryInfoR\fcategoryInfo\x1aV\n" + "\x13StorageCategoryInfo\x12+\n" + "\x04kind\x18\x01 \x01(\x0e2\x17.productv1.CategoryKindR\x04kind\x12\x12\n" + - "\x04name\x18\x02 \x01(\tR\x04name\"\x7f\n" + + "\x04name\x18\x02 \x01(\tR\x04name\"k\n" + + "!RequireStorageItemInfoByIdRequest\x12F\n" + + "\acontext\x18\x01 \x03(\v2,.productv1.RequireStorageItemInfoByIdContextR\acontext\"\xa2\x01\n" + + "!RequireStorageItemInfoByIdContext\x128\n" + + "\x03key\x18\x01 \x01(\v2&.productv1.LookupStorageByIdRequestKeyR\x03key\x12C\n" + + "\x06fields\x18\x02 \x01(\v2+.productv1.RequireStorageItemInfoByIdFieldsR\x06fields\"i\n" + + "\"RequireStorageItemInfoByIdResponse\x12C\n" + + "\x06result\x18\x01 \x03(\v2+.productv1.RequireStorageItemInfoByIdResultR\x06result\"?\n" + + " RequireStorageItemInfoByIdResult\x12\x1b\n" + + "\titem_info\x18\x01 \x01(\tR\bitemInfo\"\xea\x03\n" + + " RequireStorageItemInfoByIdFields\x12Z\n" + + "\fprimary_item\x18\x01 \x01(\v27.productv1.RequireStorageItemInfoByIdFields.StorageItemR\vprimaryItem\x1aC\n" + + "\n" + + "PalletItem\x12\x12\n" + + "\x04name\x18\x01 \x01(\tR\x04name\x12!\n" + + "\fpallet_count\x18\x02 \x01(\x05R\vpalletCount\x1aJ\n" + + "\rContainerItem\x12\x12\n" + + "\x04name\x18\x01 \x01(\tR\x04name\x12%\n" + + "\x0econtainer_size\x18\x02 \x01(\tR\rcontainerSize\x1a\xd8\x01\n" + + "\vStorageItem\x12b\n" + + "\x0econtainer_item\x18\x01 \x01(\v29.productv1.RequireStorageItemInfoByIdFields.ContainerItemH\x00R\rcontainerItem\x12Y\n" + + "\vpallet_item\x18\x02 \x01(\v26.productv1.RequireStorageItemInfoByIdFields.PalletItemH\x00R\n" + + "palletItemB\n" + + "\n" + + "\binstance\"y\n" + + "(RequireStorageOperationReportByIdRequest\x12M\n" + + "\acontext\x18\x01 \x03(\v23.productv1.RequireStorageOperationReportByIdContextR\acontext\"\xb0\x01\n" + + "(RequireStorageOperationReportByIdContext\x128\n" + + "\x03key\x18\x01 \x01(\v2&.productv1.LookupStorageByIdRequestKeyR\x03key\x12J\n" + + "\x06fields\x18\x02 \x01(\v22.productv1.RequireStorageOperationReportByIdFieldsR\x06fields\"w\n" + + ")RequireStorageOperationReportByIdResponse\x12J\n" + + "\x06result\x18\x01 \x03(\v22.productv1.RequireStorageOperationReportByIdResultR\x06result\"T\n" + + "'RequireStorageOperationReportByIdResult\x12)\n" + + "\x10operation_report\x18\x01 \x01(\tR\x0foperationReport\"\xc4\x04\n" + + "'RequireStorageOperationReportByIdFields\x12\x7f\n" + + "\x16last_storage_operation\x18\x01 \x01(\v2I.productv1.RequireStorageOperationReportByIdFields.StorageOperationResultR\x14lastStorageOperation\x1aM\n" + + "\x0eStorageSuccess\x12\x18\n" + + "\amessage\x18\x01 \x01(\tR\amessage\x12!\n" + + "\fcompleted_at\x18\x02 \x01(\tR\vcompletedAt\x1aI\n" + + "\x0eStorageFailure\x12\x18\n" + + "\amessage\x18\x01 \x01(\tR\amessage\x12\x1d\n" + + "\n" + + "error_code\x18\x02 \x01(\tR\terrorCode\x1a\xfd\x01\n" + + "\x16StorageOperationResult\x12l\n" + + "\x0fstorage_failure\x18\x01 \x01(\v2A.productv1.RequireStorageOperationReportByIdFields.StorageFailureH\x00R\x0estorageFailure\x12l\n" + + "\x0fstorage_success\x18\x02 \x01(\v2A.productv1.RequireStorageOperationReportByIdFields.StorageSuccessH\x00R\x0estorageSuccessB\a\n" + + "\x05value\"y\n" + + "(RequireStorageSecuritySummaryByIdRequest\x12M\n" + + "\acontext\x18\x01 \x03(\v23.productv1.RequireStorageSecuritySummaryByIdContextR\acontext\"\xb0\x01\n" + + "(RequireStorageSecuritySummaryByIdContext\x128\n" + + "\x03key\x18\x01 \x01(\v2&.productv1.LookupStorageByIdRequestKeyR\x03key\x12J\n" + + "\x06fields\x18\x02 \x01(\v22.productv1.RequireStorageSecuritySummaryByIdFieldsR\x06fields\"w\n" + + ")RequireStorageSecuritySummaryByIdResponse\x12J\n" + + "\x06result\x18\x01 \x03(\v22.productv1.RequireStorageSecuritySummaryByIdResultR\x06result\"T\n" + + "'RequireStorageSecuritySummaryByIdResult\x12)\n" + + "\x10security_summary\x18\x01 \x01(\tR\x0fsecuritySummary\"\xd2\x05\n" + + "'RequireStorageSecuritySummaryByIdFields\x12g\n" + + "\x0esecurity_setup\x18\x01 \x01(\v2@.productv1.RequireStorageSecuritySummaryByIdFields.SecuritySetupR\rsecuritySetup\x1a\xbd\x04\n" + + "\rSecuritySetup\x12%\n" + + "\x0esecurity_level\x18\x01 \x01(\tR\rsecurityLevel\x12o\n" + + "\fprimary_item\x18\x02 \x01(\v2L.productv1.RequireStorageSecuritySummaryByIdFields.SecuritySetup.StorageItemR\vprimaryItem\x1aC\n" + + "\n" + + "PalletItem\x12\x12\n" + + "\x04name\x18\x01 \x01(\tR\x04name\x12!\n" + + "\fpallet_count\x18\x02 \x01(\x05R\vpalletCount\x1aJ\n" + + "\rContainerItem\x12\x12\n" + + "\x04name\x18\x01 \x01(\tR\x04name\x12%\n" + + "\x0econtainer_size\x18\x02 \x01(\tR\rcontainerSize\x1a\x82\x02\n" + + "\vStorageItem\x12w\n" + + "\x0econtainer_item\x18\x01 \x01(\v2N.productv1.RequireStorageSecuritySummaryByIdFields.SecuritySetup.ContainerItemH\x00R\rcontainerItem\x12n\n" + + "\vpallet_item\x18\x02 \x01(\v2K.productv1.RequireStorageSecuritySummaryByIdFields.SecuritySetup.PalletItemH\x00R\n" + + "palletItemB\n" + + "\n" + + "\binstance\"y\n" + + "(RequireStorageItemHandlerInfoByIdRequest\x12M\n" + + "\acontext\x18\x01 \x03(\v23.productv1.RequireStorageItemHandlerInfoByIdContextR\acontext\"\xb0\x01\n" + + "(RequireStorageItemHandlerInfoByIdContext\x128\n" + + "\x03key\x18\x01 \x01(\v2&.productv1.LookupStorageByIdRequestKeyR\x03key\x12J\n" + + "\x06fields\x18\x02 \x01(\v22.productv1.RequireStorageItemHandlerInfoByIdFieldsR\x06fields\"w\n" + + ")RequireStorageItemHandlerInfoByIdResponse\x12J\n" + + "\x06result\x18\x01 \x03(\v22.productv1.RequireStorageItemHandlerInfoByIdResultR\x06result\"U\n" + + "'RequireStorageItemHandlerInfoByIdResult\x12*\n" + + "\x11item_handler_info\x18\x01 \x01(\tR\x0fitemHandlerInfo\"\xa9\x05\n" + + "'RequireStorageItemHandlerInfoByIdFields\x12a\n" + + "\fprimary_item\x18\x01 \x01(\v2>.productv1.RequireStorageItemHandlerInfoByIdFields.StorageItemR\vprimaryItem\x1a\x94\x01\n" + + "\n" + + "PalletItem\x12c\n" + + "\ahandler\x18\x01 \x01(\v2I.productv1.RequireStorageItemHandlerInfoByIdFields.PalletItem.ItemHandlerR\ahandler\x1a!\n" + + "\vItemHandler\x12\x12\n" + + "\x04name\x18\x01 \x01(\tR\x04name\x1a\x9a\x01\n" + + "\rContainerItem\x12f\n" + + "\ahandler\x18\x01 \x01(\v2L.productv1.RequireStorageItemHandlerInfoByIdFields.ContainerItem.ItemHandlerR\ahandler\x1a!\n" + + "\vItemHandler\x12\x12\n" + + "\x04name\x18\x01 \x01(\tR\x04name\x1a\xe6\x01\n" + + "\vStorageItem\x12i\n" + + "\x0econtainer_item\x18\x01 \x01(\v2@.productv1.RequireStorageItemHandlerInfoByIdFields.ContainerItemH\x00R\rcontainerItem\x12`\n" + + "\vpallet_item\x18\x02 \x01(\v2=.productv1.RequireStorageItemHandlerInfoByIdFields.PalletItemH\x00R\n" + + "palletItemB\n" + + "\n" + + "\binstance\"u\n" + + "&RequireStorageItemSpecsInfoByIdRequest\x12K\n" + + "\acontext\x18\x01 \x03(\v21.productv1.RequireStorageItemSpecsInfoByIdContextR\acontext\"\xac\x01\n" + + "&RequireStorageItemSpecsInfoByIdContext\x128\n" + + "\x03key\x18\x01 \x01(\v2&.productv1.LookupStorageByIdRequestKeyR\x03key\x12H\n" + + "\x06fields\x18\x02 \x01(\v20.productv1.RequireStorageItemSpecsInfoByIdFieldsR\x06fields\"s\n" + + "'RequireStorageItemSpecsInfoByIdResponse\x12H\n" + + "\x06result\x18\x01 \x03(\v20.productv1.RequireStorageItemSpecsInfoByIdResultR\x06result\"O\n" + + "%RequireStorageItemSpecsInfoByIdResult\x12&\n" + + "\x0fitem_specs_info\x18\x01 \x01(\tR\ritemSpecsInfo\"\x83\b\n" + + "%RequireStorageItemSpecsInfoByIdFields\x12_\n" + + "\fprimary_item\x18\x01 \x01(\v2<.productv1.RequireStorageItemSpecsInfoByIdFields.StorageItemR\vprimaryItem\x1a\xbf\x02\n" + + "\n" + + "PalletItem\x12]\n" + + "\x05specs\x18\x01 \x01(\v2G.productv1.RequireStorageItemSpecsInfoByIdFields.PalletItem.PalletSpecsR\x05specs\x1a\xd1\x01\n" + + "\vPalletSpecs\x12\x12\n" + + "\x04name\x18\x01 \x01(\tR\x04name\x12r\n" + + "\n" + + "dimensions\x18\x02 \x01(\v2R.productv1.RequireStorageItemSpecsInfoByIdFields.PalletItem.PalletSpecs.DimensionsR\n" + + "dimensions\x1a:\n" + + "\n" + + "Dimensions\x12\x16\n" + + "\x06length\x18\x01 \x01(\x01R\x06length\x12\x14\n" + + "\x05width\x18\x02 \x01(\x01R\x05width\x1a\xd1\x02\n" + + "\rContainerItem\x12c\n" + + "\x05specs\x18\x01 \x01(\v2M.productv1.RequireStorageItemSpecsInfoByIdFields.ContainerItem.ContainerSpecsR\x05specs\x1a\xda\x01\n" + + "\x0eContainerSpecs\x12\x12\n" + + "\x04name\x18\x01 \x01(\tR\x04name\x12x\n" + + "\n" + + "dimensions\x18\x02 \x01(\v2X.productv1.RequireStorageItemSpecsInfoByIdFields.ContainerItem.ContainerSpecs.DimensionsR\n" + + "dimensions\x1a:\n" + + "\n" + + "Dimensions\x12\x16\n" + + "\x06length\x18\x01 \x01(\x01R\x06length\x12\x14\n" + + "\x05width\x18\x02 \x01(\x01R\x05width\x1a\xe2\x01\n" + + "\vStorageItem\x12g\n" + + "\x0econtainer_item\x18\x01 \x01(\v2>.productv1.RequireStorageItemSpecsInfoByIdFields.ContainerItemH\x00R\rcontainerItem\x12^\n" + + "\vpallet_item\x18\x02 \x01(\v2;.productv1.RequireStorageItemSpecsInfoByIdFields.PalletItemH\x00R\n" + + "palletItemB\n" + + "\n" + + "\binstance\"s\n" + + "%RequireStorageDeepItemInfoByIdRequest\x12J\n" + + "\acontext\x18\x01 \x03(\v20.productv1.RequireStorageDeepItemInfoByIdContextR\acontext\"\xaa\x01\n" + + "%RequireStorageDeepItemInfoByIdContext\x128\n" + + "\x03key\x18\x01 \x01(\v2&.productv1.LookupStorageByIdRequestKeyR\x03key\x12G\n" + + "\x06fields\x18\x02 \x01(\v2/.productv1.RequireStorageDeepItemInfoByIdFieldsR\x06fields\"q\n" + + "&RequireStorageDeepItemInfoByIdResponse\x12G\n" + + "\x06result\x18\x01 \x03(\v2/.productv1.RequireStorageDeepItemInfoByIdResultR\x06result\"L\n" + + "$RequireStorageDeepItemInfoByIdResult\x12$\n" + + "\x0edeep_item_info\x18\x01 \x01(\tR\fdeepItemInfo\"\x9f\t\n" + + "$RequireStorageDeepItemInfoByIdFields\x12^\n" + + "\fprimary_item\x18\x01 \x01(\v2;.productv1.RequireStorageDeepItemInfoByIdFields.StorageItemR\vprimaryItem\x1a\x99\x05\n" + + "\n" + + "PalletItem\x12`\n" + + "\ahandler\x18\x01 \x01(\v2F.productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.ItemHandlerR\ahandler\x1a\xa8\x04\n" + + "\vItemHandler\x12w\n" + + "\rassigned_item\x18\x01 \x01(\v2R.productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.ItemHandler.StorageItemR\fassignedItem\x1aJ\n" + + "\rContainerItem\x12\x12\n" + + "\x04name\x18\x01 \x01(\tR\x04name\x12%\n" + + "\x0econtainer_size\x18\x02 \x01(\tR\rcontainerSize\x1aC\n" + + "\n" + + "PalletItem\x12\x12\n" + + "\x04name\x18\x01 \x01(\tR\x04name\x12!\n" + + "\fpallet_count\x18\x02 \x01(\x05R\vpalletCount\x1a\x8e\x02\n" + + "\vStorageItem\x12}\n" + + "\x0econtainer_item\x18\x01 \x01(\v2T.productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.ItemHandler.ContainerItemH\x00R\rcontainerItem\x12t\n" + + "\vpallet_item\x18\x02 \x01(\v2Q.productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.ItemHandler.PalletItemH\x00R\n" + + "palletItemB\n" + + "\n" + + "\binstance\x1a\x97\x01\n" + + "\rContainerItem\x12c\n" + + "\ahandler\x18\x01 \x01(\v2I.productv1.RequireStorageDeepItemInfoByIdFields.ContainerItem.ItemHandlerR\ahandler\x1a!\n" + + "\vItemHandler\x12\x12\n" + + "\x04name\x18\x01 \x01(\tR\x04name\x1a\xe0\x01\n" + + "\vStorageItem\x12f\n" + + "\x0econtainer_item\x18\x01 \x01(\v2=.productv1.RequireStorageDeepItemInfoByIdFields.ContainerItemH\x00R\rcontainerItem\x12]\n" + + "\vpallet_item\x18\x02 \x01(\v2:.productv1.RequireStorageDeepItemInfoByIdFields.PalletItemH\x00R\n" + + "palletItemB\n" + + "\n" + + "\binstance\"\x7f\n" + "+RequireWarehouseStockHealthScoreByIdRequest\x12P\n" + "\acontext\x18\x01 \x03(\v26.productv1.RequireWarehouseStockHealthScoreByIdContextR\acontext\"\xb8\x01\n" + "+RequireWarehouseStockHealthScoreByIdContext\x12:\n" + @@ -20270,7 +24261,64 @@ const file_product_proto_rawDesc = "" + "\x14BreedCharacteristics\x12\x12\n" + "\x04size\x18\x01 \x01(\tR\x04size\x12 \n" + "\vtemperament\x18\x02 \x01(\tR\vtemperament\x12\x1a\n" + - "\blifespan\x18\x03 \x01(\tR\blifespan\"G\n" + + "\blifespan\x18\x03 \x01(\tR\blifespan\"\x96\x01\n" + + "\vStorageItem\x128\n" + + "\vpallet_item\x18\x01 \x01(\v2\x15.productv1.PalletItemH\x00R\n" + + "palletItem\x12A\n" + + "\x0econtainer_item\x18\x02 \x01(\v2\x18.productv1.ContainerItemH\x00R\rcontainerItemB\n" + + "\n" + + "\binstance\"\xcb\x01\n" + + "\n" + + "PalletItem\x12\x0e\n" + + "\x02id\x18\x01 \x01(\tR\x02id\x12\x12\n" + + "\x04name\x18\x02 \x01(\tR\x04name\x12\x16\n" + + "\x06weight\x18\x03 \x01(\x01R\x06weight\x12!\n" + + "\fpallet_count\x18\x04 \x01(\x05R\vpalletCount\x120\n" + + "\ahandler\x18\x05 \x01(\v2\x16.productv1.ItemHandlerR\ahandler\x12,\n" + + "\x05specs\x18\x06 \x01(\v2\x16.productv1.PalletSpecsR\x05specs\"\xd5\x01\n" + + "\rContainerItem\x12\x0e\n" + + "\x02id\x18\x01 \x01(\tR\x02id\x12\x12\n" + + "\x04name\x18\x02 \x01(\tR\x04name\x12\x16\n" + + "\x06weight\x18\x03 \x01(\x01R\x06weight\x12%\n" + + "\x0econtainer_size\x18\x04 \x01(\tR\rcontainerSize\x120\n" + + "\ahandler\x18\x05 \x01(\v2\x16.productv1.ItemHandlerR\ahandler\x12/\n" + + "\x05specs\x18\x06 \x01(\v2\x19.productv1.ContainerSpecsR\x05specs\"n\n" + + "\vItemHandler\x12\x0e\n" + + "\x02id\x18\x01 \x01(\tR\x02id\x12\x12\n" + + "\x04name\x18\x02 \x01(\tR\x04name\x12;\n" + + "\rassigned_item\x18\x03 \x01(\v2\x16.productv1.StorageItemR\fassignedItem\"w\n" + + "\vPalletSpecs\x12\x12\n" + + "\x04name\x18\x01 \x01(\tR\x04name\x12\x1d\n" + + "\n" + + "max_weight\x18\x02 \x01(\x01R\tmaxWeight\x125\n" + + "\n" + + "dimensions\x18\x03 \x01(\v2\x15.productv1.DimensionsR\n" + + "dimensions\"s\n" + + "\x0eContainerSpecs\x12\x12\n" + + "\x04name\x18\x01 \x01(\tR\x04name\x12\x16\n" + + "\x06volume\x18\x02 \x01(\x01R\x06volume\x125\n" + + "\n" + + "dimensions\x18\x03 \x01(\v2\x15.productv1.DimensionsR\n" + + "dimensions\"R\n" + + "\n" + + "Dimensions\x12\x16\n" + + "\x06length\x18\x01 \x01(\x01R\x06length\x12\x14\n" + + "\x05width\x18\x02 \x01(\x01R\x05width\x12\x16\n" + + "\x06height\x18\x03 \x01(\x01R\x06height\"\xad\x01\n" + + "\x16StorageOperationResult\x12D\n" + + "\x0fstorage_success\x18\x01 \x01(\v2\x19.productv1.StorageSuccessH\x00R\x0estorageSuccess\x12D\n" + + "\x0fstorage_failure\x18\x02 \x01(\v2\x19.productv1.StorageFailureH\x00R\x0estorageFailureB\a\n" + + "\x05value\"M\n" + + "\x0eStorageSuccess\x12\x18\n" + + "\amessage\x18\x01 \x01(\tR\amessage\x12!\n" + + "\fcompleted_at\x18\x02 \x01(\tR\vcompletedAt\"I\n" + + "\x0eStorageFailure\x12\x18\n" + + "\amessage\x18\x01 \x01(\tR\amessage\x12\x1d\n" + + "\n" + + "error_code\x18\x02 \x01(\tR\terrorCode\"q\n" + + "\rSecuritySetup\x12%\n" + + "\x0esecurity_level\x18\x01 \x01(\tR\rsecurityLevel\x129\n" + + "\fprimary_item\x18\x02 \x01(\v2\x16.productv1.StorageItemR\vprimaryItem\"G\n" + "\rActionSuccess\x12\x18\n" + "\amessage\x18\x01 \x01(\tR\amessage\x12\x1c\n" + "\ttimestamp\x18\x02 \x01(\tR\ttimestamp\";\n" + @@ -20312,7 +24360,7 @@ const file_product_proto_rawDesc = "" + " SHIPPING_DESTINATION_UNSPECIFIED\x10\x00\x12!\n" + "\x1dSHIPPING_DESTINATION_DOMESTIC\x10\x01\x12 \n" + "\x1cSHIPPING_DESTINATION_EXPRESS\x10\x02\x12&\n" + - "\"SHIPPING_DESTINATION_INTERNATIONAL\x10\x032\x84R\n" + + "\"SHIPPING_DESTINATION_INTERNATIONAL\x10\x032\xd1X\n" + "\x0eProductService\x12`\n" + "\x11LookupProductById\x12#.productv1.LookupProductByIdRequest\x1a$.productv1.LookupProductByIdResponse\"\x00\x12`\n" + "\x11LookupStorageById\x12#.productv1.LookupStorageByIdRequest\x1a$.productv1.LookupStorageByIdResponse\"\x00\x12f\n" + @@ -20363,15 +24411,21 @@ const file_product_proto_rawDesc = "" + "\tQueryUser\x12\x1b.productv1.QueryUserRequest\x1a\x1c.productv1.QueryUserResponse\"\x00\x12K\n" + "\n" + "QueryUsers\x12\x1c.productv1.QueryUsersRequest\x1a\x1d.productv1.QueryUsersResponse\"\x00\x12\x9c\x01\n" + - "%RequireStorageCategoryInfoSummaryById\x127.productv1.RequireStorageCategoryInfoSummaryByIdRequest\x1a8.productv1.RequireStorageCategoryInfoSummaryByIdResponse\"\x00\x12\x84\x01\n" + + "%RequireStorageCategoryInfoSummaryById\x127.productv1.RequireStorageCategoryInfoSummaryByIdRequest\x1a8.productv1.RequireStorageCategoryInfoSummaryByIdResponse\"\x00\x12\x87\x01\n" + + "\x1eRequireStorageDeepItemInfoById\x120.productv1.RequireStorageDeepItemInfoByIdRequest\x1a1.productv1.RequireStorageDeepItemInfoByIdResponse\"\x00\x12\x90\x01\n" + + "!RequireStorageItemHandlerInfoById\x123.productv1.RequireStorageItemHandlerInfoByIdRequest\x1a4.productv1.RequireStorageItemHandlerInfoByIdResponse\"\x00\x12{\n" + + "\x1aRequireStorageItemInfoById\x12,.productv1.RequireStorageItemInfoByIdRequest\x1a-.productv1.RequireStorageItemInfoByIdResponse\"\x00\x12\x8a\x01\n" + + "\x1fRequireStorageItemSpecsInfoById\x121.productv1.RequireStorageItemSpecsInfoByIdRequest\x1a2.productv1.RequireStorageItemSpecsInfoByIdResponse\"\x00\x12\x84\x01\n" + "\x1dRequireStorageKindSummaryById\x12/.productv1.RequireStorageKindSummaryByIdRequest\x1a0.productv1.RequireStorageKindSummaryByIdResponse\"\x00\x12\x8a\x01\n" + - "\x1fRequireStorageMetadataScoreById\x121.productv1.RequireStorageMetadataScoreByIdRequest\x1a2.productv1.RequireStorageMetadataScoreByIdResponse\"\x00\x12\xae\x01\n" + + "\x1fRequireStorageMetadataScoreById\x121.productv1.RequireStorageMetadataScoreByIdRequest\x1a2.productv1.RequireStorageMetadataScoreByIdResponse\"\x00\x12\x90\x01\n" + + "!RequireStorageOperationReportById\x123.productv1.RequireStorageOperationReportByIdRequest\x1a4.productv1.RequireStorageOperationReportByIdResponse\"\x00\x12\xae\x01\n" + "+RequireStorageOptionalProcessedMetadataById\x12=.productv1.RequireStorageOptionalProcessedMetadataByIdRequest\x1a>.productv1.RequireStorageOptionalProcessedMetadataByIdResponse\"\x00\x12\xa2\x01\n" + "'RequireStorageOptionalProcessedTagsById\x129.productv1.RequireStorageOptionalProcessedTagsByIdRequest\x1a:.productv1.RequireStorageOptionalProcessedTagsByIdResponse\"\x00\x12\x99\x01\n" + "$RequireStorageOptionalTagSummaryById\x126.productv1.RequireStorageOptionalTagSummaryByIdRequest\x1a7.productv1.RequireStorageOptionalTagSummaryByIdResponse\"\x00\x12\x96\x01\n" + "#RequireStorageProcessedMetadataById\x125.productv1.RequireStorageProcessedMetadataByIdRequest\x1a6.productv1.RequireStorageProcessedMetadataByIdResponse\"\x00\x12\xab\x01\n" + "*RequireStorageProcessedMetadataHistoryById\x12<.productv1.RequireStorageProcessedMetadataHistoryByIdRequest\x1a=.productv1.RequireStorageProcessedMetadataHistoryByIdResponse\"\x00\x12\x8a\x01\n" + - "\x1fRequireStorageProcessedTagsById\x121.productv1.RequireStorageProcessedTagsByIdRequest\x1a2.productv1.RequireStorageProcessedTagsByIdResponse\"\x00\x12\x93\x01\n" + + "\x1fRequireStorageProcessedTagsById\x121.productv1.RequireStorageProcessedTagsByIdRequest\x1a2.productv1.RequireStorageProcessedTagsByIdResponse\"\x00\x12\x90\x01\n" + + "!RequireStorageSecuritySummaryById\x123.productv1.RequireStorageSecuritySummaryByIdRequest\x1a4.productv1.RequireStorageSecuritySummaryByIdResponse\"\x00\x12\x93\x01\n" + "\"RequireStorageStockHealthScoreById\x124.productv1.RequireStorageStockHealthScoreByIdRequest\x1a5.productv1.RequireStorageStockHealthScoreByIdResponse\"\x00\x12\x81\x01\n" + "\x1cRequireStorageTagSummaryById\x12..productv1.RequireStorageTagSummaryByIdRequest\x1a/.productv1.RequireStorageTagSummaryByIdResponse\"\x00\x12\x99\x01\n" + "$RequireWarehouseStockHealthScoreById\x126.productv1.RequireWarehouseStockHealthScoreByIdRequest\x1a7.productv1.RequireWarehouseStockHealthScoreByIdResponse\"\x00\x12\x93\x01\n" + @@ -20414,7 +24468,7 @@ func file_product_proto_rawDescGZIP() []byte { } var file_product_proto_enumTypes = make([]protoimpl.EnumInfo, 2) -var file_product_proto_msgTypes = make([]protoimpl.MessageInfo, 385) +var file_product_proto_msgTypes = make([]protoimpl.MessageInfo, 456) var file_product_proto_goTypes = []any{ (CategoryKind)(0), // 0: productv1.CategoryKind (ShippingDestination)(0), // 1: productv1.ShippingDestination @@ -20713,259 +24767,330 @@ var file_product_proto_goTypes = []any{ (*RequireStorageCategoryInfoSummaryByIdResponse)(nil), // 294: productv1.RequireStorageCategoryInfoSummaryByIdResponse (*RequireStorageCategoryInfoSummaryByIdResult)(nil), // 295: productv1.RequireStorageCategoryInfoSummaryByIdResult (*RequireStorageCategoryInfoSummaryByIdFields)(nil), // 296: productv1.RequireStorageCategoryInfoSummaryByIdFields - (*RequireWarehouseStockHealthScoreByIdRequest)(nil), // 297: productv1.RequireWarehouseStockHealthScoreByIdRequest - (*RequireWarehouseStockHealthScoreByIdContext)(nil), // 298: productv1.RequireWarehouseStockHealthScoreByIdContext - (*RequireWarehouseStockHealthScoreByIdResponse)(nil), // 299: productv1.RequireWarehouseStockHealthScoreByIdResponse - (*RequireWarehouseStockHealthScoreByIdResult)(nil), // 300: productv1.RequireWarehouseStockHealthScoreByIdResult - (*RequireWarehouseStockHealthScoreByIdFields)(nil), // 301: productv1.RequireWarehouseStockHealthScoreByIdFields - (*Product)(nil), // 302: productv1.Product - (*Storage)(nil), // 303: productv1.Storage - (*Warehouse)(nil), // 304: productv1.Warehouse - (*User)(nil), // 305: productv1.User - (*NestedTypeA)(nil), // 306: productv1.NestedTypeA - (*RecursiveType)(nil), // 307: productv1.RecursiveType - (*TypeWithMultipleFilterFields)(nil), // 308: productv1.TypeWithMultipleFilterFields - (*FilterTypeInput)(nil), // 309: productv1.FilterTypeInput - (*ComplexFilterTypeInput)(nil), // 310: productv1.ComplexFilterTypeInput - (*TypeWithComplexFilterInput)(nil), // 311: productv1.TypeWithComplexFilterInput - (*OrderInput)(nil), // 312: productv1.OrderInput - (*Order)(nil), // 313: productv1.Order - (*Category)(nil), // 314: productv1.Category - (*CategoryFilter)(nil), // 315: productv1.CategoryFilter - (*Animal)(nil), // 316: productv1.Animal - (*SearchInput)(nil), // 317: productv1.SearchInput - (*SearchResult)(nil), // 318: productv1.SearchResult - (*NullableFieldsType)(nil), // 319: productv1.NullableFieldsType - (*NullableFieldsFilter)(nil), // 320: productv1.NullableFieldsFilter - (*BlogPost)(nil), // 321: productv1.BlogPost - (*BlogPostFilter)(nil), // 322: productv1.BlogPostFilter - (*Author)(nil), // 323: productv1.Author - (*AuthorFilter)(nil), // 324: productv1.AuthorFilter - (*TestContainer)(nil), // 325: productv1.TestContainer - (*UserInput)(nil), // 326: productv1.UserInput - (*ActionInput)(nil), // 327: productv1.ActionInput - (*ActionResult)(nil), // 328: productv1.ActionResult - (*NullableFieldsInput)(nil), // 329: productv1.NullableFieldsInput - (*BlogPostInput)(nil), // 330: productv1.BlogPostInput - (*AuthorInput)(nil), // 331: productv1.AuthorInput - (*ProductDetails)(nil), // 332: productv1.ProductDetails - (*RestockData)(nil), // 333: productv1.RestockData - (*StorageMetadata)(nil), // 334: productv1.StorageMetadata - (*StorageCategoryInfo)(nil), // 335: productv1.StorageCategoryInfo - (*NestedTypeB)(nil), // 336: productv1.NestedTypeB - (*NestedTypeC)(nil), // 337: productv1.NestedTypeC - (*FilterType)(nil), // 338: productv1.FilterType - (*Pagination)(nil), // 339: productv1.Pagination - (*OrderLineInput)(nil), // 340: productv1.OrderLineInput - (*OrderLine)(nil), // 341: productv1.OrderLine - (*Subcategory)(nil), // 342: productv1.Subcategory - (*CategoryMetrics)(nil), // 343: productv1.CategoryMetrics - (*Cat)(nil), // 344: productv1.Cat - (*Dog)(nil), // 345: productv1.Dog - (*Owner)(nil), // 346: productv1.Owner - (*ContactInfo)(nil), // 347: productv1.ContactInfo - (*Address)(nil), // 348: productv1.Address - (*CatBreed)(nil), // 349: productv1.CatBreed - (*DogBreed)(nil), // 350: productv1.DogBreed - (*BreedCharacteristics)(nil), // 351: productv1.BreedCharacteristics - (*ActionSuccess)(nil), // 352: productv1.ActionSuccess - (*ActionError)(nil), // 353: productv1.ActionError - (*TestDetails)(nil), // 354: productv1.TestDetails - (*CategoryInput)(nil), // 355: productv1.CategoryInput - (*ProductCountFilter)(nil), // 356: productv1.ProductCountFilter - (*SubcategoryItemFilter)(nil), // 357: productv1.SubcategoryItemFilter - (*ShippingEstimateInput)(nil), // 358: productv1.ShippingEstimateInput - (*ListOfAuthorFilter_List)(nil), // 359: productv1.ListOfAuthorFilter.List - (*ListOfAuthorInput_List)(nil), // 360: productv1.ListOfAuthorInput.List - (*ListOfBlogPost_List)(nil), // 361: productv1.ListOfBlogPost.List - (*ListOfBlogPostFilter_List)(nil), // 362: productv1.ListOfBlogPostFilter.List - (*ListOfBlogPostInput_List)(nil), // 363: productv1.ListOfBlogPostInput.List - (*ListOfBoolean_List)(nil), // 364: productv1.ListOfBoolean.List - (*ListOfCategory_List)(nil), // 365: productv1.ListOfCategory.List - (*ListOfCategoryInput_List)(nil), // 366: productv1.ListOfCategoryInput.List - (*ListOfFloat_List)(nil), // 367: productv1.ListOfFloat.List - (*ListOfListOfCategory_List)(nil), // 368: productv1.ListOfListOfCategory.List - (*ListOfListOfCategoryInput_List)(nil), // 369: productv1.ListOfListOfCategoryInput.List - (*ListOfListOfString_List)(nil), // 370: productv1.ListOfListOfString.List - (*ListOfListOfUser_List)(nil), // 371: productv1.ListOfListOfUser.List - (*ListOfListOfUserInput_List)(nil), // 372: productv1.ListOfListOfUserInput.List - (*ListOfOrderLine_List)(nil), // 373: productv1.ListOfOrderLine.List - (*ListOfProduct_List)(nil), // 374: productv1.ListOfProduct.List - (*ListOfStorage_List)(nil), // 375: productv1.ListOfStorage.List - (*ListOfString_List)(nil), // 376: productv1.ListOfString.List - (*ListOfSubcategory_List)(nil), // 377: productv1.ListOfSubcategory.List - (*ListOfUser_List)(nil), // 378: productv1.ListOfUser.List - (*ListOfUserInput_List)(nil), // 379: productv1.ListOfUserInput.List - (*RequireStorageStockHealthScoreByIdFields_RestockData)(nil), // 380: productv1.RequireStorageStockHealthScoreByIdFields.RestockData - (*RequireStorageMetadataScoreByIdFields_StorageMetadata)(nil), // 381: productv1.RequireStorageMetadataScoreByIdFields.StorageMetadata - (*RequireStorageProcessedMetadataByIdFields_StorageMetadata)(nil), // 382: productv1.RequireStorageProcessedMetadataByIdFields.StorageMetadata - (*RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata)(nil), // 383: productv1.RequireStorageOptionalProcessedMetadataByIdFields.StorageMetadata - (*RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata)(nil), // 384: productv1.RequireStorageProcessedMetadataHistoryByIdFields.StorageMetadata - (*RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo)(nil), // 385: productv1.RequireStorageCategoryInfoSummaryByIdFields.StorageCategoryInfo - (*RequireWarehouseStockHealthScoreByIdFields_RestockData)(nil), // 386: productv1.RequireWarehouseStockHealthScoreByIdFields.RestockData - (*wrapperspb.Int32Value)(nil), // 387: google.protobuf.Int32Value - (*wrapperspb.BoolValue)(nil), // 388: google.protobuf.BoolValue - (*wrapperspb.StringValue)(nil), // 389: google.protobuf.StringValue - (*wrapperspb.DoubleValue)(nil), // 390: google.protobuf.DoubleValue + (*RequireStorageItemInfoByIdRequest)(nil), // 297: productv1.RequireStorageItemInfoByIdRequest + (*RequireStorageItemInfoByIdContext)(nil), // 298: productv1.RequireStorageItemInfoByIdContext + (*RequireStorageItemInfoByIdResponse)(nil), // 299: productv1.RequireStorageItemInfoByIdResponse + (*RequireStorageItemInfoByIdResult)(nil), // 300: productv1.RequireStorageItemInfoByIdResult + (*RequireStorageItemInfoByIdFields)(nil), // 301: productv1.RequireStorageItemInfoByIdFields + (*RequireStorageOperationReportByIdRequest)(nil), // 302: productv1.RequireStorageOperationReportByIdRequest + (*RequireStorageOperationReportByIdContext)(nil), // 303: productv1.RequireStorageOperationReportByIdContext + (*RequireStorageOperationReportByIdResponse)(nil), // 304: productv1.RequireStorageOperationReportByIdResponse + (*RequireStorageOperationReportByIdResult)(nil), // 305: productv1.RequireStorageOperationReportByIdResult + (*RequireStorageOperationReportByIdFields)(nil), // 306: productv1.RequireStorageOperationReportByIdFields + (*RequireStorageSecuritySummaryByIdRequest)(nil), // 307: productv1.RequireStorageSecuritySummaryByIdRequest + (*RequireStorageSecuritySummaryByIdContext)(nil), // 308: productv1.RequireStorageSecuritySummaryByIdContext + (*RequireStorageSecuritySummaryByIdResponse)(nil), // 309: productv1.RequireStorageSecuritySummaryByIdResponse + (*RequireStorageSecuritySummaryByIdResult)(nil), // 310: productv1.RequireStorageSecuritySummaryByIdResult + (*RequireStorageSecuritySummaryByIdFields)(nil), // 311: productv1.RequireStorageSecuritySummaryByIdFields + (*RequireStorageItemHandlerInfoByIdRequest)(nil), // 312: productv1.RequireStorageItemHandlerInfoByIdRequest + (*RequireStorageItemHandlerInfoByIdContext)(nil), // 313: productv1.RequireStorageItemHandlerInfoByIdContext + (*RequireStorageItemHandlerInfoByIdResponse)(nil), // 314: productv1.RequireStorageItemHandlerInfoByIdResponse + (*RequireStorageItemHandlerInfoByIdResult)(nil), // 315: productv1.RequireStorageItemHandlerInfoByIdResult + (*RequireStorageItemHandlerInfoByIdFields)(nil), // 316: productv1.RequireStorageItemHandlerInfoByIdFields + (*RequireStorageItemSpecsInfoByIdRequest)(nil), // 317: productv1.RequireStorageItemSpecsInfoByIdRequest + (*RequireStorageItemSpecsInfoByIdContext)(nil), // 318: productv1.RequireStorageItemSpecsInfoByIdContext + (*RequireStorageItemSpecsInfoByIdResponse)(nil), // 319: productv1.RequireStorageItemSpecsInfoByIdResponse + (*RequireStorageItemSpecsInfoByIdResult)(nil), // 320: productv1.RequireStorageItemSpecsInfoByIdResult + (*RequireStorageItemSpecsInfoByIdFields)(nil), // 321: productv1.RequireStorageItemSpecsInfoByIdFields + (*RequireStorageDeepItemInfoByIdRequest)(nil), // 322: productv1.RequireStorageDeepItemInfoByIdRequest + (*RequireStorageDeepItemInfoByIdContext)(nil), // 323: productv1.RequireStorageDeepItemInfoByIdContext + (*RequireStorageDeepItemInfoByIdResponse)(nil), // 324: productv1.RequireStorageDeepItemInfoByIdResponse + (*RequireStorageDeepItemInfoByIdResult)(nil), // 325: productv1.RequireStorageDeepItemInfoByIdResult + (*RequireStorageDeepItemInfoByIdFields)(nil), // 326: productv1.RequireStorageDeepItemInfoByIdFields + (*RequireWarehouseStockHealthScoreByIdRequest)(nil), // 327: productv1.RequireWarehouseStockHealthScoreByIdRequest + (*RequireWarehouseStockHealthScoreByIdContext)(nil), // 328: productv1.RequireWarehouseStockHealthScoreByIdContext + (*RequireWarehouseStockHealthScoreByIdResponse)(nil), // 329: productv1.RequireWarehouseStockHealthScoreByIdResponse + (*RequireWarehouseStockHealthScoreByIdResult)(nil), // 330: productv1.RequireWarehouseStockHealthScoreByIdResult + (*RequireWarehouseStockHealthScoreByIdFields)(nil), // 331: productv1.RequireWarehouseStockHealthScoreByIdFields + (*Product)(nil), // 332: productv1.Product + (*Storage)(nil), // 333: productv1.Storage + (*Warehouse)(nil), // 334: productv1.Warehouse + (*User)(nil), // 335: productv1.User + (*NestedTypeA)(nil), // 336: productv1.NestedTypeA + (*RecursiveType)(nil), // 337: productv1.RecursiveType + (*TypeWithMultipleFilterFields)(nil), // 338: productv1.TypeWithMultipleFilterFields + (*FilterTypeInput)(nil), // 339: productv1.FilterTypeInput + (*ComplexFilterTypeInput)(nil), // 340: productv1.ComplexFilterTypeInput + (*TypeWithComplexFilterInput)(nil), // 341: productv1.TypeWithComplexFilterInput + (*OrderInput)(nil), // 342: productv1.OrderInput + (*Order)(nil), // 343: productv1.Order + (*Category)(nil), // 344: productv1.Category + (*CategoryFilter)(nil), // 345: productv1.CategoryFilter + (*Animal)(nil), // 346: productv1.Animal + (*SearchInput)(nil), // 347: productv1.SearchInput + (*SearchResult)(nil), // 348: productv1.SearchResult + (*NullableFieldsType)(nil), // 349: productv1.NullableFieldsType + (*NullableFieldsFilter)(nil), // 350: productv1.NullableFieldsFilter + (*BlogPost)(nil), // 351: productv1.BlogPost + (*BlogPostFilter)(nil), // 352: productv1.BlogPostFilter + (*Author)(nil), // 353: productv1.Author + (*AuthorFilter)(nil), // 354: productv1.AuthorFilter + (*TestContainer)(nil), // 355: productv1.TestContainer + (*UserInput)(nil), // 356: productv1.UserInput + (*ActionInput)(nil), // 357: productv1.ActionInput + (*ActionResult)(nil), // 358: productv1.ActionResult + (*NullableFieldsInput)(nil), // 359: productv1.NullableFieldsInput + (*BlogPostInput)(nil), // 360: productv1.BlogPostInput + (*AuthorInput)(nil), // 361: productv1.AuthorInput + (*ProductDetails)(nil), // 362: productv1.ProductDetails + (*RestockData)(nil), // 363: productv1.RestockData + (*StorageMetadata)(nil), // 364: productv1.StorageMetadata + (*StorageCategoryInfo)(nil), // 365: productv1.StorageCategoryInfo + (*NestedTypeB)(nil), // 366: productv1.NestedTypeB + (*NestedTypeC)(nil), // 367: productv1.NestedTypeC + (*FilterType)(nil), // 368: productv1.FilterType + (*Pagination)(nil), // 369: productv1.Pagination + (*OrderLineInput)(nil), // 370: productv1.OrderLineInput + (*OrderLine)(nil), // 371: productv1.OrderLine + (*Subcategory)(nil), // 372: productv1.Subcategory + (*CategoryMetrics)(nil), // 373: productv1.CategoryMetrics + (*Cat)(nil), // 374: productv1.Cat + (*Dog)(nil), // 375: productv1.Dog + (*Owner)(nil), // 376: productv1.Owner + (*ContactInfo)(nil), // 377: productv1.ContactInfo + (*Address)(nil), // 378: productv1.Address + (*CatBreed)(nil), // 379: productv1.CatBreed + (*DogBreed)(nil), // 380: productv1.DogBreed + (*BreedCharacteristics)(nil), // 381: productv1.BreedCharacteristics + (*StorageItem)(nil), // 382: productv1.StorageItem + (*PalletItem)(nil), // 383: productv1.PalletItem + (*ContainerItem)(nil), // 384: productv1.ContainerItem + (*ItemHandler)(nil), // 385: productv1.ItemHandler + (*PalletSpecs)(nil), // 386: productv1.PalletSpecs + (*ContainerSpecs)(nil), // 387: productv1.ContainerSpecs + (*Dimensions)(nil), // 388: productv1.Dimensions + (*StorageOperationResult)(nil), // 389: productv1.StorageOperationResult + (*StorageSuccess)(nil), // 390: productv1.StorageSuccess + (*StorageFailure)(nil), // 391: productv1.StorageFailure + (*SecuritySetup)(nil), // 392: productv1.SecuritySetup + (*ActionSuccess)(nil), // 393: productv1.ActionSuccess + (*ActionError)(nil), // 394: productv1.ActionError + (*TestDetails)(nil), // 395: productv1.TestDetails + (*CategoryInput)(nil), // 396: productv1.CategoryInput + (*ProductCountFilter)(nil), // 397: productv1.ProductCountFilter + (*SubcategoryItemFilter)(nil), // 398: productv1.SubcategoryItemFilter + (*ShippingEstimateInput)(nil), // 399: productv1.ShippingEstimateInput + (*ListOfAuthorFilter_List)(nil), // 400: productv1.ListOfAuthorFilter.List + (*ListOfAuthorInput_List)(nil), // 401: productv1.ListOfAuthorInput.List + (*ListOfBlogPost_List)(nil), // 402: productv1.ListOfBlogPost.List + (*ListOfBlogPostFilter_List)(nil), // 403: productv1.ListOfBlogPostFilter.List + (*ListOfBlogPostInput_List)(nil), // 404: productv1.ListOfBlogPostInput.List + (*ListOfBoolean_List)(nil), // 405: productv1.ListOfBoolean.List + (*ListOfCategory_List)(nil), // 406: productv1.ListOfCategory.List + (*ListOfCategoryInput_List)(nil), // 407: productv1.ListOfCategoryInput.List + (*ListOfFloat_List)(nil), // 408: productv1.ListOfFloat.List + (*ListOfListOfCategory_List)(nil), // 409: productv1.ListOfListOfCategory.List + (*ListOfListOfCategoryInput_List)(nil), // 410: productv1.ListOfListOfCategoryInput.List + (*ListOfListOfString_List)(nil), // 411: productv1.ListOfListOfString.List + (*ListOfListOfUser_List)(nil), // 412: productv1.ListOfListOfUser.List + (*ListOfListOfUserInput_List)(nil), // 413: productv1.ListOfListOfUserInput.List + (*ListOfOrderLine_List)(nil), // 414: productv1.ListOfOrderLine.List + (*ListOfProduct_List)(nil), // 415: productv1.ListOfProduct.List + (*ListOfStorage_List)(nil), // 416: productv1.ListOfStorage.List + (*ListOfString_List)(nil), // 417: productv1.ListOfString.List + (*ListOfSubcategory_List)(nil), // 418: productv1.ListOfSubcategory.List + (*ListOfUser_List)(nil), // 419: productv1.ListOfUser.List + (*ListOfUserInput_List)(nil), // 420: productv1.ListOfUserInput.List + (*RequireStorageStockHealthScoreByIdFields_RestockData)(nil), // 421: productv1.RequireStorageStockHealthScoreByIdFields.RestockData + (*RequireStorageMetadataScoreByIdFields_StorageMetadata)(nil), // 422: productv1.RequireStorageMetadataScoreByIdFields.StorageMetadata + (*RequireStorageProcessedMetadataByIdFields_StorageMetadata)(nil), // 423: productv1.RequireStorageProcessedMetadataByIdFields.StorageMetadata + (*RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata)(nil), // 424: productv1.RequireStorageOptionalProcessedMetadataByIdFields.StorageMetadata + (*RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata)(nil), // 425: productv1.RequireStorageProcessedMetadataHistoryByIdFields.StorageMetadata + (*RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo)(nil), // 426: productv1.RequireStorageCategoryInfoSummaryByIdFields.StorageCategoryInfo + (*RequireStorageItemInfoByIdFields_PalletItem)(nil), // 427: productv1.RequireStorageItemInfoByIdFields.PalletItem + (*RequireStorageItemInfoByIdFields_ContainerItem)(nil), // 428: productv1.RequireStorageItemInfoByIdFields.ContainerItem + (*RequireStorageItemInfoByIdFields_StorageItem)(nil), // 429: productv1.RequireStorageItemInfoByIdFields.StorageItem + (*RequireStorageOperationReportByIdFields_StorageSuccess)(nil), // 430: productv1.RequireStorageOperationReportByIdFields.StorageSuccess + (*RequireStorageOperationReportByIdFields_StorageFailure)(nil), // 431: productv1.RequireStorageOperationReportByIdFields.StorageFailure + (*RequireStorageOperationReportByIdFields_StorageOperationResult)(nil), // 432: productv1.RequireStorageOperationReportByIdFields.StorageOperationResult + (*RequireStorageSecuritySummaryByIdFields_SecuritySetup)(nil), // 433: productv1.RequireStorageSecuritySummaryByIdFields.SecuritySetup + (*RequireStorageSecuritySummaryByIdFields_SecuritySetup_PalletItem)(nil), // 434: productv1.RequireStorageSecuritySummaryByIdFields.SecuritySetup.PalletItem + (*RequireStorageSecuritySummaryByIdFields_SecuritySetup_ContainerItem)(nil), // 435: productv1.RequireStorageSecuritySummaryByIdFields.SecuritySetup.ContainerItem + (*RequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem)(nil), // 436: productv1.RequireStorageSecuritySummaryByIdFields.SecuritySetup.StorageItem + (*RequireStorageItemHandlerInfoByIdFields_PalletItem)(nil), // 437: productv1.RequireStorageItemHandlerInfoByIdFields.PalletItem + (*RequireStorageItemHandlerInfoByIdFields_ContainerItem)(nil), // 438: productv1.RequireStorageItemHandlerInfoByIdFields.ContainerItem + (*RequireStorageItemHandlerInfoByIdFields_StorageItem)(nil), // 439: productv1.RequireStorageItemHandlerInfoByIdFields.StorageItem + (*RequireStorageItemHandlerInfoByIdFields_PalletItem_ItemHandler)(nil), // 440: productv1.RequireStorageItemHandlerInfoByIdFields.PalletItem.ItemHandler + (*RequireStorageItemHandlerInfoByIdFields_ContainerItem_ItemHandler)(nil), // 441: productv1.RequireStorageItemHandlerInfoByIdFields.ContainerItem.ItemHandler + (*RequireStorageItemSpecsInfoByIdFields_PalletItem)(nil), // 442: productv1.RequireStorageItemSpecsInfoByIdFields.PalletItem + (*RequireStorageItemSpecsInfoByIdFields_ContainerItem)(nil), // 443: productv1.RequireStorageItemSpecsInfoByIdFields.ContainerItem + (*RequireStorageItemSpecsInfoByIdFields_StorageItem)(nil), // 444: productv1.RequireStorageItemSpecsInfoByIdFields.StorageItem + (*RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs)(nil), // 445: productv1.RequireStorageItemSpecsInfoByIdFields.PalletItem.PalletSpecs + (*RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs_Dimensions)(nil), // 446: productv1.RequireStorageItemSpecsInfoByIdFields.PalletItem.PalletSpecs.Dimensions + (*RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs)(nil), // 447: productv1.RequireStorageItemSpecsInfoByIdFields.ContainerItem.ContainerSpecs + (*RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs_Dimensions)(nil), // 448: productv1.RequireStorageItemSpecsInfoByIdFields.ContainerItem.ContainerSpecs.Dimensions + (*RequireStorageDeepItemInfoByIdFields_PalletItem)(nil), // 449: productv1.RequireStorageDeepItemInfoByIdFields.PalletItem + (*RequireStorageDeepItemInfoByIdFields_ContainerItem)(nil), // 450: productv1.RequireStorageDeepItemInfoByIdFields.ContainerItem + (*RequireStorageDeepItemInfoByIdFields_StorageItem)(nil), // 451: productv1.RequireStorageDeepItemInfoByIdFields.StorageItem + (*RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler)(nil), // 452: productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.ItemHandler + (*RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_ContainerItem)(nil), // 453: productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.ItemHandler.ContainerItem + (*RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_PalletItem)(nil), // 454: productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.ItemHandler.PalletItem + (*RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem)(nil), // 455: productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.ItemHandler.StorageItem + (*RequireStorageDeepItemInfoByIdFields_ContainerItem_ItemHandler)(nil), // 456: productv1.RequireStorageDeepItemInfoByIdFields.ContainerItem.ItemHandler + (*RequireWarehouseStockHealthScoreByIdFields_RestockData)(nil), // 457: productv1.RequireWarehouseStockHealthScoreByIdFields.RestockData + (*wrapperspb.Int32Value)(nil), // 458: google.protobuf.Int32Value + (*wrapperspb.BoolValue)(nil), // 459: google.protobuf.BoolValue + (*wrapperspb.StringValue)(nil), // 460: google.protobuf.StringValue + (*wrapperspb.DoubleValue)(nil), // 461: google.protobuf.DoubleValue } var file_product_proto_depIdxs = []int32{ - 359, // 0: productv1.ListOfAuthorFilter.list:type_name -> productv1.ListOfAuthorFilter.List - 360, // 1: productv1.ListOfAuthorInput.list:type_name -> productv1.ListOfAuthorInput.List - 361, // 2: productv1.ListOfBlogPost.list:type_name -> productv1.ListOfBlogPost.List - 362, // 3: productv1.ListOfBlogPostFilter.list:type_name -> productv1.ListOfBlogPostFilter.List - 363, // 4: productv1.ListOfBlogPostInput.list:type_name -> productv1.ListOfBlogPostInput.List - 364, // 5: productv1.ListOfBoolean.list:type_name -> productv1.ListOfBoolean.List - 365, // 6: productv1.ListOfCategory.list:type_name -> productv1.ListOfCategory.List - 366, // 7: productv1.ListOfCategoryInput.list:type_name -> productv1.ListOfCategoryInput.List - 367, // 8: productv1.ListOfFloat.list:type_name -> productv1.ListOfFloat.List - 368, // 9: productv1.ListOfListOfCategory.list:type_name -> productv1.ListOfListOfCategory.List - 369, // 10: productv1.ListOfListOfCategoryInput.list:type_name -> productv1.ListOfListOfCategoryInput.List - 370, // 11: productv1.ListOfListOfString.list:type_name -> productv1.ListOfListOfString.List - 371, // 12: productv1.ListOfListOfUser.list:type_name -> productv1.ListOfListOfUser.List - 372, // 13: productv1.ListOfListOfUserInput.list:type_name -> productv1.ListOfListOfUserInput.List - 373, // 14: productv1.ListOfOrderLine.list:type_name -> productv1.ListOfOrderLine.List - 374, // 15: productv1.ListOfProduct.list:type_name -> productv1.ListOfProduct.List - 375, // 16: productv1.ListOfStorage.list:type_name -> productv1.ListOfStorage.List - 376, // 17: productv1.ListOfString.list:type_name -> productv1.ListOfString.List - 377, // 18: productv1.ListOfSubcategory.list:type_name -> productv1.ListOfSubcategory.List - 378, // 19: productv1.ListOfUser.list:type_name -> productv1.ListOfUser.List - 379, // 20: productv1.ListOfUserInput.list:type_name -> productv1.ListOfUserInput.List + 400, // 0: productv1.ListOfAuthorFilter.list:type_name -> productv1.ListOfAuthorFilter.List + 401, // 1: productv1.ListOfAuthorInput.list:type_name -> productv1.ListOfAuthorInput.List + 402, // 2: productv1.ListOfBlogPost.list:type_name -> productv1.ListOfBlogPost.List + 403, // 3: productv1.ListOfBlogPostFilter.list:type_name -> productv1.ListOfBlogPostFilter.List + 404, // 4: productv1.ListOfBlogPostInput.list:type_name -> productv1.ListOfBlogPostInput.List + 405, // 5: productv1.ListOfBoolean.list:type_name -> productv1.ListOfBoolean.List + 406, // 6: productv1.ListOfCategory.list:type_name -> productv1.ListOfCategory.List + 407, // 7: productv1.ListOfCategoryInput.list:type_name -> productv1.ListOfCategoryInput.List + 408, // 8: productv1.ListOfFloat.list:type_name -> productv1.ListOfFloat.List + 409, // 9: productv1.ListOfListOfCategory.list:type_name -> productv1.ListOfListOfCategory.List + 410, // 10: productv1.ListOfListOfCategoryInput.list:type_name -> productv1.ListOfListOfCategoryInput.List + 411, // 11: productv1.ListOfListOfString.list:type_name -> productv1.ListOfListOfString.List + 412, // 12: productv1.ListOfListOfUser.list:type_name -> productv1.ListOfListOfUser.List + 413, // 13: productv1.ListOfListOfUserInput.list:type_name -> productv1.ListOfListOfUserInput.List + 414, // 14: productv1.ListOfOrderLine.list:type_name -> productv1.ListOfOrderLine.List + 415, // 15: productv1.ListOfProduct.list:type_name -> productv1.ListOfProduct.List + 416, // 16: productv1.ListOfStorage.list:type_name -> productv1.ListOfStorage.List + 417, // 17: productv1.ListOfString.list:type_name -> productv1.ListOfString.List + 418, // 18: productv1.ListOfSubcategory.list:type_name -> productv1.ListOfSubcategory.List + 419, // 19: productv1.ListOfUser.list:type_name -> productv1.ListOfUser.List + 420, // 20: productv1.ListOfUserInput.list:type_name -> productv1.ListOfUserInput.List 23, // 21: productv1.LookupProductByIdRequest.keys:type_name -> productv1.LookupProductByIdRequestKey - 302, // 22: productv1.LookupProductByIdResponse.result:type_name -> productv1.Product + 332, // 22: productv1.LookupProductByIdResponse.result:type_name -> productv1.Product 26, // 23: productv1.LookupStorageByIdRequest.keys:type_name -> productv1.LookupStorageByIdRequestKey - 303, // 24: productv1.LookupStorageByIdResponse.result:type_name -> productv1.Storage + 333, // 24: productv1.LookupStorageByIdResponse.result:type_name -> productv1.Storage 29, // 25: productv1.LookupWarehouseByIdRequest.keys:type_name -> productv1.LookupWarehouseByIdRequestKey - 304, // 26: productv1.LookupWarehouseByIdResponse.result:type_name -> productv1.Warehouse - 305, // 27: productv1.QueryUsersResponse.users:type_name -> productv1.User - 305, // 28: productv1.QueryUserResponse.user:type_name -> productv1.User - 306, // 29: productv1.QueryNestedTypeResponse.nested_type:type_name -> productv1.NestedTypeA - 307, // 30: productv1.QueryRecursiveTypeResponse.recursive_type:type_name -> productv1.RecursiveType - 308, // 31: productv1.QueryTypeFilterWithArgumentsResponse.type_filter_with_arguments:type_name -> productv1.TypeWithMultipleFilterFields - 309, // 32: productv1.QueryTypeWithMultipleFilterFieldsRequest.filter:type_name -> productv1.FilterTypeInput - 308, // 33: productv1.QueryTypeWithMultipleFilterFieldsResponse.type_with_multiple_filter_fields:type_name -> productv1.TypeWithMultipleFilterFields - 310, // 34: productv1.QueryComplexFilterTypeRequest.filter:type_name -> productv1.ComplexFilterTypeInput - 311, // 35: productv1.QueryComplexFilterTypeResponse.complex_filter_type:type_name -> productv1.TypeWithComplexFilterInput - 312, // 36: productv1.QueryCalculateTotalsRequest.orders:type_name -> productv1.OrderInput - 313, // 37: productv1.QueryCalculateTotalsResponse.calculate_totals:type_name -> productv1.Order - 314, // 38: productv1.QueryCategoriesResponse.categories:type_name -> productv1.Category - 314, // 39: productv1.QueryCategoryResponse.category:type_name -> productv1.Category + 334, // 26: productv1.LookupWarehouseByIdResponse.result:type_name -> productv1.Warehouse + 335, // 27: productv1.QueryUsersResponse.users:type_name -> productv1.User + 335, // 28: productv1.QueryUserResponse.user:type_name -> productv1.User + 336, // 29: productv1.QueryNestedTypeResponse.nested_type:type_name -> productv1.NestedTypeA + 337, // 30: productv1.QueryRecursiveTypeResponse.recursive_type:type_name -> productv1.RecursiveType + 338, // 31: productv1.QueryTypeFilterWithArgumentsResponse.type_filter_with_arguments:type_name -> productv1.TypeWithMultipleFilterFields + 339, // 32: productv1.QueryTypeWithMultipleFilterFieldsRequest.filter:type_name -> productv1.FilterTypeInput + 338, // 33: productv1.QueryTypeWithMultipleFilterFieldsResponse.type_with_multiple_filter_fields:type_name -> productv1.TypeWithMultipleFilterFields + 340, // 34: productv1.QueryComplexFilterTypeRequest.filter:type_name -> productv1.ComplexFilterTypeInput + 341, // 35: productv1.QueryComplexFilterTypeResponse.complex_filter_type:type_name -> productv1.TypeWithComplexFilterInput + 342, // 36: productv1.QueryCalculateTotalsRequest.orders:type_name -> productv1.OrderInput + 343, // 37: productv1.QueryCalculateTotalsResponse.calculate_totals:type_name -> productv1.Order + 344, // 38: productv1.QueryCategoriesResponse.categories:type_name -> productv1.Category + 344, // 39: productv1.QueryCategoryResponse.category:type_name -> productv1.Category 0, // 40: productv1.QueryCategoriesByKindRequest.kind:type_name -> productv1.CategoryKind - 314, // 41: productv1.QueryCategoriesByKindResponse.categories_by_kind:type_name -> productv1.Category + 344, // 41: productv1.QueryCategoriesByKindResponse.categories_by_kind:type_name -> productv1.Category 0, // 42: productv1.QueryCategoriesByKindsRequest.kinds:type_name -> productv1.CategoryKind - 314, // 43: productv1.QueryCategoriesByKindsResponse.categories_by_kinds:type_name -> productv1.Category - 315, // 44: productv1.QueryFilterCategoriesRequest.filter:type_name -> productv1.CategoryFilter - 314, // 45: productv1.QueryFilterCategoriesResponse.filter_categories:type_name -> productv1.Category - 316, // 46: productv1.QueryRandomPetResponse.random_pet:type_name -> productv1.Animal - 316, // 47: productv1.QueryAllPetsResponse.all_pets:type_name -> productv1.Animal - 317, // 48: productv1.QuerySearchRequest.input:type_name -> productv1.SearchInput - 318, // 49: productv1.QuerySearchResponse.search:type_name -> productv1.SearchResult - 318, // 50: productv1.QueryRandomSearchResultResponse.random_search_result:type_name -> productv1.SearchResult - 319, // 51: productv1.QueryNullableFieldsTypeResponse.nullable_fields_type:type_name -> productv1.NullableFieldsType - 319, // 52: productv1.QueryNullableFieldsTypeByIdResponse.nullable_fields_type_by_id:type_name -> productv1.NullableFieldsType - 320, // 53: productv1.QueryNullableFieldsTypeWithFilterRequest.filter:type_name -> productv1.NullableFieldsFilter - 319, // 54: productv1.QueryNullableFieldsTypeWithFilterResponse.nullable_fields_type_with_filter:type_name -> productv1.NullableFieldsType - 319, // 55: productv1.QueryAllNullableFieldsTypesResponse.all_nullable_fields_types:type_name -> productv1.NullableFieldsType - 321, // 56: productv1.QueryBlogPostResponse.blog_post:type_name -> productv1.BlogPost - 321, // 57: productv1.QueryBlogPostByIdResponse.blog_post_by_id:type_name -> productv1.BlogPost - 322, // 58: productv1.QueryBlogPostsWithFilterRequest.filter:type_name -> productv1.BlogPostFilter - 321, // 59: productv1.QueryBlogPostsWithFilterResponse.blog_posts_with_filter:type_name -> productv1.BlogPost - 321, // 60: productv1.QueryAllBlogPostsResponse.all_blog_posts:type_name -> productv1.BlogPost - 323, // 61: productv1.QueryAuthorResponse.author:type_name -> productv1.Author - 323, // 62: productv1.QueryAuthorByIdResponse.author_by_id:type_name -> productv1.Author - 324, // 63: productv1.QueryAuthorsWithFilterRequest.filter:type_name -> productv1.AuthorFilter - 323, // 64: productv1.QueryAuthorsWithFilterResponse.authors_with_filter:type_name -> productv1.Author - 323, // 65: productv1.QueryAllAuthorsResponse.all_authors:type_name -> productv1.Author + 344, // 43: productv1.QueryCategoriesByKindsResponse.categories_by_kinds:type_name -> productv1.Category + 345, // 44: productv1.QueryFilterCategoriesRequest.filter:type_name -> productv1.CategoryFilter + 344, // 45: productv1.QueryFilterCategoriesResponse.filter_categories:type_name -> productv1.Category + 346, // 46: productv1.QueryRandomPetResponse.random_pet:type_name -> productv1.Animal + 346, // 47: productv1.QueryAllPetsResponse.all_pets:type_name -> productv1.Animal + 347, // 48: productv1.QuerySearchRequest.input:type_name -> productv1.SearchInput + 348, // 49: productv1.QuerySearchResponse.search:type_name -> productv1.SearchResult + 348, // 50: productv1.QueryRandomSearchResultResponse.random_search_result:type_name -> productv1.SearchResult + 349, // 51: productv1.QueryNullableFieldsTypeResponse.nullable_fields_type:type_name -> productv1.NullableFieldsType + 349, // 52: productv1.QueryNullableFieldsTypeByIdResponse.nullable_fields_type_by_id:type_name -> productv1.NullableFieldsType + 350, // 53: productv1.QueryNullableFieldsTypeWithFilterRequest.filter:type_name -> productv1.NullableFieldsFilter + 349, // 54: productv1.QueryNullableFieldsTypeWithFilterResponse.nullable_fields_type_with_filter:type_name -> productv1.NullableFieldsType + 349, // 55: productv1.QueryAllNullableFieldsTypesResponse.all_nullable_fields_types:type_name -> productv1.NullableFieldsType + 351, // 56: productv1.QueryBlogPostResponse.blog_post:type_name -> productv1.BlogPost + 351, // 57: productv1.QueryBlogPostByIdResponse.blog_post_by_id:type_name -> productv1.BlogPost + 352, // 58: productv1.QueryBlogPostsWithFilterRequest.filter:type_name -> productv1.BlogPostFilter + 351, // 59: productv1.QueryBlogPostsWithFilterResponse.blog_posts_with_filter:type_name -> productv1.BlogPost + 351, // 60: productv1.QueryAllBlogPostsResponse.all_blog_posts:type_name -> productv1.BlogPost + 353, // 61: productv1.QueryAuthorResponse.author:type_name -> productv1.Author + 353, // 62: productv1.QueryAuthorByIdResponse.author_by_id:type_name -> productv1.Author + 354, // 63: productv1.QueryAuthorsWithFilterRequest.filter:type_name -> productv1.AuthorFilter + 353, // 64: productv1.QueryAuthorsWithFilterResponse.authors_with_filter:type_name -> productv1.Author + 353, // 65: productv1.QueryAllAuthorsResponse.all_authors:type_name -> productv1.Author 2, // 66: productv1.QueryBulkSearchAuthorsRequest.filters:type_name -> productv1.ListOfAuthorFilter - 323, // 67: productv1.QueryBulkSearchAuthorsResponse.bulk_search_authors:type_name -> productv1.Author + 353, // 67: productv1.QueryBulkSearchAuthorsResponse.bulk_search_authors:type_name -> productv1.Author 5, // 68: productv1.QueryBulkSearchBlogPostsRequest.filters:type_name -> productv1.ListOfBlogPostFilter - 321, // 69: productv1.QueryBulkSearchBlogPostsResponse.bulk_search_blog_posts:type_name -> productv1.BlogPost - 325, // 70: productv1.QueryTestContainerResponse.test_container:type_name -> productv1.TestContainer - 325, // 71: productv1.QueryTestContainersResponse.test_containers:type_name -> productv1.TestContainer - 326, // 72: productv1.MutationCreateUserRequest.input:type_name -> productv1.UserInput - 305, // 73: productv1.MutationCreateUserResponse.create_user:type_name -> productv1.User - 327, // 74: productv1.MutationPerformActionRequest.input:type_name -> productv1.ActionInput - 328, // 75: productv1.MutationPerformActionResponse.perform_action:type_name -> productv1.ActionResult - 329, // 76: productv1.MutationCreateNullableFieldsTypeRequest.input:type_name -> productv1.NullableFieldsInput - 319, // 77: productv1.MutationCreateNullableFieldsTypeResponse.create_nullable_fields_type:type_name -> productv1.NullableFieldsType - 329, // 78: productv1.MutationUpdateNullableFieldsTypeRequest.input:type_name -> productv1.NullableFieldsInput - 319, // 79: productv1.MutationUpdateNullableFieldsTypeResponse.update_nullable_fields_type:type_name -> productv1.NullableFieldsType - 330, // 80: productv1.MutationCreateBlogPostRequest.input:type_name -> productv1.BlogPostInput - 321, // 81: productv1.MutationCreateBlogPostResponse.create_blog_post:type_name -> productv1.BlogPost - 330, // 82: productv1.MutationUpdateBlogPostRequest.input:type_name -> productv1.BlogPostInput - 321, // 83: productv1.MutationUpdateBlogPostResponse.update_blog_post:type_name -> productv1.BlogPost - 331, // 84: productv1.MutationCreateAuthorRequest.input:type_name -> productv1.AuthorInput - 323, // 85: productv1.MutationCreateAuthorResponse.create_author:type_name -> productv1.Author - 331, // 86: productv1.MutationUpdateAuthorRequest.input:type_name -> productv1.AuthorInput - 323, // 87: productv1.MutationUpdateAuthorResponse.update_author:type_name -> productv1.Author + 351, // 69: productv1.QueryBulkSearchBlogPostsResponse.bulk_search_blog_posts:type_name -> productv1.BlogPost + 355, // 70: productv1.QueryTestContainerResponse.test_container:type_name -> productv1.TestContainer + 355, // 71: productv1.QueryTestContainersResponse.test_containers:type_name -> productv1.TestContainer + 356, // 72: productv1.MutationCreateUserRequest.input:type_name -> productv1.UserInput + 335, // 73: productv1.MutationCreateUserResponse.create_user:type_name -> productv1.User + 357, // 74: productv1.MutationPerformActionRequest.input:type_name -> productv1.ActionInput + 358, // 75: productv1.MutationPerformActionResponse.perform_action:type_name -> productv1.ActionResult + 359, // 76: productv1.MutationCreateNullableFieldsTypeRequest.input:type_name -> productv1.NullableFieldsInput + 349, // 77: productv1.MutationCreateNullableFieldsTypeResponse.create_nullable_fields_type:type_name -> productv1.NullableFieldsType + 359, // 78: productv1.MutationUpdateNullableFieldsTypeRequest.input:type_name -> productv1.NullableFieldsInput + 349, // 79: productv1.MutationUpdateNullableFieldsTypeResponse.update_nullable_fields_type:type_name -> productv1.NullableFieldsType + 360, // 80: productv1.MutationCreateBlogPostRequest.input:type_name -> productv1.BlogPostInput + 351, // 81: productv1.MutationCreateBlogPostResponse.create_blog_post:type_name -> productv1.BlogPost + 360, // 82: productv1.MutationUpdateBlogPostRequest.input:type_name -> productv1.BlogPostInput + 351, // 83: productv1.MutationUpdateBlogPostResponse.update_blog_post:type_name -> productv1.BlogPost + 361, // 84: productv1.MutationCreateAuthorRequest.input:type_name -> productv1.AuthorInput + 353, // 85: productv1.MutationCreateAuthorResponse.create_author:type_name -> productv1.Author + 361, // 86: productv1.MutationUpdateAuthorRequest.input:type_name -> productv1.AuthorInput + 353, // 87: productv1.MutationUpdateAuthorResponse.update_author:type_name -> productv1.Author 3, // 88: productv1.MutationBulkCreateAuthorsRequest.authors:type_name -> productv1.ListOfAuthorInput - 323, // 89: productv1.MutationBulkCreateAuthorsResponse.bulk_create_authors:type_name -> productv1.Author + 353, // 89: productv1.MutationBulkCreateAuthorsResponse.bulk_create_authors:type_name -> productv1.Author 3, // 90: productv1.MutationBulkUpdateAuthorsRequest.authors:type_name -> productv1.ListOfAuthorInput - 323, // 91: productv1.MutationBulkUpdateAuthorsResponse.bulk_update_authors:type_name -> productv1.Author + 353, // 91: productv1.MutationBulkUpdateAuthorsResponse.bulk_update_authors:type_name -> productv1.Author 6, // 92: productv1.MutationBulkCreateBlogPostsRequest.blog_posts:type_name -> productv1.ListOfBlogPostInput - 321, // 93: productv1.MutationBulkCreateBlogPostsResponse.bulk_create_blog_posts:type_name -> productv1.BlogPost + 351, // 93: productv1.MutationBulkCreateBlogPostsResponse.bulk_create_blog_posts:type_name -> productv1.BlogPost 6, // 94: productv1.MutationBulkUpdateBlogPostsRequest.blog_posts:type_name -> productv1.ListOfBlogPostInput - 321, // 95: productv1.MutationBulkUpdateBlogPostsResponse.bulk_update_blog_posts:type_name -> productv1.BlogPost - 358, // 96: productv1.ResolveProductShippingEstimateArgs.input:type_name -> productv1.ShippingEstimateInput + 351, // 95: productv1.MutationBulkUpdateBlogPostsResponse.bulk_update_blog_posts:type_name -> productv1.BlogPost + 399, // 96: productv1.ResolveProductShippingEstimateArgs.input:type_name -> productv1.ShippingEstimateInput 123, // 97: productv1.ResolveProductShippingEstimateRequest.context:type_name -> productv1.ResolveProductShippingEstimateContext 122, // 98: productv1.ResolveProductShippingEstimateRequest.field_args:type_name -> productv1.ResolveProductShippingEstimateArgs 125, // 99: productv1.ResolveProductShippingEstimateResponse.result:type_name -> productv1.ResolveProductShippingEstimateResult 128, // 100: productv1.ResolveProductRecommendedCategoryRequest.context:type_name -> productv1.ResolveProductRecommendedCategoryContext 127, // 101: productv1.ResolveProductRecommendedCategoryRequest.field_args:type_name -> productv1.ResolveProductRecommendedCategoryArgs - 314, // 102: productv1.ResolveProductRecommendedCategoryResult.recommended_category:type_name -> productv1.Category + 344, // 102: productv1.ResolveProductRecommendedCategoryResult.recommended_category:type_name -> productv1.Category 130, // 103: productv1.ResolveProductRecommendedCategoryResponse.result:type_name -> productv1.ResolveProductRecommendedCategoryResult 133, // 104: productv1.ResolveProductMascotRecommendationRequest.context:type_name -> productv1.ResolveProductMascotRecommendationContext 132, // 105: productv1.ResolveProductMascotRecommendationRequest.field_args:type_name -> productv1.ResolveProductMascotRecommendationArgs - 316, // 106: productv1.ResolveProductMascotRecommendationResult.mascot_recommendation:type_name -> productv1.Animal + 346, // 106: productv1.ResolveProductMascotRecommendationResult.mascot_recommendation:type_name -> productv1.Animal 135, // 107: productv1.ResolveProductMascotRecommendationResponse.result:type_name -> productv1.ResolveProductMascotRecommendationResult 138, // 108: productv1.ResolveProductStockStatusRequest.context:type_name -> productv1.ResolveProductStockStatusContext 137, // 109: productv1.ResolveProductStockStatusRequest.field_args:type_name -> productv1.ResolveProductStockStatusArgs - 328, // 110: productv1.ResolveProductStockStatusResult.stock_status:type_name -> productv1.ActionResult + 358, // 110: productv1.ResolveProductStockStatusResult.stock_status:type_name -> productv1.ActionResult 140, // 111: productv1.ResolveProductStockStatusResponse.result:type_name -> productv1.ResolveProductStockStatusResult 143, // 112: productv1.ResolveProductProductDetailsRequest.context:type_name -> productv1.ResolveProductProductDetailsContext 142, // 113: productv1.ResolveProductProductDetailsRequest.field_args:type_name -> productv1.ResolveProductProductDetailsArgs - 332, // 114: productv1.ResolveProductProductDetailsResult.product_details:type_name -> productv1.ProductDetails + 362, // 114: productv1.ResolveProductProductDetailsResult.product_details:type_name -> productv1.ProductDetails 145, // 115: productv1.ResolveProductProductDetailsResponse.result:type_name -> productv1.ResolveProductProductDetailsResult 148, // 116: productv1.ResolveStorageStorageStatusRequest.context:type_name -> productv1.ResolveStorageStorageStatusContext 147, // 117: productv1.ResolveStorageStorageStatusRequest.field_args:type_name -> productv1.ResolveStorageStorageStatusArgs - 328, // 118: productv1.ResolveStorageStorageStatusResult.storage_status:type_name -> productv1.ActionResult + 358, // 118: productv1.ResolveStorageStorageStatusResult.storage_status:type_name -> productv1.ActionResult 150, // 119: productv1.ResolveStorageStorageStatusResponse.result:type_name -> productv1.ResolveStorageStorageStatusResult 153, // 120: productv1.ResolveStorageLinkedStoragesRequest.context:type_name -> productv1.ResolveStorageLinkedStoragesContext 152, // 121: productv1.ResolveStorageLinkedStoragesRequest.field_args:type_name -> productv1.ResolveStorageLinkedStoragesArgs - 303, // 122: productv1.ResolveStorageLinkedStoragesResult.linked_storages:type_name -> productv1.Storage + 333, // 122: productv1.ResolveStorageLinkedStoragesResult.linked_storages:type_name -> productv1.Storage 155, // 123: productv1.ResolveStorageLinkedStoragesResponse.result:type_name -> productv1.ResolveStorageLinkedStoragesResult - 387, // 124: productv1.ResolveStorageNearbyStoragesArgs.radius:type_name -> google.protobuf.Int32Value + 458, // 124: productv1.ResolveStorageNearbyStoragesArgs.radius:type_name -> google.protobuf.Int32Value 158, // 125: productv1.ResolveStorageNearbyStoragesRequest.context:type_name -> productv1.ResolveStorageNearbyStoragesContext 157, // 126: productv1.ResolveStorageNearbyStoragesRequest.field_args:type_name -> productv1.ResolveStorageNearbyStoragesArgs 18, // 127: productv1.ResolveStorageNearbyStoragesResult.nearby_storages:type_name -> productv1.ListOfStorage 160, // 128: productv1.ResolveStorageNearbyStoragesResponse.result:type_name -> productv1.ResolveStorageNearbyStoragesResult - 356, // 129: productv1.ResolveCategoryProductCountArgs.filters:type_name -> productv1.ProductCountFilter + 397, // 129: productv1.ResolveCategoryProductCountArgs.filters:type_name -> productv1.ProductCountFilter 163, // 130: productv1.ResolveCategoryProductCountRequest.context:type_name -> productv1.ResolveCategoryProductCountContext 162, // 131: productv1.ResolveCategoryProductCountRequest.field_args:type_name -> productv1.ResolveCategoryProductCountArgs 165, // 132: productv1.ResolveCategoryProductCountResponse.result:type_name -> productv1.ResolveCategoryProductCountResult - 387, // 133: productv1.ResolveCategoryPopularityScoreArgs.threshold:type_name -> google.protobuf.Int32Value + 458, // 133: productv1.ResolveCategoryPopularityScoreArgs.threshold:type_name -> google.protobuf.Int32Value 168, // 134: productv1.ResolveCategoryPopularityScoreRequest.context:type_name -> productv1.ResolveCategoryPopularityScoreContext 167, // 135: productv1.ResolveCategoryPopularityScoreRequest.field_args:type_name -> productv1.ResolveCategoryPopularityScoreArgs - 387, // 136: productv1.ResolveCategoryPopularityScoreResult.popularity_score:type_name -> google.protobuf.Int32Value + 458, // 136: productv1.ResolveCategoryPopularityScoreResult.popularity_score:type_name -> google.protobuf.Int32Value 170, // 137: productv1.ResolveCategoryPopularityScoreResponse.result:type_name -> productv1.ResolveCategoryPopularityScoreResult 173, // 138: productv1.ResolveCategoryCategoryMetricsRequest.context:type_name -> productv1.ResolveCategoryCategoryMetricsContext 172, // 139: productv1.ResolveCategoryCategoryMetricsRequest.field_args:type_name -> productv1.ResolveCategoryCategoryMetricsArgs - 343, // 140: productv1.ResolveCategoryCategoryMetricsResult.category_metrics:type_name -> productv1.CategoryMetrics + 373, // 140: productv1.ResolveCategoryCategoryMetricsResult.category_metrics:type_name -> productv1.CategoryMetrics 175, // 141: productv1.ResolveCategoryCategoryMetricsResponse.result:type_name -> productv1.ResolveCategoryCategoryMetricsResult 0, // 142: productv1.ResolveCategoryMascotContext.kind:type_name -> productv1.CategoryKind 178, // 143: productv1.ResolveCategoryMascotRequest.context:type_name -> productv1.ResolveCategoryMascotContext 177, // 144: productv1.ResolveCategoryMascotRequest.field_args:type_name -> productv1.ResolveCategoryMascotArgs - 316, // 145: productv1.ResolveCategoryMascotResult.mascot:type_name -> productv1.Animal + 346, // 145: productv1.ResolveCategoryMascotResult.mascot:type_name -> productv1.Animal 180, // 146: productv1.ResolveCategoryMascotResponse.result:type_name -> productv1.ResolveCategoryMascotResult 183, // 147: productv1.ResolveCategoryCategoryStatusRequest.context:type_name -> productv1.ResolveCategoryCategoryStatusContext 182, // 148: productv1.ResolveCategoryCategoryStatusRequest.field_args:type_name -> productv1.ResolveCategoryCategoryStatusArgs - 328, // 149: productv1.ResolveCategoryCategoryStatusResult.category_status:type_name -> productv1.ActionResult + 358, // 149: productv1.ResolveCategoryCategoryStatusResult.category_status:type_name -> productv1.ActionResult 185, // 150: productv1.ResolveCategoryCategoryStatusResponse.result:type_name -> productv1.ResolveCategoryCategoryStatusResult - 388, // 151: productv1.ResolveCategoryChildCategoriesArgs.include:type_name -> google.protobuf.BoolValue + 459, // 151: productv1.ResolveCategoryChildCategoriesArgs.include:type_name -> google.protobuf.BoolValue 188, // 152: productv1.ResolveCategoryChildCategoriesRequest.context:type_name -> productv1.ResolveCategoryChildCategoriesContext 187, // 153: productv1.ResolveCategoryChildCategoriesRequest.field_args:type_name -> productv1.ResolveCategoryChildCategoriesArgs - 314, // 154: productv1.ResolveCategoryChildCategoriesResult.child_categories:type_name -> productv1.Category + 344, // 154: productv1.ResolveCategoryChildCategoriesResult.child_categories:type_name -> productv1.Category 190, // 155: productv1.ResolveCategoryChildCategoriesResponse.result:type_name -> productv1.ResolveCategoryChildCategoriesResult - 388, // 156: productv1.ResolveCategoryOptionalCategoriesArgs.include:type_name -> google.protobuf.BoolValue + 459, // 156: productv1.ResolveCategoryOptionalCategoriesArgs.include:type_name -> google.protobuf.BoolValue 193, // 157: productv1.ResolveCategoryOptionalCategoriesRequest.context:type_name -> productv1.ResolveCategoryOptionalCategoriesContext 192, // 158: productv1.ResolveCategoryOptionalCategoriesRequest.field_args:type_name -> productv1.ResolveCategoryOptionalCategoriesArgs 8, // 159: productv1.ResolveCategoryOptionalCategoriesResult.optional_categories:type_name -> productv1.ListOfCategory @@ -20973,41 +25098,41 @@ var file_product_proto_depIdxs = []int32{ 197, // 161: productv1.ResolveCategoryTotalProductsRequest.context:type_name -> productv1.ResolveCategoryTotalProductsContext 199, // 162: productv1.ResolveCategoryTotalProductsResponse.result:type_name -> productv1.ResolveCategoryTotalProductsResult 201, // 163: productv1.ResolveCategoryTopSubcategoryRequest.context:type_name -> productv1.ResolveCategoryTopSubcategoryContext - 342, // 164: productv1.ResolveCategoryTopSubcategoryResult.top_subcategory:type_name -> productv1.Subcategory + 372, // 164: productv1.ResolveCategoryTopSubcategoryResult.top_subcategory:type_name -> productv1.Subcategory 203, // 165: productv1.ResolveCategoryTopSubcategoryResponse.result:type_name -> productv1.ResolveCategoryTopSubcategoryResult 205, // 166: productv1.ResolveCategoryActiveSubcategoriesRequest.context:type_name -> productv1.ResolveCategoryActiveSubcategoriesContext - 342, // 167: productv1.ResolveCategoryActiveSubcategoriesResult.active_subcategories:type_name -> productv1.Subcategory + 372, // 167: productv1.ResolveCategoryActiveSubcategoriesResult.active_subcategories:type_name -> productv1.Subcategory 207, // 168: productv1.ResolveCategoryActiveSubcategoriesResponse.result:type_name -> productv1.ResolveCategoryActiveSubcategoriesResult - 357, // 169: productv1.ResolveSubcategoryItemCountArgs.filters:type_name -> productv1.SubcategoryItemFilter + 398, // 169: productv1.ResolveSubcategoryItemCountArgs.filters:type_name -> productv1.SubcategoryItemFilter 210, // 170: productv1.ResolveSubcategoryItemCountRequest.context:type_name -> productv1.ResolveSubcategoryItemCountContext 209, // 171: productv1.ResolveSubcategoryItemCountRequest.field_args:type_name -> productv1.ResolveSubcategoryItemCountArgs 212, // 172: productv1.ResolveSubcategoryItemCountResponse.result:type_name -> productv1.ResolveSubcategoryItemCountResult 215, // 173: productv1.ResolveSubcategoryFeaturedCategoryRequest.context:type_name -> productv1.ResolveSubcategoryFeaturedCategoryContext 214, // 174: productv1.ResolveSubcategoryFeaturedCategoryRequest.field_args:type_name -> productv1.ResolveSubcategoryFeaturedCategoryArgs - 314, // 175: productv1.ResolveSubcategoryFeaturedCategoryResult.featured_category:type_name -> productv1.Category + 344, // 175: productv1.ResolveSubcategoryFeaturedCategoryResult.featured_category:type_name -> productv1.Category 217, // 176: productv1.ResolveSubcategoryFeaturedCategoryResponse.result:type_name -> productv1.ResolveSubcategoryFeaturedCategoryResult 219, // 177: productv1.ResolveSubcategoryParentCategoryRequest.context:type_name -> productv1.ResolveSubcategoryParentCategoryContext - 314, // 178: productv1.ResolveSubcategoryParentCategoryResult.parent_category:type_name -> productv1.Category + 344, // 178: productv1.ResolveSubcategoryParentCategoryResult.parent_category:type_name -> productv1.Category 221, // 179: productv1.ResolveSubcategoryParentCategoryResponse.result:type_name -> productv1.ResolveSubcategoryParentCategoryResult 224, // 180: productv1.ResolveCategoryMetricsNormalizedScoreRequest.context:type_name -> productv1.ResolveCategoryMetricsNormalizedScoreContext 223, // 181: productv1.ResolveCategoryMetricsNormalizedScoreRequest.field_args:type_name -> productv1.ResolveCategoryMetricsNormalizedScoreArgs 226, // 182: productv1.ResolveCategoryMetricsNormalizedScoreResponse.result:type_name -> productv1.ResolveCategoryMetricsNormalizedScoreResult - 388, // 183: productv1.ResolveCategoryMetricsRelatedCategoryArgs.include:type_name -> google.protobuf.BoolValue + 459, // 183: productv1.ResolveCategoryMetricsRelatedCategoryArgs.include:type_name -> google.protobuf.BoolValue 229, // 184: productv1.ResolveCategoryMetricsRelatedCategoryRequest.context:type_name -> productv1.ResolveCategoryMetricsRelatedCategoryContext 228, // 185: productv1.ResolveCategoryMetricsRelatedCategoryRequest.field_args:type_name -> productv1.ResolveCategoryMetricsRelatedCategoryArgs - 314, // 186: productv1.ResolveCategoryMetricsRelatedCategoryResult.related_category:type_name -> productv1.Category + 344, // 186: productv1.ResolveCategoryMetricsRelatedCategoryResult.related_category:type_name -> productv1.Category 231, // 187: productv1.ResolveCategoryMetricsRelatedCategoryResponse.result:type_name -> productv1.ResolveCategoryMetricsRelatedCategoryResult 233, // 188: productv1.ResolveCategoryMetricsAverageScoreRequest.context:type_name -> productv1.ResolveCategoryMetricsAverageScoreContext 235, // 189: productv1.ResolveCategoryMetricsAverageScoreResponse.result:type_name -> productv1.ResolveCategoryMetricsAverageScoreResult 238, // 190: productv1.ResolveTestContainerDetailsRequest.context:type_name -> productv1.ResolveTestContainerDetailsContext 237, // 191: productv1.ResolveTestContainerDetailsRequest.field_args:type_name -> productv1.ResolveTestContainerDetailsArgs - 354, // 192: productv1.ResolveTestContainerDetailsResult.details:type_name -> productv1.TestDetails + 395, // 192: productv1.ResolveTestContainerDetailsResult.details:type_name -> productv1.TestDetails 240, // 193: productv1.ResolveTestContainerDetailsResponse.result:type_name -> productv1.ResolveTestContainerDetailsResult 243, // 194: productv1.RequireStorageStockHealthScoreByIdRequest.context:type_name -> productv1.RequireStorageStockHealthScoreByIdContext 26, // 195: productv1.RequireStorageStockHealthScoreByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey 246, // 196: productv1.RequireStorageStockHealthScoreByIdContext.fields:type_name -> productv1.RequireStorageStockHealthScoreByIdFields 245, // 197: productv1.RequireStorageStockHealthScoreByIdResponse.result:type_name -> productv1.RequireStorageStockHealthScoreByIdResult - 380, // 198: productv1.RequireStorageStockHealthScoreByIdFields.restock_data:type_name -> productv1.RequireStorageStockHealthScoreByIdFields.RestockData + 421, // 198: productv1.RequireStorageStockHealthScoreByIdFields.restock_data:type_name -> productv1.RequireStorageStockHealthScoreByIdFields.RestockData 248, // 199: productv1.RequireStorageTagSummaryByIdRequest.context:type_name -> productv1.RequireStorageTagSummaryByIdContext 26, // 200: productv1.RequireStorageTagSummaryByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey 251, // 201: productv1.RequireStorageTagSummaryByIdContext.fields:type_name -> productv1.RequireStorageTagSummaryByIdFields @@ -21016,25 +25141,25 @@ var file_product_proto_depIdxs = []int32{ 26, // 204: productv1.RequireStorageOptionalTagSummaryByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey 256, // 205: productv1.RequireStorageOptionalTagSummaryByIdContext.fields:type_name -> productv1.RequireStorageOptionalTagSummaryByIdFields 255, // 206: productv1.RequireStorageOptionalTagSummaryByIdResponse.result:type_name -> productv1.RequireStorageOptionalTagSummaryByIdResult - 389, // 207: productv1.RequireStorageOptionalTagSummaryByIdResult.optional_tag_summary:type_name -> google.protobuf.StringValue + 460, // 207: productv1.RequireStorageOptionalTagSummaryByIdResult.optional_tag_summary:type_name -> google.protobuf.StringValue 19, // 208: productv1.RequireStorageOptionalTagSummaryByIdFields.optional_tags:type_name -> productv1.ListOfString 258, // 209: productv1.RequireStorageMetadataScoreByIdRequest.context:type_name -> productv1.RequireStorageMetadataScoreByIdContext 26, // 210: productv1.RequireStorageMetadataScoreByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey 261, // 211: productv1.RequireStorageMetadataScoreByIdContext.fields:type_name -> productv1.RequireStorageMetadataScoreByIdFields 260, // 212: productv1.RequireStorageMetadataScoreByIdResponse.result:type_name -> productv1.RequireStorageMetadataScoreByIdResult - 381, // 213: productv1.RequireStorageMetadataScoreByIdFields.metadata:type_name -> productv1.RequireStorageMetadataScoreByIdFields.StorageMetadata + 422, // 213: productv1.RequireStorageMetadataScoreByIdFields.metadata:type_name -> productv1.RequireStorageMetadataScoreByIdFields.StorageMetadata 263, // 214: productv1.RequireStorageProcessedMetadataByIdRequest.context:type_name -> productv1.RequireStorageProcessedMetadataByIdContext 26, // 215: productv1.RequireStorageProcessedMetadataByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey 266, // 216: productv1.RequireStorageProcessedMetadataByIdContext.fields:type_name -> productv1.RequireStorageProcessedMetadataByIdFields 265, // 217: productv1.RequireStorageProcessedMetadataByIdResponse.result:type_name -> productv1.RequireStorageProcessedMetadataByIdResult - 334, // 218: productv1.RequireStorageProcessedMetadataByIdResult.processed_metadata:type_name -> productv1.StorageMetadata - 382, // 219: productv1.RequireStorageProcessedMetadataByIdFields.metadata:type_name -> productv1.RequireStorageProcessedMetadataByIdFields.StorageMetadata + 364, // 218: productv1.RequireStorageProcessedMetadataByIdResult.processed_metadata:type_name -> productv1.StorageMetadata + 423, // 219: productv1.RequireStorageProcessedMetadataByIdFields.metadata:type_name -> productv1.RequireStorageProcessedMetadataByIdFields.StorageMetadata 268, // 220: productv1.RequireStorageOptionalProcessedMetadataByIdRequest.context:type_name -> productv1.RequireStorageOptionalProcessedMetadataByIdContext 26, // 221: productv1.RequireStorageOptionalProcessedMetadataByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey 271, // 222: productv1.RequireStorageOptionalProcessedMetadataByIdContext.fields:type_name -> productv1.RequireStorageOptionalProcessedMetadataByIdFields 270, // 223: productv1.RequireStorageOptionalProcessedMetadataByIdResponse.result:type_name -> productv1.RequireStorageOptionalProcessedMetadataByIdResult - 334, // 224: productv1.RequireStorageOptionalProcessedMetadataByIdResult.optional_processed_metadata:type_name -> productv1.StorageMetadata - 383, // 225: productv1.RequireStorageOptionalProcessedMetadataByIdFields.metadata:type_name -> productv1.RequireStorageOptionalProcessedMetadataByIdFields.StorageMetadata + 364, // 224: productv1.RequireStorageOptionalProcessedMetadataByIdResult.optional_processed_metadata:type_name -> productv1.StorageMetadata + 424, // 225: productv1.RequireStorageOptionalProcessedMetadataByIdFields.metadata:type_name -> productv1.RequireStorageOptionalProcessedMetadataByIdFields.StorageMetadata 273, // 226: productv1.RequireStorageProcessedTagsByIdRequest.context:type_name -> productv1.RequireStorageProcessedTagsByIdContext 26, // 227: productv1.RequireStorageProcessedTagsByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey 276, // 228: productv1.RequireStorageProcessedTagsByIdContext.fields:type_name -> productv1.RequireStorageProcessedTagsByIdFields @@ -21049,8 +25174,8 @@ var file_product_proto_depIdxs = []int32{ 26, // 237: productv1.RequireStorageProcessedMetadataHistoryByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey 286, // 238: productv1.RequireStorageProcessedMetadataHistoryByIdContext.fields:type_name -> productv1.RequireStorageProcessedMetadataHistoryByIdFields 285, // 239: productv1.RequireStorageProcessedMetadataHistoryByIdResponse.result:type_name -> productv1.RequireStorageProcessedMetadataHistoryByIdResult - 334, // 240: productv1.RequireStorageProcessedMetadataHistoryByIdResult.processed_metadata_history:type_name -> productv1.StorageMetadata - 384, // 241: productv1.RequireStorageProcessedMetadataHistoryByIdFields.metadata_history:type_name -> productv1.RequireStorageProcessedMetadataHistoryByIdFields.StorageMetadata + 364, // 240: productv1.RequireStorageProcessedMetadataHistoryByIdResult.processed_metadata_history:type_name -> productv1.StorageMetadata + 425, // 241: productv1.RequireStorageProcessedMetadataHistoryByIdFields.metadata_history:type_name -> productv1.RequireStorageProcessedMetadataHistoryByIdFields.StorageMetadata 288, // 242: productv1.RequireStorageKindSummaryByIdRequest.context:type_name -> productv1.RequireStorageKindSummaryByIdContext 26, // 243: productv1.RequireStorageKindSummaryByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey 291, // 244: productv1.RequireStorageKindSummaryByIdContext.fields:type_name -> productv1.RequireStorageKindSummaryByIdFields @@ -21060,316 +25185,394 @@ var file_product_proto_depIdxs = []int32{ 26, // 248: productv1.RequireStorageCategoryInfoSummaryByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey 296, // 249: productv1.RequireStorageCategoryInfoSummaryByIdContext.fields:type_name -> productv1.RequireStorageCategoryInfoSummaryByIdFields 295, // 250: productv1.RequireStorageCategoryInfoSummaryByIdResponse.result:type_name -> productv1.RequireStorageCategoryInfoSummaryByIdResult - 385, // 251: productv1.RequireStorageCategoryInfoSummaryByIdFields.category_info:type_name -> productv1.RequireStorageCategoryInfoSummaryByIdFields.StorageCategoryInfo - 298, // 252: productv1.RequireWarehouseStockHealthScoreByIdRequest.context:type_name -> productv1.RequireWarehouseStockHealthScoreByIdContext - 29, // 253: productv1.RequireWarehouseStockHealthScoreByIdContext.key:type_name -> productv1.LookupWarehouseByIdRequestKey - 301, // 254: productv1.RequireWarehouseStockHealthScoreByIdContext.fields:type_name -> productv1.RequireWarehouseStockHealthScoreByIdFields - 300, // 255: productv1.RequireWarehouseStockHealthScoreByIdResponse.result:type_name -> productv1.RequireWarehouseStockHealthScoreByIdResult - 386, // 256: productv1.RequireWarehouseStockHealthScoreByIdFields.restock_data:type_name -> productv1.RequireWarehouseStockHealthScoreByIdFields.RestockData - 336, // 257: productv1.NestedTypeA.b:type_name -> productv1.NestedTypeB - 307, // 258: productv1.RecursiveType.recursive_type:type_name -> productv1.RecursiveType - 338, // 259: productv1.ComplexFilterTypeInput.filter:type_name -> productv1.FilterType - 340, // 260: productv1.OrderInput.lines:type_name -> productv1.OrderLineInput - 16, // 261: productv1.Order.order_lines:type_name -> productv1.ListOfOrderLine - 0, // 262: productv1.Category.kind:type_name -> productv1.CategoryKind - 20, // 263: productv1.Category.subcategories:type_name -> productv1.ListOfSubcategory - 343, // 264: productv1.Category.null_metrics:type_name -> productv1.CategoryMetrics - 0, // 265: productv1.CategoryFilter.category:type_name -> productv1.CategoryKind - 339, // 266: productv1.CategoryFilter.pagination:type_name -> productv1.Pagination - 344, // 267: productv1.Animal.cat:type_name -> productv1.Cat - 345, // 268: productv1.Animal.dog:type_name -> productv1.Dog - 387, // 269: productv1.SearchInput.limit:type_name -> google.protobuf.Int32Value - 302, // 270: productv1.SearchResult.product:type_name -> productv1.Product - 305, // 271: productv1.SearchResult.user:type_name -> productv1.User - 314, // 272: productv1.SearchResult.category:type_name -> productv1.Category - 389, // 273: productv1.NullableFieldsType.optional_string:type_name -> google.protobuf.StringValue - 387, // 274: productv1.NullableFieldsType.optional_int:type_name -> google.protobuf.Int32Value - 390, // 275: productv1.NullableFieldsType.optional_float:type_name -> google.protobuf.DoubleValue - 388, // 276: productv1.NullableFieldsType.optional_boolean:type_name -> google.protobuf.BoolValue - 389, // 277: productv1.NullableFieldsFilter.name:type_name -> google.protobuf.StringValue - 389, // 278: productv1.NullableFieldsFilter.optional_string:type_name -> google.protobuf.StringValue - 388, // 279: productv1.NullableFieldsFilter.include_nulls:type_name -> google.protobuf.BoolValue - 19, // 280: productv1.BlogPost.optional_tags:type_name -> productv1.ListOfString - 19, // 281: productv1.BlogPost.keywords:type_name -> productv1.ListOfString - 10, // 282: productv1.BlogPost.ratings:type_name -> productv1.ListOfFloat - 7, // 283: productv1.BlogPost.is_published:type_name -> productv1.ListOfBoolean - 13, // 284: productv1.BlogPost.tag_groups:type_name -> productv1.ListOfListOfString - 13, // 285: productv1.BlogPost.related_topics:type_name -> productv1.ListOfListOfString - 13, // 286: productv1.BlogPost.comment_threads:type_name -> productv1.ListOfListOfString - 13, // 287: productv1.BlogPost.suggestions:type_name -> productv1.ListOfListOfString - 314, // 288: productv1.BlogPost.related_categories:type_name -> productv1.Category - 305, // 289: productv1.BlogPost.contributors:type_name -> productv1.User - 17, // 290: productv1.BlogPost.mentioned_products:type_name -> productv1.ListOfProduct - 21, // 291: productv1.BlogPost.mentioned_users:type_name -> productv1.ListOfUser - 11, // 292: productv1.BlogPost.category_groups:type_name -> productv1.ListOfListOfCategory - 14, // 293: productv1.BlogPost.contributor_teams:type_name -> productv1.ListOfListOfUser - 389, // 294: productv1.BlogPostFilter.title:type_name -> google.protobuf.StringValue - 388, // 295: productv1.BlogPostFilter.has_categories:type_name -> google.protobuf.BoolValue - 387, // 296: productv1.BlogPostFilter.min_tags:type_name -> google.protobuf.Int32Value - 389, // 297: productv1.Author.email:type_name -> google.protobuf.StringValue - 19, // 298: productv1.Author.social_links:type_name -> productv1.ListOfString - 13, // 299: productv1.Author.teams_by_project:type_name -> productv1.ListOfListOfString - 13, // 300: productv1.Author.collaborations:type_name -> productv1.ListOfListOfString - 4, // 301: productv1.Author.written_posts:type_name -> productv1.ListOfBlogPost - 314, // 302: productv1.Author.favorite_categories:type_name -> productv1.Category - 21, // 303: productv1.Author.related_authors:type_name -> productv1.ListOfUser - 17, // 304: productv1.Author.product_reviews:type_name -> productv1.ListOfProduct - 14, // 305: productv1.Author.author_groups:type_name -> productv1.ListOfListOfUser - 11, // 306: productv1.Author.category_preferences:type_name -> productv1.ListOfListOfCategory - 14, // 307: productv1.Author.project_teams:type_name -> productv1.ListOfListOfUser - 389, // 308: productv1.AuthorFilter.name:type_name -> google.protobuf.StringValue - 388, // 309: productv1.AuthorFilter.has_teams:type_name -> google.protobuf.BoolValue - 387, // 310: productv1.AuthorFilter.skill_count:type_name -> google.protobuf.Int32Value - 389, // 311: productv1.TestContainer.description:type_name -> google.protobuf.StringValue - 352, // 312: productv1.ActionResult.action_success:type_name -> productv1.ActionSuccess - 353, // 313: productv1.ActionResult.action_error:type_name -> productv1.ActionError - 389, // 314: productv1.NullableFieldsInput.optional_string:type_name -> google.protobuf.StringValue - 387, // 315: productv1.NullableFieldsInput.optional_int:type_name -> google.protobuf.Int32Value - 390, // 316: productv1.NullableFieldsInput.optional_float:type_name -> google.protobuf.DoubleValue - 388, // 317: productv1.NullableFieldsInput.optional_boolean:type_name -> google.protobuf.BoolValue - 19, // 318: productv1.BlogPostInput.optional_tags:type_name -> productv1.ListOfString - 19, // 319: productv1.BlogPostInput.keywords:type_name -> productv1.ListOfString - 10, // 320: productv1.BlogPostInput.ratings:type_name -> productv1.ListOfFloat - 7, // 321: productv1.BlogPostInput.is_published:type_name -> productv1.ListOfBoolean - 13, // 322: productv1.BlogPostInput.tag_groups:type_name -> productv1.ListOfListOfString - 13, // 323: productv1.BlogPostInput.related_topics:type_name -> productv1.ListOfListOfString - 13, // 324: productv1.BlogPostInput.comment_threads:type_name -> productv1.ListOfListOfString - 13, // 325: productv1.BlogPostInput.suggestions:type_name -> productv1.ListOfListOfString - 9, // 326: productv1.BlogPostInput.related_categories:type_name -> productv1.ListOfCategoryInput - 22, // 327: productv1.BlogPostInput.contributors:type_name -> productv1.ListOfUserInput - 12, // 328: productv1.BlogPostInput.category_groups:type_name -> productv1.ListOfListOfCategoryInput - 389, // 329: productv1.AuthorInput.email:type_name -> google.protobuf.StringValue - 19, // 330: productv1.AuthorInput.social_links:type_name -> productv1.ListOfString - 13, // 331: productv1.AuthorInput.teams_by_project:type_name -> productv1.ListOfListOfString - 13, // 332: productv1.AuthorInput.collaborations:type_name -> productv1.ListOfListOfString - 355, // 333: productv1.AuthorInput.favorite_categories:type_name -> productv1.CategoryInput - 15, // 334: productv1.AuthorInput.author_groups:type_name -> productv1.ListOfListOfUserInput - 15, // 335: productv1.AuthorInput.project_teams:type_name -> productv1.ListOfListOfUserInput - 328, // 336: productv1.ProductDetails.review_summary:type_name -> productv1.ActionResult - 316, // 337: productv1.ProductDetails.recommended_pet:type_name -> productv1.Animal - 0, // 338: productv1.StorageCategoryInfo.kind:type_name -> productv1.CategoryKind - 337, // 339: productv1.NestedTypeB.c:type_name -> productv1.NestedTypeC - 339, // 340: productv1.FilterType.pagination:type_name -> productv1.Pagination - 19, // 341: productv1.OrderLineInput.modifiers:type_name -> productv1.ListOfString - 19, // 342: productv1.OrderLine.modifiers:type_name -> productv1.ListOfString - 389, // 343: productv1.Subcategory.description:type_name -> google.protobuf.StringValue - 346, // 344: productv1.Cat.owner:type_name -> productv1.Owner - 349, // 345: productv1.Cat.breed:type_name -> productv1.CatBreed - 346, // 346: productv1.Dog.owner:type_name -> productv1.Owner - 350, // 347: productv1.Dog.breed:type_name -> productv1.DogBreed - 347, // 348: productv1.Owner.contact:type_name -> productv1.ContactInfo - 316, // 349: productv1.Owner.pet:type_name -> productv1.Animal - 348, // 350: productv1.ContactInfo.address:type_name -> productv1.Address - 351, // 351: productv1.CatBreed.characteristics:type_name -> productv1.BreedCharacteristics - 351, // 352: productv1.DogBreed.characteristics:type_name -> productv1.BreedCharacteristics - 316, // 353: productv1.TestDetails.pet:type_name -> productv1.Animal - 328, // 354: productv1.TestDetails.status:type_name -> productv1.ActionResult - 0, // 355: productv1.CategoryInput.kind:type_name -> productv1.CategoryKind - 390, // 356: productv1.ProductCountFilter.min_price:type_name -> google.protobuf.DoubleValue - 390, // 357: productv1.ProductCountFilter.max_price:type_name -> google.protobuf.DoubleValue - 388, // 358: productv1.ProductCountFilter.in_stock:type_name -> google.protobuf.BoolValue - 389, // 359: productv1.ProductCountFilter.search_term:type_name -> google.protobuf.StringValue - 390, // 360: productv1.SubcategoryItemFilter.min_price:type_name -> google.protobuf.DoubleValue - 390, // 361: productv1.SubcategoryItemFilter.max_price:type_name -> google.protobuf.DoubleValue - 388, // 362: productv1.SubcategoryItemFilter.in_stock:type_name -> google.protobuf.BoolValue - 388, // 363: productv1.SubcategoryItemFilter.is_active:type_name -> google.protobuf.BoolValue - 389, // 364: productv1.SubcategoryItemFilter.search_term:type_name -> google.protobuf.StringValue - 1, // 365: productv1.ShippingEstimateInput.destination:type_name -> productv1.ShippingDestination - 388, // 366: productv1.ShippingEstimateInput.expedited:type_name -> google.protobuf.BoolValue - 324, // 367: productv1.ListOfAuthorFilter.List.items:type_name -> productv1.AuthorFilter - 331, // 368: productv1.ListOfAuthorInput.List.items:type_name -> productv1.AuthorInput - 321, // 369: productv1.ListOfBlogPost.List.items:type_name -> productv1.BlogPost - 322, // 370: productv1.ListOfBlogPostFilter.List.items:type_name -> productv1.BlogPostFilter - 330, // 371: productv1.ListOfBlogPostInput.List.items:type_name -> productv1.BlogPostInput - 314, // 372: productv1.ListOfCategory.List.items:type_name -> productv1.Category - 355, // 373: productv1.ListOfCategoryInput.List.items:type_name -> productv1.CategoryInput - 8, // 374: productv1.ListOfListOfCategory.List.items:type_name -> productv1.ListOfCategory - 9, // 375: productv1.ListOfListOfCategoryInput.List.items:type_name -> productv1.ListOfCategoryInput - 19, // 376: productv1.ListOfListOfString.List.items:type_name -> productv1.ListOfString - 21, // 377: productv1.ListOfListOfUser.List.items:type_name -> productv1.ListOfUser - 22, // 378: productv1.ListOfListOfUserInput.List.items:type_name -> productv1.ListOfUserInput - 341, // 379: productv1.ListOfOrderLine.List.items:type_name -> productv1.OrderLine - 302, // 380: productv1.ListOfProduct.List.items:type_name -> productv1.Product - 303, // 381: productv1.ListOfStorage.List.items:type_name -> productv1.Storage - 342, // 382: productv1.ListOfSubcategory.List.items:type_name -> productv1.Subcategory - 305, // 383: productv1.ListOfUser.List.items:type_name -> productv1.User - 326, // 384: productv1.ListOfUserInput.List.items:type_name -> productv1.UserInput - 0, // 385: productv1.RequireStorageCategoryInfoSummaryByIdFields.StorageCategoryInfo.kind:type_name -> productv1.CategoryKind - 24, // 386: productv1.ProductService.LookupProductById:input_type -> productv1.LookupProductByIdRequest - 27, // 387: productv1.ProductService.LookupStorageById:input_type -> productv1.LookupStorageByIdRequest - 30, // 388: productv1.ProductService.LookupWarehouseById:input_type -> productv1.LookupWarehouseByIdRequest - 114, // 389: productv1.ProductService.MutationBulkCreateAuthors:input_type -> productv1.MutationBulkCreateAuthorsRequest - 118, // 390: productv1.ProductService.MutationBulkCreateBlogPosts:input_type -> productv1.MutationBulkCreateBlogPostsRequest - 116, // 391: productv1.ProductService.MutationBulkUpdateAuthors:input_type -> productv1.MutationBulkUpdateAuthorsRequest - 120, // 392: productv1.ProductService.MutationBulkUpdateBlogPosts:input_type -> productv1.MutationBulkUpdateBlogPostsRequest - 110, // 393: productv1.ProductService.MutationCreateAuthor:input_type -> productv1.MutationCreateAuthorRequest - 106, // 394: productv1.ProductService.MutationCreateBlogPost:input_type -> productv1.MutationCreateBlogPostRequest - 102, // 395: productv1.ProductService.MutationCreateNullableFieldsType:input_type -> productv1.MutationCreateNullableFieldsTypeRequest - 98, // 396: productv1.ProductService.MutationCreateUser:input_type -> productv1.MutationCreateUserRequest - 100, // 397: productv1.ProductService.MutationPerformAction:input_type -> productv1.MutationPerformActionRequest - 112, // 398: productv1.ProductService.MutationUpdateAuthor:input_type -> productv1.MutationUpdateAuthorRequest - 108, // 399: productv1.ProductService.MutationUpdateBlogPost:input_type -> productv1.MutationUpdateBlogPostRequest - 104, // 400: productv1.ProductService.MutationUpdateNullableFieldsType:input_type -> productv1.MutationUpdateNullableFieldsTypeRequest - 88, // 401: productv1.ProductService.QueryAllAuthors:input_type -> productv1.QueryAllAuthorsRequest - 80, // 402: productv1.ProductService.QueryAllBlogPosts:input_type -> productv1.QueryAllBlogPostsRequest - 72, // 403: productv1.ProductService.QueryAllNullableFieldsTypes:input_type -> productv1.QueryAllNullableFieldsTypesRequest - 60, // 404: productv1.ProductService.QueryAllPets:input_type -> productv1.QueryAllPetsRequest - 82, // 405: productv1.ProductService.QueryAuthor:input_type -> productv1.QueryAuthorRequest - 84, // 406: productv1.ProductService.QueryAuthorById:input_type -> productv1.QueryAuthorByIdRequest - 86, // 407: productv1.ProductService.QueryAuthorsWithFilter:input_type -> productv1.QueryAuthorsWithFilterRequest - 74, // 408: productv1.ProductService.QueryBlogPost:input_type -> productv1.QueryBlogPostRequest - 76, // 409: productv1.ProductService.QueryBlogPostById:input_type -> productv1.QueryBlogPostByIdRequest - 78, // 410: productv1.ProductService.QueryBlogPostsWithFilter:input_type -> productv1.QueryBlogPostsWithFilterRequest - 90, // 411: productv1.ProductService.QueryBulkSearchAuthors:input_type -> productv1.QueryBulkSearchAuthorsRequest - 92, // 412: productv1.ProductService.QueryBulkSearchBlogPosts:input_type -> productv1.QueryBulkSearchBlogPostsRequest - 46, // 413: productv1.ProductService.QueryCalculateTotals:input_type -> productv1.QueryCalculateTotalsRequest - 48, // 414: productv1.ProductService.QueryCategories:input_type -> productv1.QueryCategoriesRequest - 52, // 415: productv1.ProductService.QueryCategoriesByKind:input_type -> productv1.QueryCategoriesByKindRequest - 54, // 416: productv1.ProductService.QueryCategoriesByKinds:input_type -> productv1.QueryCategoriesByKindsRequest - 50, // 417: productv1.ProductService.QueryCategory:input_type -> productv1.QueryCategoryRequest - 44, // 418: productv1.ProductService.QueryComplexFilterType:input_type -> productv1.QueryComplexFilterTypeRequest - 56, // 419: productv1.ProductService.QueryFilterCategories:input_type -> productv1.QueryFilterCategoriesRequest - 36, // 420: productv1.ProductService.QueryNestedType:input_type -> productv1.QueryNestedTypeRequest - 66, // 421: productv1.ProductService.QueryNullableFieldsType:input_type -> productv1.QueryNullableFieldsTypeRequest - 68, // 422: productv1.ProductService.QueryNullableFieldsTypeById:input_type -> productv1.QueryNullableFieldsTypeByIdRequest - 70, // 423: productv1.ProductService.QueryNullableFieldsTypeWithFilter:input_type -> productv1.QueryNullableFieldsTypeWithFilterRequest - 58, // 424: productv1.ProductService.QueryRandomPet:input_type -> productv1.QueryRandomPetRequest - 64, // 425: productv1.ProductService.QueryRandomSearchResult:input_type -> productv1.QueryRandomSearchResultRequest - 38, // 426: productv1.ProductService.QueryRecursiveType:input_type -> productv1.QueryRecursiveTypeRequest - 62, // 427: productv1.ProductService.QuerySearch:input_type -> productv1.QuerySearchRequest - 94, // 428: productv1.ProductService.QueryTestContainer:input_type -> productv1.QueryTestContainerRequest - 96, // 429: productv1.ProductService.QueryTestContainers:input_type -> productv1.QueryTestContainersRequest - 40, // 430: productv1.ProductService.QueryTypeFilterWithArguments:input_type -> productv1.QueryTypeFilterWithArgumentsRequest - 42, // 431: productv1.ProductService.QueryTypeWithMultipleFilterFields:input_type -> productv1.QueryTypeWithMultipleFilterFieldsRequest - 34, // 432: productv1.ProductService.QueryUser:input_type -> productv1.QueryUserRequest - 32, // 433: productv1.ProductService.QueryUsers:input_type -> productv1.QueryUsersRequest - 292, // 434: productv1.ProductService.RequireStorageCategoryInfoSummaryById:input_type -> productv1.RequireStorageCategoryInfoSummaryByIdRequest - 287, // 435: productv1.ProductService.RequireStorageKindSummaryById:input_type -> productv1.RequireStorageKindSummaryByIdRequest - 257, // 436: productv1.ProductService.RequireStorageMetadataScoreById:input_type -> productv1.RequireStorageMetadataScoreByIdRequest - 267, // 437: productv1.ProductService.RequireStorageOptionalProcessedMetadataById:input_type -> productv1.RequireStorageOptionalProcessedMetadataByIdRequest - 277, // 438: productv1.ProductService.RequireStorageOptionalProcessedTagsById:input_type -> productv1.RequireStorageOptionalProcessedTagsByIdRequest - 252, // 439: productv1.ProductService.RequireStorageOptionalTagSummaryById:input_type -> productv1.RequireStorageOptionalTagSummaryByIdRequest - 262, // 440: productv1.ProductService.RequireStorageProcessedMetadataById:input_type -> productv1.RequireStorageProcessedMetadataByIdRequest - 282, // 441: productv1.ProductService.RequireStorageProcessedMetadataHistoryById:input_type -> productv1.RequireStorageProcessedMetadataHistoryByIdRequest - 272, // 442: productv1.ProductService.RequireStorageProcessedTagsById:input_type -> productv1.RequireStorageProcessedTagsByIdRequest - 242, // 443: productv1.ProductService.RequireStorageStockHealthScoreById:input_type -> productv1.RequireStorageStockHealthScoreByIdRequest - 247, // 444: productv1.ProductService.RequireStorageTagSummaryById:input_type -> productv1.RequireStorageTagSummaryByIdRequest - 297, // 445: productv1.ProductService.RequireWarehouseStockHealthScoreById:input_type -> productv1.RequireWarehouseStockHealthScoreByIdRequest - 206, // 446: productv1.ProductService.ResolveCategoryActiveSubcategories:input_type -> productv1.ResolveCategoryActiveSubcategoriesRequest - 174, // 447: productv1.ProductService.ResolveCategoryCategoryMetrics:input_type -> productv1.ResolveCategoryCategoryMetricsRequest - 184, // 448: productv1.ProductService.ResolveCategoryCategoryStatus:input_type -> productv1.ResolveCategoryCategoryStatusRequest - 189, // 449: productv1.ProductService.ResolveCategoryChildCategories:input_type -> productv1.ResolveCategoryChildCategoriesRequest - 179, // 450: productv1.ProductService.ResolveCategoryMascot:input_type -> productv1.ResolveCategoryMascotRequest - 234, // 451: productv1.ProductService.ResolveCategoryMetricsAverageScore:input_type -> productv1.ResolveCategoryMetricsAverageScoreRequest - 225, // 452: productv1.ProductService.ResolveCategoryMetricsNormalizedScore:input_type -> productv1.ResolveCategoryMetricsNormalizedScoreRequest - 230, // 453: productv1.ProductService.ResolveCategoryMetricsRelatedCategory:input_type -> productv1.ResolveCategoryMetricsRelatedCategoryRequest - 194, // 454: productv1.ProductService.ResolveCategoryOptionalCategories:input_type -> productv1.ResolveCategoryOptionalCategoriesRequest - 169, // 455: productv1.ProductService.ResolveCategoryPopularityScore:input_type -> productv1.ResolveCategoryPopularityScoreRequest - 164, // 456: productv1.ProductService.ResolveCategoryProductCount:input_type -> productv1.ResolveCategoryProductCountRequest - 202, // 457: productv1.ProductService.ResolveCategoryTopSubcategory:input_type -> productv1.ResolveCategoryTopSubcategoryRequest - 198, // 458: productv1.ProductService.ResolveCategoryTotalProducts:input_type -> productv1.ResolveCategoryTotalProductsRequest - 134, // 459: productv1.ProductService.ResolveProductMascotRecommendation:input_type -> productv1.ResolveProductMascotRecommendationRequest - 144, // 460: productv1.ProductService.ResolveProductProductDetails:input_type -> productv1.ResolveProductProductDetailsRequest - 129, // 461: productv1.ProductService.ResolveProductRecommendedCategory:input_type -> productv1.ResolveProductRecommendedCategoryRequest - 124, // 462: productv1.ProductService.ResolveProductShippingEstimate:input_type -> productv1.ResolveProductShippingEstimateRequest - 139, // 463: productv1.ProductService.ResolveProductStockStatus:input_type -> productv1.ResolveProductStockStatusRequest - 154, // 464: productv1.ProductService.ResolveStorageLinkedStorages:input_type -> productv1.ResolveStorageLinkedStoragesRequest - 159, // 465: productv1.ProductService.ResolveStorageNearbyStorages:input_type -> productv1.ResolveStorageNearbyStoragesRequest - 149, // 466: productv1.ProductService.ResolveStorageStorageStatus:input_type -> productv1.ResolveStorageStorageStatusRequest - 216, // 467: productv1.ProductService.ResolveSubcategoryFeaturedCategory:input_type -> productv1.ResolveSubcategoryFeaturedCategoryRequest - 211, // 468: productv1.ProductService.ResolveSubcategoryItemCount:input_type -> productv1.ResolveSubcategoryItemCountRequest - 220, // 469: productv1.ProductService.ResolveSubcategoryParentCategory:input_type -> productv1.ResolveSubcategoryParentCategoryRequest - 239, // 470: productv1.ProductService.ResolveTestContainerDetails:input_type -> productv1.ResolveTestContainerDetailsRequest - 25, // 471: productv1.ProductService.LookupProductById:output_type -> productv1.LookupProductByIdResponse - 28, // 472: productv1.ProductService.LookupStorageById:output_type -> productv1.LookupStorageByIdResponse - 31, // 473: productv1.ProductService.LookupWarehouseById:output_type -> productv1.LookupWarehouseByIdResponse - 115, // 474: productv1.ProductService.MutationBulkCreateAuthors:output_type -> productv1.MutationBulkCreateAuthorsResponse - 119, // 475: productv1.ProductService.MutationBulkCreateBlogPosts:output_type -> productv1.MutationBulkCreateBlogPostsResponse - 117, // 476: productv1.ProductService.MutationBulkUpdateAuthors:output_type -> productv1.MutationBulkUpdateAuthorsResponse - 121, // 477: productv1.ProductService.MutationBulkUpdateBlogPosts:output_type -> productv1.MutationBulkUpdateBlogPostsResponse - 111, // 478: productv1.ProductService.MutationCreateAuthor:output_type -> productv1.MutationCreateAuthorResponse - 107, // 479: productv1.ProductService.MutationCreateBlogPost:output_type -> productv1.MutationCreateBlogPostResponse - 103, // 480: productv1.ProductService.MutationCreateNullableFieldsType:output_type -> productv1.MutationCreateNullableFieldsTypeResponse - 99, // 481: productv1.ProductService.MutationCreateUser:output_type -> productv1.MutationCreateUserResponse - 101, // 482: productv1.ProductService.MutationPerformAction:output_type -> productv1.MutationPerformActionResponse - 113, // 483: productv1.ProductService.MutationUpdateAuthor:output_type -> productv1.MutationUpdateAuthorResponse - 109, // 484: productv1.ProductService.MutationUpdateBlogPost:output_type -> productv1.MutationUpdateBlogPostResponse - 105, // 485: productv1.ProductService.MutationUpdateNullableFieldsType:output_type -> productv1.MutationUpdateNullableFieldsTypeResponse - 89, // 486: productv1.ProductService.QueryAllAuthors:output_type -> productv1.QueryAllAuthorsResponse - 81, // 487: productv1.ProductService.QueryAllBlogPosts:output_type -> productv1.QueryAllBlogPostsResponse - 73, // 488: productv1.ProductService.QueryAllNullableFieldsTypes:output_type -> productv1.QueryAllNullableFieldsTypesResponse - 61, // 489: productv1.ProductService.QueryAllPets:output_type -> productv1.QueryAllPetsResponse - 83, // 490: productv1.ProductService.QueryAuthor:output_type -> productv1.QueryAuthorResponse - 85, // 491: productv1.ProductService.QueryAuthorById:output_type -> productv1.QueryAuthorByIdResponse - 87, // 492: productv1.ProductService.QueryAuthorsWithFilter:output_type -> productv1.QueryAuthorsWithFilterResponse - 75, // 493: productv1.ProductService.QueryBlogPost:output_type -> productv1.QueryBlogPostResponse - 77, // 494: productv1.ProductService.QueryBlogPostById:output_type -> productv1.QueryBlogPostByIdResponse - 79, // 495: productv1.ProductService.QueryBlogPostsWithFilter:output_type -> productv1.QueryBlogPostsWithFilterResponse - 91, // 496: productv1.ProductService.QueryBulkSearchAuthors:output_type -> productv1.QueryBulkSearchAuthorsResponse - 93, // 497: productv1.ProductService.QueryBulkSearchBlogPosts:output_type -> productv1.QueryBulkSearchBlogPostsResponse - 47, // 498: productv1.ProductService.QueryCalculateTotals:output_type -> productv1.QueryCalculateTotalsResponse - 49, // 499: productv1.ProductService.QueryCategories:output_type -> productv1.QueryCategoriesResponse - 53, // 500: productv1.ProductService.QueryCategoriesByKind:output_type -> productv1.QueryCategoriesByKindResponse - 55, // 501: productv1.ProductService.QueryCategoriesByKinds:output_type -> productv1.QueryCategoriesByKindsResponse - 51, // 502: productv1.ProductService.QueryCategory:output_type -> productv1.QueryCategoryResponse - 45, // 503: productv1.ProductService.QueryComplexFilterType:output_type -> productv1.QueryComplexFilterTypeResponse - 57, // 504: productv1.ProductService.QueryFilterCategories:output_type -> productv1.QueryFilterCategoriesResponse - 37, // 505: productv1.ProductService.QueryNestedType:output_type -> productv1.QueryNestedTypeResponse - 67, // 506: productv1.ProductService.QueryNullableFieldsType:output_type -> productv1.QueryNullableFieldsTypeResponse - 69, // 507: productv1.ProductService.QueryNullableFieldsTypeById:output_type -> productv1.QueryNullableFieldsTypeByIdResponse - 71, // 508: productv1.ProductService.QueryNullableFieldsTypeWithFilter:output_type -> productv1.QueryNullableFieldsTypeWithFilterResponse - 59, // 509: productv1.ProductService.QueryRandomPet:output_type -> productv1.QueryRandomPetResponse - 65, // 510: productv1.ProductService.QueryRandomSearchResult:output_type -> productv1.QueryRandomSearchResultResponse - 39, // 511: productv1.ProductService.QueryRecursiveType:output_type -> productv1.QueryRecursiveTypeResponse - 63, // 512: productv1.ProductService.QuerySearch:output_type -> productv1.QuerySearchResponse - 95, // 513: productv1.ProductService.QueryTestContainer:output_type -> productv1.QueryTestContainerResponse - 97, // 514: productv1.ProductService.QueryTestContainers:output_type -> productv1.QueryTestContainersResponse - 41, // 515: productv1.ProductService.QueryTypeFilterWithArguments:output_type -> productv1.QueryTypeFilterWithArgumentsResponse - 43, // 516: productv1.ProductService.QueryTypeWithMultipleFilterFields:output_type -> productv1.QueryTypeWithMultipleFilterFieldsResponse - 35, // 517: productv1.ProductService.QueryUser:output_type -> productv1.QueryUserResponse - 33, // 518: productv1.ProductService.QueryUsers:output_type -> productv1.QueryUsersResponse - 294, // 519: productv1.ProductService.RequireStorageCategoryInfoSummaryById:output_type -> productv1.RequireStorageCategoryInfoSummaryByIdResponse - 289, // 520: productv1.ProductService.RequireStorageKindSummaryById:output_type -> productv1.RequireStorageKindSummaryByIdResponse - 259, // 521: productv1.ProductService.RequireStorageMetadataScoreById:output_type -> productv1.RequireStorageMetadataScoreByIdResponse - 269, // 522: productv1.ProductService.RequireStorageOptionalProcessedMetadataById:output_type -> productv1.RequireStorageOptionalProcessedMetadataByIdResponse - 279, // 523: productv1.ProductService.RequireStorageOptionalProcessedTagsById:output_type -> productv1.RequireStorageOptionalProcessedTagsByIdResponse - 254, // 524: productv1.ProductService.RequireStorageOptionalTagSummaryById:output_type -> productv1.RequireStorageOptionalTagSummaryByIdResponse - 264, // 525: productv1.ProductService.RequireStorageProcessedMetadataById:output_type -> productv1.RequireStorageProcessedMetadataByIdResponse - 284, // 526: productv1.ProductService.RequireStorageProcessedMetadataHistoryById:output_type -> productv1.RequireStorageProcessedMetadataHistoryByIdResponse - 274, // 527: productv1.ProductService.RequireStorageProcessedTagsById:output_type -> productv1.RequireStorageProcessedTagsByIdResponse - 244, // 528: productv1.ProductService.RequireStorageStockHealthScoreById:output_type -> productv1.RequireStorageStockHealthScoreByIdResponse - 249, // 529: productv1.ProductService.RequireStorageTagSummaryById:output_type -> productv1.RequireStorageTagSummaryByIdResponse - 299, // 530: productv1.ProductService.RequireWarehouseStockHealthScoreById:output_type -> productv1.RequireWarehouseStockHealthScoreByIdResponse - 208, // 531: productv1.ProductService.ResolveCategoryActiveSubcategories:output_type -> productv1.ResolveCategoryActiveSubcategoriesResponse - 176, // 532: productv1.ProductService.ResolveCategoryCategoryMetrics:output_type -> productv1.ResolveCategoryCategoryMetricsResponse - 186, // 533: productv1.ProductService.ResolveCategoryCategoryStatus:output_type -> productv1.ResolveCategoryCategoryStatusResponse - 191, // 534: productv1.ProductService.ResolveCategoryChildCategories:output_type -> productv1.ResolveCategoryChildCategoriesResponse - 181, // 535: productv1.ProductService.ResolveCategoryMascot:output_type -> productv1.ResolveCategoryMascotResponse - 236, // 536: productv1.ProductService.ResolveCategoryMetricsAverageScore:output_type -> productv1.ResolveCategoryMetricsAverageScoreResponse - 227, // 537: productv1.ProductService.ResolveCategoryMetricsNormalizedScore:output_type -> productv1.ResolveCategoryMetricsNormalizedScoreResponse - 232, // 538: productv1.ProductService.ResolveCategoryMetricsRelatedCategory:output_type -> productv1.ResolveCategoryMetricsRelatedCategoryResponse - 196, // 539: productv1.ProductService.ResolveCategoryOptionalCategories:output_type -> productv1.ResolveCategoryOptionalCategoriesResponse - 171, // 540: productv1.ProductService.ResolveCategoryPopularityScore:output_type -> productv1.ResolveCategoryPopularityScoreResponse - 166, // 541: productv1.ProductService.ResolveCategoryProductCount:output_type -> productv1.ResolveCategoryProductCountResponse - 204, // 542: productv1.ProductService.ResolveCategoryTopSubcategory:output_type -> productv1.ResolveCategoryTopSubcategoryResponse - 200, // 543: productv1.ProductService.ResolveCategoryTotalProducts:output_type -> productv1.ResolveCategoryTotalProductsResponse - 136, // 544: productv1.ProductService.ResolveProductMascotRecommendation:output_type -> productv1.ResolveProductMascotRecommendationResponse - 146, // 545: productv1.ProductService.ResolveProductProductDetails:output_type -> productv1.ResolveProductProductDetailsResponse - 131, // 546: productv1.ProductService.ResolveProductRecommendedCategory:output_type -> productv1.ResolveProductRecommendedCategoryResponse - 126, // 547: productv1.ProductService.ResolveProductShippingEstimate:output_type -> productv1.ResolveProductShippingEstimateResponse - 141, // 548: productv1.ProductService.ResolveProductStockStatus:output_type -> productv1.ResolveProductStockStatusResponse - 156, // 549: productv1.ProductService.ResolveStorageLinkedStorages:output_type -> productv1.ResolveStorageLinkedStoragesResponse - 161, // 550: productv1.ProductService.ResolveStorageNearbyStorages:output_type -> productv1.ResolveStorageNearbyStoragesResponse - 151, // 551: productv1.ProductService.ResolveStorageStorageStatus:output_type -> productv1.ResolveStorageStorageStatusResponse - 218, // 552: productv1.ProductService.ResolveSubcategoryFeaturedCategory:output_type -> productv1.ResolveSubcategoryFeaturedCategoryResponse - 213, // 553: productv1.ProductService.ResolveSubcategoryItemCount:output_type -> productv1.ResolveSubcategoryItemCountResponse - 222, // 554: productv1.ProductService.ResolveSubcategoryParentCategory:output_type -> productv1.ResolveSubcategoryParentCategoryResponse - 241, // 555: productv1.ProductService.ResolveTestContainerDetails:output_type -> productv1.ResolveTestContainerDetailsResponse - 471, // [471:556] is the sub-list for method output_type - 386, // [386:471] is the sub-list for method input_type - 386, // [386:386] is the sub-list for extension type_name - 386, // [386:386] is the sub-list for extension extendee - 0, // [0:386] is the sub-list for field type_name + 426, // 251: productv1.RequireStorageCategoryInfoSummaryByIdFields.category_info:type_name -> productv1.RequireStorageCategoryInfoSummaryByIdFields.StorageCategoryInfo + 298, // 252: productv1.RequireStorageItemInfoByIdRequest.context:type_name -> productv1.RequireStorageItemInfoByIdContext + 26, // 253: productv1.RequireStorageItemInfoByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey + 301, // 254: productv1.RequireStorageItemInfoByIdContext.fields:type_name -> productv1.RequireStorageItemInfoByIdFields + 300, // 255: productv1.RequireStorageItemInfoByIdResponse.result:type_name -> productv1.RequireStorageItemInfoByIdResult + 429, // 256: productv1.RequireStorageItemInfoByIdFields.primary_item:type_name -> productv1.RequireStorageItemInfoByIdFields.StorageItem + 303, // 257: productv1.RequireStorageOperationReportByIdRequest.context:type_name -> productv1.RequireStorageOperationReportByIdContext + 26, // 258: productv1.RequireStorageOperationReportByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey + 306, // 259: productv1.RequireStorageOperationReportByIdContext.fields:type_name -> productv1.RequireStorageOperationReportByIdFields + 305, // 260: productv1.RequireStorageOperationReportByIdResponse.result:type_name -> productv1.RequireStorageOperationReportByIdResult + 432, // 261: productv1.RequireStorageOperationReportByIdFields.last_storage_operation:type_name -> productv1.RequireStorageOperationReportByIdFields.StorageOperationResult + 308, // 262: productv1.RequireStorageSecuritySummaryByIdRequest.context:type_name -> productv1.RequireStorageSecuritySummaryByIdContext + 26, // 263: productv1.RequireStorageSecuritySummaryByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey + 311, // 264: productv1.RequireStorageSecuritySummaryByIdContext.fields:type_name -> productv1.RequireStorageSecuritySummaryByIdFields + 310, // 265: productv1.RequireStorageSecuritySummaryByIdResponse.result:type_name -> productv1.RequireStorageSecuritySummaryByIdResult + 433, // 266: productv1.RequireStorageSecuritySummaryByIdFields.security_setup:type_name -> productv1.RequireStorageSecuritySummaryByIdFields.SecuritySetup + 313, // 267: productv1.RequireStorageItemHandlerInfoByIdRequest.context:type_name -> productv1.RequireStorageItemHandlerInfoByIdContext + 26, // 268: productv1.RequireStorageItemHandlerInfoByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey + 316, // 269: productv1.RequireStorageItemHandlerInfoByIdContext.fields:type_name -> productv1.RequireStorageItemHandlerInfoByIdFields + 315, // 270: productv1.RequireStorageItemHandlerInfoByIdResponse.result:type_name -> productv1.RequireStorageItemHandlerInfoByIdResult + 439, // 271: productv1.RequireStorageItemHandlerInfoByIdFields.primary_item:type_name -> productv1.RequireStorageItemHandlerInfoByIdFields.StorageItem + 318, // 272: productv1.RequireStorageItemSpecsInfoByIdRequest.context:type_name -> productv1.RequireStorageItemSpecsInfoByIdContext + 26, // 273: productv1.RequireStorageItemSpecsInfoByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey + 321, // 274: productv1.RequireStorageItemSpecsInfoByIdContext.fields:type_name -> productv1.RequireStorageItemSpecsInfoByIdFields + 320, // 275: productv1.RequireStorageItemSpecsInfoByIdResponse.result:type_name -> productv1.RequireStorageItemSpecsInfoByIdResult + 444, // 276: productv1.RequireStorageItemSpecsInfoByIdFields.primary_item:type_name -> productv1.RequireStorageItemSpecsInfoByIdFields.StorageItem + 323, // 277: productv1.RequireStorageDeepItemInfoByIdRequest.context:type_name -> productv1.RequireStorageDeepItemInfoByIdContext + 26, // 278: productv1.RequireStorageDeepItemInfoByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey + 326, // 279: productv1.RequireStorageDeepItemInfoByIdContext.fields:type_name -> productv1.RequireStorageDeepItemInfoByIdFields + 325, // 280: productv1.RequireStorageDeepItemInfoByIdResponse.result:type_name -> productv1.RequireStorageDeepItemInfoByIdResult + 451, // 281: productv1.RequireStorageDeepItemInfoByIdFields.primary_item:type_name -> productv1.RequireStorageDeepItemInfoByIdFields.StorageItem + 328, // 282: productv1.RequireWarehouseStockHealthScoreByIdRequest.context:type_name -> productv1.RequireWarehouseStockHealthScoreByIdContext + 29, // 283: productv1.RequireWarehouseStockHealthScoreByIdContext.key:type_name -> productv1.LookupWarehouseByIdRequestKey + 331, // 284: productv1.RequireWarehouseStockHealthScoreByIdContext.fields:type_name -> productv1.RequireWarehouseStockHealthScoreByIdFields + 330, // 285: productv1.RequireWarehouseStockHealthScoreByIdResponse.result:type_name -> productv1.RequireWarehouseStockHealthScoreByIdResult + 457, // 286: productv1.RequireWarehouseStockHealthScoreByIdFields.restock_data:type_name -> productv1.RequireWarehouseStockHealthScoreByIdFields.RestockData + 366, // 287: productv1.NestedTypeA.b:type_name -> productv1.NestedTypeB + 337, // 288: productv1.RecursiveType.recursive_type:type_name -> productv1.RecursiveType + 368, // 289: productv1.ComplexFilterTypeInput.filter:type_name -> productv1.FilterType + 370, // 290: productv1.OrderInput.lines:type_name -> productv1.OrderLineInput + 16, // 291: productv1.Order.order_lines:type_name -> productv1.ListOfOrderLine + 0, // 292: productv1.Category.kind:type_name -> productv1.CategoryKind + 20, // 293: productv1.Category.subcategories:type_name -> productv1.ListOfSubcategory + 373, // 294: productv1.Category.null_metrics:type_name -> productv1.CategoryMetrics + 0, // 295: productv1.CategoryFilter.category:type_name -> productv1.CategoryKind + 369, // 296: productv1.CategoryFilter.pagination:type_name -> productv1.Pagination + 374, // 297: productv1.Animal.cat:type_name -> productv1.Cat + 375, // 298: productv1.Animal.dog:type_name -> productv1.Dog + 458, // 299: productv1.SearchInput.limit:type_name -> google.protobuf.Int32Value + 332, // 300: productv1.SearchResult.product:type_name -> productv1.Product + 335, // 301: productv1.SearchResult.user:type_name -> productv1.User + 344, // 302: productv1.SearchResult.category:type_name -> productv1.Category + 460, // 303: productv1.NullableFieldsType.optional_string:type_name -> google.protobuf.StringValue + 458, // 304: productv1.NullableFieldsType.optional_int:type_name -> google.protobuf.Int32Value + 461, // 305: productv1.NullableFieldsType.optional_float:type_name -> google.protobuf.DoubleValue + 459, // 306: productv1.NullableFieldsType.optional_boolean:type_name -> google.protobuf.BoolValue + 460, // 307: productv1.NullableFieldsFilter.name:type_name -> google.protobuf.StringValue + 460, // 308: productv1.NullableFieldsFilter.optional_string:type_name -> google.protobuf.StringValue + 459, // 309: productv1.NullableFieldsFilter.include_nulls:type_name -> google.protobuf.BoolValue + 19, // 310: productv1.BlogPost.optional_tags:type_name -> productv1.ListOfString + 19, // 311: productv1.BlogPost.keywords:type_name -> productv1.ListOfString + 10, // 312: productv1.BlogPost.ratings:type_name -> productv1.ListOfFloat + 7, // 313: productv1.BlogPost.is_published:type_name -> productv1.ListOfBoolean + 13, // 314: productv1.BlogPost.tag_groups:type_name -> productv1.ListOfListOfString + 13, // 315: productv1.BlogPost.related_topics:type_name -> productv1.ListOfListOfString + 13, // 316: productv1.BlogPost.comment_threads:type_name -> productv1.ListOfListOfString + 13, // 317: productv1.BlogPost.suggestions:type_name -> productv1.ListOfListOfString + 344, // 318: productv1.BlogPost.related_categories:type_name -> productv1.Category + 335, // 319: productv1.BlogPost.contributors:type_name -> productv1.User + 17, // 320: productv1.BlogPost.mentioned_products:type_name -> productv1.ListOfProduct + 21, // 321: productv1.BlogPost.mentioned_users:type_name -> productv1.ListOfUser + 11, // 322: productv1.BlogPost.category_groups:type_name -> productv1.ListOfListOfCategory + 14, // 323: productv1.BlogPost.contributor_teams:type_name -> productv1.ListOfListOfUser + 460, // 324: productv1.BlogPostFilter.title:type_name -> google.protobuf.StringValue + 459, // 325: productv1.BlogPostFilter.has_categories:type_name -> google.protobuf.BoolValue + 458, // 326: productv1.BlogPostFilter.min_tags:type_name -> google.protobuf.Int32Value + 460, // 327: productv1.Author.email:type_name -> google.protobuf.StringValue + 19, // 328: productv1.Author.social_links:type_name -> productv1.ListOfString + 13, // 329: productv1.Author.teams_by_project:type_name -> productv1.ListOfListOfString + 13, // 330: productv1.Author.collaborations:type_name -> productv1.ListOfListOfString + 4, // 331: productv1.Author.written_posts:type_name -> productv1.ListOfBlogPost + 344, // 332: productv1.Author.favorite_categories:type_name -> productv1.Category + 21, // 333: productv1.Author.related_authors:type_name -> productv1.ListOfUser + 17, // 334: productv1.Author.product_reviews:type_name -> productv1.ListOfProduct + 14, // 335: productv1.Author.author_groups:type_name -> productv1.ListOfListOfUser + 11, // 336: productv1.Author.category_preferences:type_name -> productv1.ListOfListOfCategory + 14, // 337: productv1.Author.project_teams:type_name -> productv1.ListOfListOfUser + 460, // 338: productv1.AuthorFilter.name:type_name -> google.protobuf.StringValue + 459, // 339: productv1.AuthorFilter.has_teams:type_name -> google.protobuf.BoolValue + 458, // 340: productv1.AuthorFilter.skill_count:type_name -> google.protobuf.Int32Value + 460, // 341: productv1.TestContainer.description:type_name -> google.protobuf.StringValue + 393, // 342: productv1.ActionResult.action_success:type_name -> productv1.ActionSuccess + 394, // 343: productv1.ActionResult.action_error:type_name -> productv1.ActionError + 460, // 344: productv1.NullableFieldsInput.optional_string:type_name -> google.protobuf.StringValue + 458, // 345: productv1.NullableFieldsInput.optional_int:type_name -> google.protobuf.Int32Value + 461, // 346: productv1.NullableFieldsInput.optional_float:type_name -> google.protobuf.DoubleValue + 459, // 347: productv1.NullableFieldsInput.optional_boolean:type_name -> google.protobuf.BoolValue + 19, // 348: productv1.BlogPostInput.optional_tags:type_name -> productv1.ListOfString + 19, // 349: productv1.BlogPostInput.keywords:type_name -> productv1.ListOfString + 10, // 350: productv1.BlogPostInput.ratings:type_name -> productv1.ListOfFloat + 7, // 351: productv1.BlogPostInput.is_published:type_name -> productv1.ListOfBoolean + 13, // 352: productv1.BlogPostInput.tag_groups:type_name -> productv1.ListOfListOfString + 13, // 353: productv1.BlogPostInput.related_topics:type_name -> productv1.ListOfListOfString + 13, // 354: productv1.BlogPostInput.comment_threads:type_name -> productv1.ListOfListOfString + 13, // 355: productv1.BlogPostInput.suggestions:type_name -> productv1.ListOfListOfString + 9, // 356: productv1.BlogPostInput.related_categories:type_name -> productv1.ListOfCategoryInput + 22, // 357: productv1.BlogPostInput.contributors:type_name -> productv1.ListOfUserInput + 12, // 358: productv1.BlogPostInput.category_groups:type_name -> productv1.ListOfListOfCategoryInput + 460, // 359: productv1.AuthorInput.email:type_name -> google.protobuf.StringValue + 19, // 360: productv1.AuthorInput.social_links:type_name -> productv1.ListOfString + 13, // 361: productv1.AuthorInput.teams_by_project:type_name -> productv1.ListOfListOfString + 13, // 362: productv1.AuthorInput.collaborations:type_name -> productv1.ListOfListOfString + 396, // 363: productv1.AuthorInput.favorite_categories:type_name -> productv1.CategoryInput + 15, // 364: productv1.AuthorInput.author_groups:type_name -> productv1.ListOfListOfUserInput + 15, // 365: productv1.AuthorInput.project_teams:type_name -> productv1.ListOfListOfUserInput + 358, // 366: productv1.ProductDetails.review_summary:type_name -> productv1.ActionResult + 346, // 367: productv1.ProductDetails.recommended_pet:type_name -> productv1.Animal + 0, // 368: productv1.StorageCategoryInfo.kind:type_name -> productv1.CategoryKind + 367, // 369: productv1.NestedTypeB.c:type_name -> productv1.NestedTypeC + 369, // 370: productv1.FilterType.pagination:type_name -> productv1.Pagination + 19, // 371: productv1.OrderLineInput.modifiers:type_name -> productv1.ListOfString + 19, // 372: productv1.OrderLine.modifiers:type_name -> productv1.ListOfString + 460, // 373: productv1.Subcategory.description:type_name -> google.protobuf.StringValue + 376, // 374: productv1.Cat.owner:type_name -> productv1.Owner + 379, // 375: productv1.Cat.breed:type_name -> productv1.CatBreed + 376, // 376: productv1.Dog.owner:type_name -> productv1.Owner + 380, // 377: productv1.Dog.breed:type_name -> productv1.DogBreed + 377, // 378: productv1.Owner.contact:type_name -> productv1.ContactInfo + 346, // 379: productv1.Owner.pet:type_name -> productv1.Animal + 378, // 380: productv1.ContactInfo.address:type_name -> productv1.Address + 381, // 381: productv1.CatBreed.characteristics:type_name -> productv1.BreedCharacteristics + 381, // 382: productv1.DogBreed.characteristics:type_name -> productv1.BreedCharacteristics + 383, // 383: productv1.StorageItem.pallet_item:type_name -> productv1.PalletItem + 384, // 384: productv1.StorageItem.container_item:type_name -> productv1.ContainerItem + 385, // 385: productv1.PalletItem.handler:type_name -> productv1.ItemHandler + 386, // 386: productv1.PalletItem.specs:type_name -> productv1.PalletSpecs + 385, // 387: productv1.ContainerItem.handler:type_name -> productv1.ItemHandler + 387, // 388: productv1.ContainerItem.specs:type_name -> productv1.ContainerSpecs + 382, // 389: productv1.ItemHandler.assigned_item:type_name -> productv1.StorageItem + 388, // 390: productv1.PalletSpecs.dimensions:type_name -> productv1.Dimensions + 388, // 391: productv1.ContainerSpecs.dimensions:type_name -> productv1.Dimensions + 390, // 392: productv1.StorageOperationResult.storage_success:type_name -> productv1.StorageSuccess + 391, // 393: productv1.StorageOperationResult.storage_failure:type_name -> productv1.StorageFailure + 382, // 394: productv1.SecuritySetup.primary_item:type_name -> productv1.StorageItem + 346, // 395: productv1.TestDetails.pet:type_name -> productv1.Animal + 358, // 396: productv1.TestDetails.status:type_name -> productv1.ActionResult + 0, // 397: productv1.CategoryInput.kind:type_name -> productv1.CategoryKind + 461, // 398: productv1.ProductCountFilter.min_price:type_name -> google.protobuf.DoubleValue + 461, // 399: productv1.ProductCountFilter.max_price:type_name -> google.protobuf.DoubleValue + 459, // 400: productv1.ProductCountFilter.in_stock:type_name -> google.protobuf.BoolValue + 460, // 401: productv1.ProductCountFilter.search_term:type_name -> google.protobuf.StringValue + 461, // 402: productv1.SubcategoryItemFilter.min_price:type_name -> google.protobuf.DoubleValue + 461, // 403: productv1.SubcategoryItemFilter.max_price:type_name -> google.protobuf.DoubleValue + 459, // 404: productv1.SubcategoryItemFilter.in_stock:type_name -> google.protobuf.BoolValue + 459, // 405: productv1.SubcategoryItemFilter.is_active:type_name -> google.protobuf.BoolValue + 460, // 406: productv1.SubcategoryItemFilter.search_term:type_name -> google.protobuf.StringValue + 1, // 407: productv1.ShippingEstimateInput.destination:type_name -> productv1.ShippingDestination + 459, // 408: productv1.ShippingEstimateInput.expedited:type_name -> google.protobuf.BoolValue + 354, // 409: productv1.ListOfAuthorFilter.List.items:type_name -> productv1.AuthorFilter + 361, // 410: productv1.ListOfAuthorInput.List.items:type_name -> productv1.AuthorInput + 351, // 411: productv1.ListOfBlogPost.List.items:type_name -> productv1.BlogPost + 352, // 412: productv1.ListOfBlogPostFilter.List.items:type_name -> productv1.BlogPostFilter + 360, // 413: productv1.ListOfBlogPostInput.List.items:type_name -> productv1.BlogPostInput + 344, // 414: productv1.ListOfCategory.List.items:type_name -> productv1.Category + 396, // 415: productv1.ListOfCategoryInput.List.items:type_name -> productv1.CategoryInput + 8, // 416: productv1.ListOfListOfCategory.List.items:type_name -> productv1.ListOfCategory + 9, // 417: productv1.ListOfListOfCategoryInput.List.items:type_name -> productv1.ListOfCategoryInput + 19, // 418: productv1.ListOfListOfString.List.items:type_name -> productv1.ListOfString + 21, // 419: productv1.ListOfListOfUser.List.items:type_name -> productv1.ListOfUser + 22, // 420: productv1.ListOfListOfUserInput.List.items:type_name -> productv1.ListOfUserInput + 371, // 421: productv1.ListOfOrderLine.List.items:type_name -> productv1.OrderLine + 332, // 422: productv1.ListOfProduct.List.items:type_name -> productv1.Product + 333, // 423: productv1.ListOfStorage.List.items:type_name -> productv1.Storage + 372, // 424: productv1.ListOfSubcategory.List.items:type_name -> productv1.Subcategory + 335, // 425: productv1.ListOfUser.List.items:type_name -> productv1.User + 356, // 426: productv1.ListOfUserInput.List.items:type_name -> productv1.UserInput + 0, // 427: productv1.RequireStorageCategoryInfoSummaryByIdFields.StorageCategoryInfo.kind:type_name -> productv1.CategoryKind + 428, // 428: productv1.RequireStorageItemInfoByIdFields.StorageItem.container_item:type_name -> productv1.RequireStorageItemInfoByIdFields.ContainerItem + 427, // 429: productv1.RequireStorageItemInfoByIdFields.StorageItem.pallet_item:type_name -> productv1.RequireStorageItemInfoByIdFields.PalletItem + 431, // 430: productv1.RequireStorageOperationReportByIdFields.StorageOperationResult.storage_failure:type_name -> productv1.RequireStorageOperationReportByIdFields.StorageFailure + 430, // 431: productv1.RequireStorageOperationReportByIdFields.StorageOperationResult.storage_success:type_name -> productv1.RequireStorageOperationReportByIdFields.StorageSuccess + 436, // 432: productv1.RequireStorageSecuritySummaryByIdFields.SecuritySetup.primary_item:type_name -> productv1.RequireStorageSecuritySummaryByIdFields.SecuritySetup.StorageItem + 435, // 433: productv1.RequireStorageSecuritySummaryByIdFields.SecuritySetup.StorageItem.container_item:type_name -> productv1.RequireStorageSecuritySummaryByIdFields.SecuritySetup.ContainerItem + 434, // 434: productv1.RequireStorageSecuritySummaryByIdFields.SecuritySetup.StorageItem.pallet_item:type_name -> productv1.RequireStorageSecuritySummaryByIdFields.SecuritySetup.PalletItem + 440, // 435: productv1.RequireStorageItemHandlerInfoByIdFields.PalletItem.handler:type_name -> productv1.RequireStorageItemHandlerInfoByIdFields.PalletItem.ItemHandler + 441, // 436: productv1.RequireStorageItemHandlerInfoByIdFields.ContainerItem.handler:type_name -> productv1.RequireStorageItemHandlerInfoByIdFields.ContainerItem.ItemHandler + 438, // 437: productv1.RequireStorageItemHandlerInfoByIdFields.StorageItem.container_item:type_name -> productv1.RequireStorageItemHandlerInfoByIdFields.ContainerItem + 437, // 438: productv1.RequireStorageItemHandlerInfoByIdFields.StorageItem.pallet_item:type_name -> productv1.RequireStorageItemHandlerInfoByIdFields.PalletItem + 445, // 439: productv1.RequireStorageItemSpecsInfoByIdFields.PalletItem.specs:type_name -> productv1.RequireStorageItemSpecsInfoByIdFields.PalletItem.PalletSpecs + 447, // 440: productv1.RequireStorageItemSpecsInfoByIdFields.ContainerItem.specs:type_name -> productv1.RequireStorageItemSpecsInfoByIdFields.ContainerItem.ContainerSpecs + 443, // 441: productv1.RequireStorageItemSpecsInfoByIdFields.StorageItem.container_item:type_name -> productv1.RequireStorageItemSpecsInfoByIdFields.ContainerItem + 442, // 442: productv1.RequireStorageItemSpecsInfoByIdFields.StorageItem.pallet_item:type_name -> productv1.RequireStorageItemSpecsInfoByIdFields.PalletItem + 446, // 443: productv1.RequireStorageItemSpecsInfoByIdFields.PalletItem.PalletSpecs.dimensions:type_name -> productv1.RequireStorageItemSpecsInfoByIdFields.PalletItem.PalletSpecs.Dimensions + 448, // 444: productv1.RequireStorageItemSpecsInfoByIdFields.ContainerItem.ContainerSpecs.dimensions:type_name -> productv1.RequireStorageItemSpecsInfoByIdFields.ContainerItem.ContainerSpecs.Dimensions + 452, // 445: productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.handler:type_name -> productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.ItemHandler + 456, // 446: productv1.RequireStorageDeepItemInfoByIdFields.ContainerItem.handler:type_name -> productv1.RequireStorageDeepItemInfoByIdFields.ContainerItem.ItemHandler + 450, // 447: productv1.RequireStorageDeepItemInfoByIdFields.StorageItem.container_item:type_name -> productv1.RequireStorageDeepItemInfoByIdFields.ContainerItem + 449, // 448: productv1.RequireStorageDeepItemInfoByIdFields.StorageItem.pallet_item:type_name -> productv1.RequireStorageDeepItemInfoByIdFields.PalletItem + 455, // 449: productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.ItemHandler.assigned_item:type_name -> productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.ItemHandler.StorageItem + 453, // 450: productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.ItemHandler.StorageItem.container_item:type_name -> productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.ItemHandler.ContainerItem + 454, // 451: productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.ItemHandler.StorageItem.pallet_item:type_name -> productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.ItemHandler.PalletItem + 24, // 452: productv1.ProductService.LookupProductById:input_type -> productv1.LookupProductByIdRequest + 27, // 453: productv1.ProductService.LookupStorageById:input_type -> productv1.LookupStorageByIdRequest + 30, // 454: productv1.ProductService.LookupWarehouseById:input_type -> productv1.LookupWarehouseByIdRequest + 114, // 455: productv1.ProductService.MutationBulkCreateAuthors:input_type -> productv1.MutationBulkCreateAuthorsRequest + 118, // 456: productv1.ProductService.MutationBulkCreateBlogPosts:input_type -> productv1.MutationBulkCreateBlogPostsRequest + 116, // 457: productv1.ProductService.MutationBulkUpdateAuthors:input_type -> productv1.MutationBulkUpdateAuthorsRequest + 120, // 458: productv1.ProductService.MutationBulkUpdateBlogPosts:input_type -> productv1.MutationBulkUpdateBlogPostsRequest + 110, // 459: productv1.ProductService.MutationCreateAuthor:input_type -> productv1.MutationCreateAuthorRequest + 106, // 460: productv1.ProductService.MutationCreateBlogPost:input_type -> productv1.MutationCreateBlogPostRequest + 102, // 461: productv1.ProductService.MutationCreateNullableFieldsType:input_type -> productv1.MutationCreateNullableFieldsTypeRequest + 98, // 462: productv1.ProductService.MutationCreateUser:input_type -> productv1.MutationCreateUserRequest + 100, // 463: productv1.ProductService.MutationPerformAction:input_type -> productv1.MutationPerformActionRequest + 112, // 464: productv1.ProductService.MutationUpdateAuthor:input_type -> productv1.MutationUpdateAuthorRequest + 108, // 465: productv1.ProductService.MutationUpdateBlogPost:input_type -> productv1.MutationUpdateBlogPostRequest + 104, // 466: productv1.ProductService.MutationUpdateNullableFieldsType:input_type -> productv1.MutationUpdateNullableFieldsTypeRequest + 88, // 467: productv1.ProductService.QueryAllAuthors:input_type -> productv1.QueryAllAuthorsRequest + 80, // 468: productv1.ProductService.QueryAllBlogPosts:input_type -> productv1.QueryAllBlogPostsRequest + 72, // 469: productv1.ProductService.QueryAllNullableFieldsTypes:input_type -> productv1.QueryAllNullableFieldsTypesRequest + 60, // 470: productv1.ProductService.QueryAllPets:input_type -> productv1.QueryAllPetsRequest + 82, // 471: productv1.ProductService.QueryAuthor:input_type -> productv1.QueryAuthorRequest + 84, // 472: productv1.ProductService.QueryAuthorById:input_type -> productv1.QueryAuthorByIdRequest + 86, // 473: productv1.ProductService.QueryAuthorsWithFilter:input_type -> productv1.QueryAuthorsWithFilterRequest + 74, // 474: productv1.ProductService.QueryBlogPost:input_type -> productv1.QueryBlogPostRequest + 76, // 475: productv1.ProductService.QueryBlogPostById:input_type -> productv1.QueryBlogPostByIdRequest + 78, // 476: productv1.ProductService.QueryBlogPostsWithFilter:input_type -> productv1.QueryBlogPostsWithFilterRequest + 90, // 477: productv1.ProductService.QueryBulkSearchAuthors:input_type -> productv1.QueryBulkSearchAuthorsRequest + 92, // 478: productv1.ProductService.QueryBulkSearchBlogPosts:input_type -> productv1.QueryBulkSearchBlogPostsRequest + 46, // 479: productv1.ProductService.QueryCalculateTotals:input_type -> productv1.QueryCalculateTotalsRequest + 48, // 480: productv1.ProductService.QueryCategories:input_type -> productv1.QueryCategoriesRequest + 52, // 481: productv1.ProductService.QueryCategoriesByKind:input_type -> productv1.QueryCategoriesByKindRequest + 54, // 482: productv1.ProductService.QueryCategoriesByKinds:input_type -> productv1.QueryCategoriesByKindsRequest + 50, // 483: productv1.ProductService.QueryCategory:input_type -> productv1.QueryCategoryRequest + 44, // 484: productv1.ProductService.QueryComplexFilterType:input_type -> productv1.QueryComplexFilterTypeRequest + 56, // 485: productv1.ProductService.QueryFilterCategories:input_type -> productv1.QueryFilterCategoriesRequest + 36, // 486: productv1.ProductService.QueryNestedType:input_type -> productv1.QueryNestedTypeRequest + 66, // 487: productv1.ProductService.QueryNullableFieldsType:input_type -> productv1.QueryNullableFieldsTypeRequest + 68, // 488: productv1.ProductService.QueryNullableFieldsTypeById:input_type -> productv1.QueryNullableFieldsTypeByIdRequest + 70, // 489: productv1.ProductService.QueryNullableFieldsTypeWithFilter:input_type -> productv1.QueryNullableFieldsTypeWithFilterRequest + 58, // 490: productv1.ProductService.QueryRandomPet:input_type -> productv1.QueryRandomPetRequest + 64, // 491: productv1.ProductService.QueryRandomSearchResult:input_type -> productv1.QueryRandomSearchResultRequest + 38, // 492: productv1.ProductService.QueryRecursiveType:input_type -> productv1.QueryRecursiveTypeRequest + 62, // 493: productv1.ProductService.QuerySearch:input_type -> productv1.QuerySearchRequest + 94, // 494: productv1.ProductService.QueryTestContainer:input_type -> productv1.QueryTestContainerRequest + 96, // 495: productv1.ProductService.QueryTestContainers:input_type -> productv1.QueryTestContainersRequest + 40, // 496: productv1.ProductService.QueryTypeFilterWithArguments:input_type -> productv1.QueryTypeFilterWithArgumentsRequest + 42, // 497: productv1.ProductService.QueryTypeWithMultipleFilterFields:input_type -> productv1.QueryTypeWithMultipleFilterFieldsRequest + 34, // 498: productv1.ProductService.QueryUser:input_type -> productv1.QueryUserRequest + 32, // 499: productv1.ProductService.QueryUsers:input_type -> productv1.QueryUsersRequest + 292, // 500: productv1.ProductService.RequireStorageCategoryInfoSummaryById:input_type -> productv1.RequireStorageCategoryInfoSummaryByIdRequest + 322, // 501: productv1.ProductService.RequireStorageDeepItemInfoById:input_type -> productv1.RequireStorageDeepItemInfoByIdRequest + 312, // 502: productv1.ProductService.RequireStorageItemHandlerInfoById:input_type -> productv1.RequireStorageItemHandlerInfoByIdRequest + 297, // 503: productv1.ProductService.RequireStorageItemInfoById:input_type -> productv1.RequireStorageItemInfoByIdRequest + 317, // 504: productv1.ProductService.RequireStorageItemSpecsInfoById:input_type -> productv1.RequireStorageItemSpecsInfoByIdRequest + 287, // 505: productv1.ProductService.RequireStorageKindSummaryById:input_type -> productv1.RequireStorageKindSummaryByIdRequest + 257, // 506: productv1.ProductService.RequireStorageMetadataScoreById:input_type -> productv1.RequireStorageMetadataScoreByIdRequest + 302, // 507: productv1.ProductService.RequireStorageOperationReportById:input_type -> productv1.RequireStorageOperationReportByIdRequest + 267, // 508: productv1.ProductService.RequireStorageOptionalProcessedMetadataById:input_type -> productv1.RequireStorageOptionalProcessedMetadataByIdRequest + 277, // 509: productv1.ProductService.RequireStorageOptionalProcessedTagsById:input_type -> productv1.RequireStorageOptionalProcessedTagsByIdRequest + 252, // 510: productv1.ProductService.RequireStorageOptionalTagSummaryById:input_type -> productv1.RequireStorageOptionalTagSummaryByIdRequest + 262, // 511: productv1.ProductService.RequireStorageProcessedMetadataById:input_type -> productv1.RequireStorageProcessedMetadataByIdRequest + 282, // 512: productv1.ProductService.RequireStorageProcessedMetadataHistoryById:input_type -> productv1.RequireStorageProcessedMetadataHistoryByIdRequest + 272, // 513: productv1.ProductService.RequireStorageProcessedTagsById:input_type -> productv1.RequireStorageProcessedTagsByIdRequest + 307, // 514: productv1.ProductService.RequireStorageSecuritySummaryById:input_type -> productv1.RequireStorageSecuritySummaryByIdRequest + 242, // 515: productv1.ProductService.RequireStorageStockHealthScoreById:input_type -> productv1.RequireStorageStockHealthScoreByIdRequest + 247, // 516: productv1.ProductService.RequireStorageTagSummaryById:input_type -> productv1.RequireStorageTagSummaryByIdRequest + 327, // 517: productv1.ProductService.RequireWarehouseStockHealthScoreById:input_type -> productv1.RequireWarehouseStockHealthScoreByIdRequest + 206, // 518: productv1.ProductService.ResolveCategoryActiveSubcategories:input_type -> productv1.ResolveCategoryActiveSubcategoriesRequest + 174, // 519: productv1.ProductService.ResolveCategoryCategoryMetrics:input_type -> productv1.ResolveCategoryCategoryMetricsRequest + 184, // 520: productv1.ProductService.ResolveCategoryCategoryStatus:input_type -> productv1.ResolveCategoryCategoryStatusRequest + 189, // 521: productv1.ProductService.ResolveCategoryChildCategories:input_type -> productv1.ResolveCategoryChildCategoriesRequest + 179, // 522: productv1.ProductService.ResolveCategoryMascot:input_type -> productv1.ResolveCategoryMascotRequest + 234, // 523: productv1.ProductService.ResolveCategoryMetricsAverageScore:input_type -> productv1.ResolveCategoryMetricsAverageScoreRequest + 225, // 524: productv1.ProductService.ResolveCategoryMetricsNormalizedScore:input_type -> productv1.ResolveCategoryMetricsNormalizedScoreRequest + 230, // 525: productv1.ProductService.ResolveCategoryMetricsRelatedCategory:input_type -> productv1.ResolveCategoryMetricsRelatedCategoryRequest + 194, // 526: productv1.ProductService.ResolveCategoryOptionalCategories:input_type -> productv1.ResolveCategoryOptionalCategoriesRequest + 169, // 527: productv1.ProductService.ResolveCategoryPopularityScore:input_type -> productv1.ResolveCategoryPopularityScoreRequest + 164, // 528: productv1.ProductService.ResolveCategoryProductCount:input_type -> productv1.ResolveCategoryProductCountRequest + 202, // 529: productv1.ProductService.ResolveCategoryTopSubcategory:input_type -> productv1.ResolveCategoryTopSubcategoryRequest + 198, // 530: productv1.ProductService.ResolveCategoryTotalProducts:input_type -> productv1.ResolveCategoryTotalProductsRequest + 134, // 531: productv1.ProductService.ResolveProductMascotRecommendation:input_type -> productv1.ResolveProductMascotRecommendationRequest + 144, // 532: productv1.ProductService.ResolveProductProductDetails:input_type -> productv1.ResolveProductProductDetailsRequest + 129, // 533: productv1.ProductService.ResolveProductRecommendedCategory:input_type -> productv1.ResolveProductRecommendedCategoryRequest + 124, // 534: productv1.ProductService.ResolveProductShippingEstimate:input_type -> productv1.ResolveProductShippingEstimateRequest + 139, // 535: productv1.ProductService.ResolveProductStockStatus:input_type -> productv1.ResolveProductStockStatusRequest + 154, // 536: productv1.ProductService.ResolveStorageLinkedStorages:input_type -> productv1.ResolveStorageLinkedStoragesRequest + 159, // 537: productv1.ProductService.ResolveStorageNearbyStorages:input_type -> productv1.ResolveStorageNearbyStoragesRequest + 149, // 538: productv1.ProductService.ResolveStorageStorageStatus:input_type -> productv1.ResolveStorageStorageStatusRequest + 216, // 539: productv1.ProductService.ResolveSubcategoryFeaturedCategory:input_type -> productv1.ResolveSubcategoryFeaturedCategoryRequest + 211, // 540: productv1.ProductService.ResolveSubcategoryItemCount:input_type -> productv1.ResolveSubcategoryItemCountRequest + 220, // 541: productv1.ProductService.ResolveSubcategoryParentCategory:input_type -> productv1.ResolveSubcategoryParentCategoryRequest + 239, // 542: productv1.ProductService.ResolveTestContainerDetails:input_type -> productv1.ResolveTestContainerDetailsRequest + 25, // 543: productv1.ProductService.LookupProductById:output_type -> productv1.LookupProductByIdResponse + 28, // 544: productv1.ProductService.LookupStorageById:output_type -> productv1.LookupStorageByIdResponse + 31, // 545: productv1.ProductService.LookupWarehouseById:output_type -> productv1.LookupWarehouseByIdResponse + 115, // 546: productv1.ProductService.MutationBulkCreateAuthors:output_type -> productv1.MutationBulkCreateAuthorsResponse + 119, // 547: productv1.ProductService.MutationBulkCreateBlogPosts:output_type -> productv1.MutationBulkCreateBlogPostsResponse + 117, // 548: productv1.ProductService.MutationBulkUpdateAuthors:output_type -> productv1.MutationBulkUpdateAuthorsResponse + 121, // 549: productv1.ProductService.MutationBulkUpdateBlogPosts:output_type -> productv1.MutationBulkUpdateBlogPostsResponse + 111, // 550: productv1.ProductService.MutationCreateAuthor:output_type -> productv1.MutationCreateAuthorResponse + 107, // 551: productv1.ProductService.MutationCreateBlogPost:output_type -> productv1.MutationCreateBlogPostResponse + 103, // 552: productv1.ProductService.MutationCreateNullableFieldsType:output_type -> productv1.MutationCreateNullableFieldsTypeResponse + 99, // 553: productv1.ProductService.MutationCreateUser:output_type -> productv1.MutationCreateUserResponse + 101, // 554: productv1.ProductService.MutationPerformAction:output_type -> productv1.MutationPerformActionResponse + 113, // 555: productv1.ProductService.MutationUpdateAuthor:output_type -> productv1.MutationUpdateAuthorResponse + 109, // 556: productv1.ProductService.MutationUpdateBlogPost:output_type -> productv1.MutationUpdateBlogPostResponse + 105, // 557: productv1.ProductService.MutationUpdateNullableFieldsType:output_type -> productv1.MutationUpdateNullableFieldsTypeResponse + 89, // 558: productv1.ProductService.QueryAllAuthors:output_type -> productv1.QueryAllAuthorsResponse + 81, // 559: productv1.ProductService.QueryAllBlogPosts:output_type -> productv1.QueryAllBlogPostsResponse + 73, // 560: productv1.ProductService.QueryAllNullableFieldsTypes:output_type -> productv1.QueryAllNullableFieldsTypesResponse + 61, // 561: productv1.ProductService.QueryAllPets:output_type -> productv1.QueryAllPetsResponse + 83, // 562: productv1.ProductService.QueryAuthor:output_type -> productv1.QueryAuthorResponse + 85, // 563: productv1.ProductService.QueryAuthorById:output_type -> productv1.QueryAuthorByIdResponse + 87, // 564: productv1.ProductService.QueryAuthorsWithFilter:output_type -> productv1.QueryAuthorsWithFilterResponse + 75, // 565: productv1.ProductService.QueryBlogPost:output_type -> productv1.QueryBlogPostResponse + 77, // 566: productv1.ProductService.QueryBlogPostById:output_type -> productv1.QueryBlogPostByIdResponse + 79, // 567: productv1.ProductService.QueryBlogPostsWithFilter:output_type -> productv1.QueryBlogPostsWithFilterResponse + 91, // 568: productv1.ProductService.QueryBulkSearchAuthors:output_type -> productv1.QueryBulkSearchAuthorsResponse + 93, // 569: productv1.ProductService.QueryBulkSearchBlogPosts:output_type -> productv1.QueryBulkSearchBlogPostsResponse + 47, // 570: productv1.ProductService.QueryCalculateTotals:output_type -> productv1.QueryCalculateTotalsResponse + 49, // 571: productv1.ProductService.QueryCategories:output_type -> productv1.QueryCategoriesResponse + 53, // 572: productv1.ProductService.QueryCategoriesByKind:output_type -> productv1.QueryCategoriesByKindResponse + 55, // 573: productv1.ProductService.QueryCategoriesByKinds:output_type -> productv1.QueryCategoriesByKindsResponse + 51, // 574: productv1.ProductService.QueryCategory:output_type -> productv1.QueryCategoryResponse + 45, // 575: productv1.ProductService.QueryComplexFilterType:output_type -> productv1.QueryComplexFilterTypeResponse + 57, // 576: productv1.ProductService.QueryFilterCategories:output_type -> productv1.QueryFilterCategoriesResponse + 37, // 577: productv1.ProductService.QueryNestedType:output_type -> productv1.QueryNestedTypeResponse + 67, // 578: productv1.ProductService.QueryNullableFieldsType:output_type -> productv1.QueryNullableFieldsTypeResponse + 69, // 579: productv1.ProductService.QueryNullableFieldsTypeById:output_type -> productv1.QueryNullableFieldsTypeByIdResponse + 71, // 580: productv1.ProductService.QueryNullableFieldsTypeWithFilter:output_type -> productv1.QueryNullableFieldsTypeWithFilterResponse + 59, // 581: productv1.ProductService.QueryRandomPet:output_type -> productv1.QueryRandomPetResponse + 65, // 582: productv1.ProductService.QueryRandomSearchResult:output_type -> productv1.QueryRandomSearchResultResponse + 39, // 583: productv1.ProductService.QueryRecursiveType:output_type -> productv1.QueryRecursiveTypeResponse + 63, // 584: productv1.ProductService.QuerySearch:output_type -> productv1.QuerySearchResponse + 95, // 585: productv1.ProductService.QueryTestContainer:output_type -> productv1.QueryTestContainerResponse + 97, // 586: productv1.ProductService.QueryTestContainers:output_type -> productv1.QueryTestContainersResponse + 41, // 587: productv1.ProductService.QueryTypeFilterWithArguments:output_type -> productv1.QueryTypeFilterWithArgumentsResponse + 43, // 588: productv1.ProductService.QueryTypeWithMultipleFilterFields:output_type -> productv1.QueryTypeWithMultipleFilterFieldsResponse + 35, // 589: productv1.ProductService.QueryUser:output_type -> productv1.QueryUserResponse + 33, // 590: productv1.ProductService.QueryUsers:output_type -> productv1.QueryUsersResponse + 294, // 591: productv1.ProductService.RequireStorageCategoryInfoSummaryById:output_type -> productv1.RequireStorageCategoryInfoSummaryByIdResponse + 324, // 592: productv1.ProductService.RequireStorageDeepItemInfoById:output_type -> productv1.RequireStorageDeepItemInfoByIdResponse + 314, // 593: productv1.ProductService.RequireStorageItemHandlerInfoById:output_type -> productv1.RequireStorageItemHandlerInfoByIdResponse + 299, // 594: productv1.ProductService.RequireStorageItemInfoById:output_type -> productv1.RequireStorageItemInfoByIdResponse + 319, // 595: productv1.ProductService.RequireStorageItemSpecsInfoById:output_type -> productv1.RequireStorageItemSpecsInfoByIdResponse + 289, // 596: productv1.ProductService.RequireStorageKindSummaryById:output_type -> productv1.RequireStorageKindSummaryByIdResponse + 259, // 597: productv1.ProductService.RequireStorageMetadataScoreById:output_type -> productv1.RequireStorageMetadataScoreByIdResponse + 304, // 598: productv1.ProductService.RequireStorageOperationReportById:output_type -> productv1.RequireStorageOperationReportByIdResponse + 269, // 599: productv1.ProductService.RequireStorageOptionalProcessedMetadataById:output_type -> productv1.RequireStorageOptionalProcessedMetadataByIdResponse + 279, // 600: productv1.ProductService.RequireStorageOptionalProcessedTagsById:output_type -> productv1.RequireStorageOptionalProcessedTagsByIdResponse + 254, // 601: productv1.ProductService.RequireStorageOptionalTagSummaryById:output_type -> productv1.RequireStorageOptionalTagSummaryByIdResponse + 264, // 602: productv1.ProductService.RequireStorageProcessedMetadataById:output_type -> productv1.RequireStorageProcessedMetadataByIdResponse + 284, // 603: productv1.ProductService.RequireStorageProcessedMetadataHistoryById:output_type -> productv1.RequireStorageProcessedMetadataHistoryByIdResponse + 274, // 604: productv1.ProductService.RequireStorageProcessedTagsById:output_type -> productv1.RequireStorageProcessedTagsByIdResponse + 309, // 605: productv1.ProductService.RequireStorageSecuritySummaryById:output_type -> productv1.RequireStorageSecuritySummaryByIdResponse + 244, // 606: productv1.ProductService.RequireStorageStockHealthScoreById:output_type -> productv1.RequireStorageStockHealthScoreByIdResponse + 249, // 607: productv1.ProductService.RequireStorageTagSummaryById:output_type -> productv1.RequireStorageTagSummaryByIdResponse + 329, // 608: productv1.ProductService.RequireWarehouseStockHealthScoreById:output_type -> productv1.RequireWarehouseStockHealthScoreByIdResponse + 208, // 609: productv1.ProductService.ResolveCategoryActiveSubcategories:output_type -> productv1.ResolveCategoryActiveSubcategoriesResponse + 176, // 610: productv1.ProductService.ResolveCategoryCategoryMetrics:output_type -> productv1.ResolveCategoryCategoryMetricsResponse + 186, // 611: productv1.ProductService.ResolveCategoryCategoryStatus:output_type -> productv1.ResolveCategoryCategoryStatusResponse + 191, // 612: productv1.ProductService.ResolveCategoryChildCategories:output_type -> productv1.ResolveCategoryChildCategoriesResponse + 181, // 613: productv1.ProductService.ResolveCategoryMascot:output_type -> productv1.ResolveCategoryMascotResponse + 236, // 614: productv1.ProductService.ResolveCategoryMetricsAverageScore:output_type -> productv1.ResolveCategoryMetricsAverageScoreResponse + 227, // 615: productv1.ProductService.ResolveCategoryMetricsNormalizedScore:output_type -> productv1.ResolveCategoryMetricsNormalizedScoreResponse + 232, // 616: productv1.ProductService.ResolveCategoryMetricsRelatedCategory:output_type -> productv1.ResolveCategoryMetricsRelatedCategoryResponse + 196, // 617: productv1.ProductService.ResolveCategoryOptionalCategories:output_type -> productv1.ResolveCategoryOptionalCategoriesResponse + 171, // 618: productv1.ProductService.ResolveCategoryPopularityScore:output_type -> productv1.ResolveCategoryPopularityScoreResponse + 166, // 619: productv1.ProductService.ResolveCategoryProductCount:output_type -> productv1.ResolveCategoryProductCountResponse + 204, // 620: productv1.ProductService.ResolveCategoryTopSubcategory:output_type -> productv1.ResolveCategoryTopSubcategoryResponse + 200, // 621: productv1.ProductService.ResolveCategoryTotalProducts:output_type -> productv1.ResolveCategoryTotalProductsResponse + 136, // 622: productv1.ProductService.ResolveProductMascotRecommendation:output_type -> productv1.ResolveProductMascotRecommendationResponse + 146, // 623: productv1.ProductService.ResolveProductProductDetails:output_type -> productv1.ResolveProductProductDetailsResponse + 131, // 624: productv1.ProductService.ResolveProductRecommendedCategory:output_type -> productv1.ResolveProductRecommendedCategoryResponse + 126, // 625: productv1.ProductService.ResolveProductShippingEstimate:output_type -> productv1.ResolveProductShippingEstimateResponse + 141, // 626: productv1.ProductService.ResolveProductStockStatus:output_type -> productv1.ResolveProductStockStatusResponse + 156, // 627: productv1.ProductService.ResolveStorageLinkedStorages:output_type -> productv1.ResolveStorageLinkedStoragesResponse + 161, // 628: productv1.ProductService.ResolveStorageNearbyStorages:output_type -> productv1.ResolveStorageNearbyStoragesResponse + 151, // 629: productv1.ProductService.ResolveStorageStorageStatus:output_type -> productv1.ResolveStorageStorageStatusResponse + 218, // 630: productv1.ProductService.ResolveSubcategoryFeaturedCategory:output_type -> productv1.ResolveSubcategoryFeaturedCategoryResponse + 213, // 631: productv1.ProductService.ResolveSubcategoryItemCount:output_type -> productv1.ResolveSubcategoryItemCountResponse + 222, // 632: productv1.ProductService.ResolveSubcategoryParentCategory:output_type -> productv1.ResolveSubcategoryParentCategoryResponse + 241, // 633: productv1.ProductService.ResolveTestContainerDetails:output_type -> productv1.ResolveTestContainerDetailsResponse + 543, // [543:634] is the sub-list for method output_type + 452, // [452:543] is the sub-list for method input_type + 452, // [452:452] is the sub-list for extension type_name + 452, // [452:452] is the sub-list for extension extendee + 0, // [0:452] is the sub-list for field type_name } func init() { file_product_proto_init() } @@ -21377,26 +25580,62 @@ func file_product_proto_init() { if File_product_proto != nil { return } - file_product_proto_msgTypes[314].OneofWrappers = []any{ + file_product_proto_msgTypes[344].OneofWrappers = []any{ (*Animal_Cat)(nil), (*Animal_Dog)(nil), } - file_product_proto_msgTypes[316].OneofWrappers = []any{ + file_product_proto_msgTypes[346].OneofWrappers = []any{ (*SearchResult_Product)(nil), (*SearchResult_User)(nil), (*SearchResult_Category)(nil), } - file_product_proto_msgTypes[326].OneofWrappers = []any{ + file_product_proto_msgTypes[356].OneofWrappers = []any{ (*ActionResult_ActionSuccess)(nil), (*ActionResult_ActionError)(nil), } + file_product_proto_msgTypes[380].OneofWrappers = []any{ + (*StorageItem_PalletItem)(nil), + (*StorageItem_ContainerItem)(nil), + } + file_product_proto_msgTypes[387].OneofWrappers = []any{ + (*StorageOperationResult_StorageSuccess)(nil), + (*StorageOperationResult_StorageFailure)(nil), + } + file_product_proto_msgTypes[427].OneofWrappers = []any{ + (*RequireStorageItemInfoByIdFields_StorageItem_ContainerItem)(nil), + (*RequireStorageItemInfoByIdFields_StorageItem_PalletItem)(nil), + } + file_product_proto_msgTypes[430].OneofWrappers = []any{ + (*RequireStorageOperationReportByIdFields_StorageOperationResult_StorageFailure)(nil), + (*RequireStorageOperationReportByIdFields_StorageOperationResult_StorageSuccess)(nil), + } + file_product_proto_msgTypes[434].OneofWrappers = []any{ + (*RequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem_ContainerItem)(nil), + (*RequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem_PalletItem)(nil), + } + file_product_proto_msgTypes[437].OneofWrappers = []any{ + (*RequireStorageItemHandlerInfoByIdFields_StorageItem_ContainerItem)(nil), + (*RequireStorageItemHandlerInfoByIdFields_StorageItem_PalletItem)(nil), + } + file_product_proto_msgTypes[442].OneofWrappers = []any{ + (*RequireStorageItemSpecsInfoByIdFields_StorageItem_ContainerItem)(nil), + (*RequireStorageItemSpecsInfoByIdFields_StorageItem_PalletItem)(nil), + } + file_product_proto_msgTypes[449].OneofWrappers = []any{ + (*RequireStorageDeepItemInfoByIdFields_StorageItem_ContainerItem)(nil), + (*RequireStorageDeepItemInfoByIdFields_StorageItem_PalletItem)(nil), + } + file_product_proto_msgTypes[453].OneofWrappers = []any{ + (*RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem_ContainerItem)(nil), + (*RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem_PalletItem)(nil), + } type x struct{} out := protoimpl.TypeBuilder{ File: protoimpl.DescBuilder{ GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: unsafe.Slice(unsafe.StringData(file_product_proto_rawDesc), len(file_product_proto_rawDesc)), NumEnums: 2, - NumMessages: 385, + NumMessages: 456, NumExtensions: 0, NumServices: 1, }, diff --git a/v2/pkg/grpctest/productv1/product_grpc.pb.go b/v2/pkg/grpctest/productv1/product_grpc.pb.go index 2d827aae86..4d9f069571 100644 --- a/v2/pkg/grpctest/productv1/product_grpc.pb.go +++ b/v2/pkg/grpctest/productv1/product_grpc.pb.go @@ -68,14 +68,20 @@ const ( ProductService_QueryUser_FullMethodName = "/productv1.ProductService/QueryUser" ProductService_QueryUsers_FullMethodName = "/productv1.ProductService/QueryUsers" ProductService_RequireStorageCategoryInfoSummaryById_FullMethodName = "/productv1.ProductService/RequireStorageCategoryInfoSummaryById" + ProductService_RequireStorageDeepItemInfoById_FullMethodName = "/productv1.ProductService/RequireStorageDeepItemInfoById" + ProductService_RequireStorageItemHandlerInfoById_FullMethodName = "/productv1.ProductService/RequireStorageItemHandlerInfoById" + ProductService_RequireStorageItemInfoById_FullMethodName = "/productv1.ProductService/RequireStorageItemInfoById" + ProductService_RequireStorageItemSpecsInfoById_FullMethodName = "/productv1.ProductService/RequireStorageItemSpecsInfoById" ProductService_RequireStorageKindSummaryById_FullMethodName = "/productv1.ProductService/RequireStorageKindSummaryById" ProductService_RequireStorageMetadataScoreById_FullMethodName = "/productv1.ProductService/RequireStorageMetadataScoreById" + ProductService_RequireStorageOperationReportById_FullMethodName = "/productv1.ProductService/RequireStorageOperationReportById" ProductService_RequireStorageOptionalProcessedMetadataById_FullMethodName = "/productv1.ProductService/RequireStorageOptionalProcessedMetadataById" ProductService_RequireStorageOptionalProcessedTagsById_FullMethodName = "/productv1.ProductService/RequireStorageOptionalProcessedTagsById" ProductService_RequireStorageOptionalTagSummaryById_FullMethodName = "/productv1.ProductService/RequireStorageOptionalTagSummaryById" ProductService_RequireStorageProcessedMetadataById_FullMethodName = "/productv1.ProductService/RequireStorageProcessedMetadataById" ProductService_RequireStorageProcessedMetadataHistoryById_FullMethodName = "/productv1.ProductService/RequireStorageProcessedMetadataHistoryById" ProductService_RequireStorageProcessedTagsById_FullMethodName = "/productv1.ProductService/RequireStorageProcessedTagsById" + ProductService_RequireStorageSecuritySummaryById_FullMethodName = "/productv1.ProductService/RequireStorageSecuritySummaryById" ProductService_RequireStorageStockHealthScoreById_FullMethodName = "/productv1.ProductService/RequireStorageStockHealthScoreById" ProductService_RequireStorageTagSummaryById_FullMethodName = "/productv1.ProductService/RequireStorageTagSummaryById" ProductService_RequireWarehouseStockHealthScoreById_FullMethodName = "/productv1.ProductService/RequireWarehouseStockHealthScoreById" @@ -164,14 +170,20 @@ type ProductServiceClient interface { QueryUser(ctx context.Context, in *QueryUserRequest, opts ...grpc.CallOption) (*QueryUserResponse, error) QueryUsers(ctx context.Context, in *QueryUsersRequest, opts ...grpc.CallOption) (*QueryUsersResponse, error) RequireStorageCategoryInfoSummaryById(ctx context.Context, in *RequireStorageCategoryInfoSummaryByIdRequest, opts ...grpc.CallOption) (*RequireStorageCategoryInfoSummaryByIdResponse, error) + RequireStorageDeepItemInfoById(ctx context.Context, in *RequireStorageDeepItemInfoByIdRequest, opts ...grpc.CallOption) (*RequireStorageDeepItemInfoByIdResponse, error) + RequireStorageItemHandlerInfoById(ctx context.Context, in *RequireStorageItemHandlerInfoByIdRequest, opts ...grpc.CallOption) (*RequireStorageItemHandlerInfoByIdResponse, error) + RequireStorageItemInfoById(ctx context.Context, in *RequireStorageItemInfoByIdRequest, opts ...grpc.CallOption) (*RequireStorageItemInfoByIdResponse, error) + RequireStorageItemSpecsInfoById(ctx context.Context, in *RequireStorageItemSpecsInfoByIdRequest, opts ...grpc.CallOption) (*RequireStorageItemSpecsInfoByIdResponse, error) RequireStorageKindSummaryById(ctx context.Context, in *RequireStorageKindSummaryByIdRequest, opts ...grpc.CallOption) (*RequireStorageKindSummaryByIdResponse, error) RequireStorageMetadataScoreById(ctx context.Context, in *RequireStorageMetadataScoreByIdRequest, opts ...grpc.CallOption) (*RequireStorageMetadataScoreByIdResponse, error) + RequireStorageOperationReportById(ctx context.Context, in *RequireStorageOperationReportByIdRequest, opts ...grpc.CallOption) (*RequireStorageOperationReportByIdResponse, error) RequireStorageOptionalProcessedMetadataById(ctx context.Context, in *RequireStorageOptionalProcessedMetadataByIdRequest, opts ...grpc.CallOption) (*RequireStorageOptionalProcessedMetadataByIdResponse, error) RequireStorageOptionalProcessedTagsById(ctx context.Context, in *RequireStorageOptionalProcessedTagsByIdRequest, opts ...grpc.CallOption) (*RequireStorageOptionalProcessedTagsByIdResponse, error) RequireStorageOptionalTagSummaryById(ctx context.Context, in *RequireStorageOptionalTagSummaryByIdRequest, opts ...grpc.CallOption) (*RequireStorageOptionalTagSummaryByIdResponse, error) RequireStorageProcessedMetadataById(ctx context.Context, in *RequireStorageProcessedMetadataByIdRequest, opts ...grpc.CallOption) (*RequireStorageProcessedMetadataByIdResponse, error) RequireStorageProcessedMetadataHistoryById(ctx context.Context, in *RequireStorageProcessedMetadataHistoryByIdRequest, opts ...grpc.CallOption) (*RequireStorageProcessedMetadataHistoryByIdResponse, error) RequireStorageProcessedTagsById(ctx context.Context, in *RequireStorageProcessedTagsByIdRequest, opts ...grpc.CallOption) (*RequireStorageProcessedTagsByIdResponse, error) + RequireStorageSecuritySummaryById(ctx context.Context, in *RequireStorageSecuritySummaryByIdRequest, opts ...grpc.CallOption) (*RequireStorageSecuritySummaryByIdResponse, error) RequireStorageStockHealthScoreById(ctx context.Context, in *RequireStorageStockHealthScoreByIdRequest, opts ...grpc.CallOption) (*RequireStorageStockHealthScoreByIdResponse, error) RequireStorageTagSummaryById(ctx context.Context, in *RequireStorageTagSummaryByIdRequest, opts ...grpc.CallOption) (*RequireStorageTagSummaryByIdResponse, error) RequireWarehouseStockHealthScoreById(ctx context.Context, in *RequireWarehouseStockHealthScoreByIdRequest, opts ...grpc.CallOption) (*RequireWarehouseStockHealthScoreByIdResponse, error) @@ -700,6 +712,46 @@ func (c *productServiceClient) RequireStorageCategoryInfoSummaryById(ctx context return out, nil } +func (c *productServiceClient) RequireStorageDeepItemInfoById(ctx context.Context, in *RequireStorageDeepItemInfoByIdRequest, opts ...grpc.CallOption) (*RequireStorageDeepItemInfoByIdResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(RequireStorageDeepItemInfoByIdResponse) + err := c.cc.Invoke(ctx, ProductService_RequireStorageDeepItemInfoById_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *productServiceClient) RequireStorageItemHandlerInfoById(ctx context.Context, in *RequireStorageItemHandlerInfoByIdRequest, opts ...grpc.CallOption) (*RequireStorageItemHandlerInfoByIdResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(RequireStorageItemHandlerInfoByIdResponse) + err := c.cc.Invoke(ctx, ProductService_RequireStorageItemHandlerInfoById_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *productServiceClient) RequireStorageItemInfoById(ctx context.Context, in *RequireStorageItemInfoByIdRequest, opts ...grpc.CallOption) (*RequireStorageItemInfoByIdResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(RequireStorageItemInfoByIdResponse) + err := c.cc.Invoke(ctx, ProductService_RequireStorageItemInfoById_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *productServiceClient) RequireStorageItemSpecsInfoById(ctx context.Context, in *RequireStorageItemSpecsInfoByIdRequest, opts ...grpc.CallOption) (*RequireStorageItemSpecsInfoByIdResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(RequireStorageItemSpecsInfoByIdResponse) + err := c.cc.Invoke(ctx, ProductService_RequireStorageItemSpecsInfoById_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *productServiceClient) RequireStorageKindSummaryById(ctx context.Context, in *RequireStorageKindSummaryByIdRequest, opts ...grpc.CallOption) (*RequireStorageKindSummaryByIdResponse, error) { cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(RequireStorageKindSummaryByIdResponse) @@ -720,6 +772,16 @@ func (c *productServiceClient) RequireStorageMetadataScoreById(ctx context.Conte return out, nil } +func (c *productServiceClient) RequireStorageOperationReportById(ctx context.Context, in *RequireStorageOperationReportByIdRequest, opts ...grpc.CallOption) (*RequireStorageOperationReportByIdResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(RequireStorageOperationReportByIdResponse) + err := c.cc.Invoke(ctx, ProductService_RequireStorageOperationReportById_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *productServiceClient) RequireStorageOptionalProcessedMetadataById(ctx context.Context, in *RequireStorageOptionalProcessedMetadataByIdRequest, opts ...grpc.CallOption) (*RequireStorageOptionalProcessedMetadataByIdResponse, error) { cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(RequireStorageOptionalProcessedMetadataByIdResponse) @@ -780,6 +842,16 @@ func (c *productServiceClient) RequireStorageProcessedTagsById(ctx context.Conte return out, nil } +func (c *productServiceClient) RequireStorageSecuritySummaryById(ctx context.Context, in *RequireStorageSecuritySummaryByIdRequest, opts ...grpc.CallOption) (*RequireStorageSecuritySummaryByIdResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(RequireStorageSecuritySummaryByIdResponse) + err := c.cc.Invoke(ctx, ProductService_RequireStorageSecuritySummaryById_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *productServiceClient) RequireStorageStockHealthScoreById(ctx context.Context, in *RequireStorageStockHealthScoreByIdRequest, opts ...grpc.CallOption) (*RequireStorageStockHealthScoreByIdResponse, error) { cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(RequireStorageStockHealthScoreByIdResponse) @@ -1118,14 +1190,20 @@ type ProductServiceServer interface { QueryUser(context.Context, *QueryUserRequest) (*QueryUserResponse, error) QueryUsers(context.Context, *QueryUsersRequest) (*QueryUsersResponse, error) RequireStorageCategoryInfoSummaryById(context.Context, *RequireStorageCategoryInfoSummaryByIdRequest) (*RequireStorageCategoryInfoSummaryByIdResponse, error) + RequireStorageDeepItemInfoById(context.Context, *RequireStorageDeepItemInfoByIdRequest) (*RequireStorageDeepItemInfoByIdResponse, error) + RequireStorageItemHandlerInfoById(context.Context, *RequireStorageItemHandlerInfoByIdRequest) (*RequireStorageItemHandlerInfoByIdResponse, error) + RequireStorageItemInfoById(context.Context, *RequireStorageItemInfoByIdRequest) (*RequireStorageItemInfoByIdResponse, error) + RequireStorageItemSpecsInfoById(context.Context, *RequireStorageItemSpecsInfoByIdRequest) (*RequireStorageItemSpecsInfoByIdResponse, error) RequireStorageKindSummaryById(context.Context, *RequireStorageKindSummaryByIdRequest) (*RequireStorageKindSummaryByIdResponse, error) RequireStorageMetadataScoreById(context.Context, *RequireStorageMetadataScoreByIdRequest) (*RequireStorageMetadataScoreByIdResponse, error) + RequireStorageOperationReportById(context.Context, *RequireStorageOperationReportByIdRequest) (*RequireStorageOperationReportByIdResponse, error) RequireStorageOptionalProcessedMetadataById(context.Context, *RequireStorageOptionalProcessedMetadataByIdRequest) (*RequireStorageOptionalProcessedMetadataByIdResponse, error) RequireStorageOptionalProcessedTagsById(context.Context, *RequireStorageOptionalProcessedTagsByIdRequest) (*RequireStorageOptionalProcessedTagsByIdResponse, error) RequireStorageOptionalTagSummaryById(context.Context, *RequireStorageOptionalTagSummaryByIdRequest) (*RequireStorageOptionalTagSummaryByIdResponse, error) RequireStorageProcessedMetadataById(context.Context, *RequireStorageProcessedMetadataByIdRequest) (*RequireStorageProcessedMetadataByIdResponse, error) RequireStorageProcessedMetadataHistoryById(context.Context, *RequireStorageProcessedMetadataHistoryByIdRequest) (*RequireStorageProcessedMetadataHistoryByIdResponse, error) RequireStorageProcessedTagsById(context.Context, *RequireStorageProcessedTagsByIdRequest) (*RequireStorageProcessedTagsByIdResponse, error) + RequireStorageSecuritySummaryById(context.Context, *RequireStorageSecuritySummaryByIdRequest) (*RequireStorageSecuritySummaryByIdResponse, error) RequireStorageStockHealthScoreById(context.Context, *RequireStorageStockHealthScoreByIdRequest) (*RequireStorageStockHealthScoreByIdResponse, error) RequireStorageTagSummaryById(context.Context, *RequireStorageTagSummaryByIdRequest) (*RequireStorageTagSummaryByIdResponse, error) RequireWarehouseStockHealthScoreById(context.Context, *RequireWarehouseStockHealthScoreByIdRequest) (*RequireWarehouseStockHealthScoreByIdResponse, error) @@ -1311,12 +1389,27 @@ func (UnimplementedProductServiceServer) QueryUsers(context.Context, *QueryUsers func (UnimplementedProductServiceServer) RequireStorageCategoryInfoSummaryById(context.Context, *RequireStorageCategoryInfoSummaryByIdRequest) (*RequireStorageCategoryInfoSummaryByIdResponse, error) { return nil, status.Error(codes.Unimplemented, "method RequireStorageCategoryInfoSummaryById not implemented") } +func (UnimplementedProductServiceServer) RequireStorageDeepItemInfoById(context.Context, *RequireStorageDeepItemInfoByIdRequest) (*RequireStorageDeepItemInfoByIdResponse, error) { + return nil, status.Error(codes.Unimplemented, "method RequireStorageDeepItemInfoById not implemented") +} +func (UnimplementedProductServiceServer) RequireStorageItemHandlerInfoById(context.Context, *RequireStorageItemHandlerInfoByIdRequest) (*RequireStorageItemHandlerInfoByIdResponse, error) { + return nil, status.Error(codes.Unimplemented, "method RequireStorageItemHandlerInfoById not implemented") +} +func (UnimplementedProductServiceServer) RequireStorageItemInfoById(context.Context, *RequireStorageItemInfoByIdRequest) (*RequireStorageItemInfoByIdResponse, error) { + return nil, status.Error(codes.Unimplemented, "method RequireStorageItemInfoById not implemented") +} +func (UnimplementedProductServiceServer) RequireStorageItemSpecsInfoById(context.Context, *RequireStorageItemSpecsInfoByIdRequest) (*RequireStorageItemSpecsInfoByIdResponse, error) { + return nil, status.Error(codes.Unimplemented, "method RequireStorageItemSpecsInfoById not implemented") +} func (UnimplementedProductServiceServer) RequireStorageKindSummaryById(context.Context, *RequireStorageKindSummaryByIdRequest) (*RequireStorageKindSummaryByIdResponse, error) { return nil, status.Error(codes.Unimplemented, "method RequireStorageKindSummaryById not implemented") } func (UnimplementedProductServiceServer) RequireStorageMetadataScoreById(context.Context, *RequireStorageMetadataScoreByIdRequest) (*RequireStorageMetadataScoreByIdResponse, error) { return nil, status.Error(codes.Unimplemented, "method RequireStorageMetadataScoreById not implemented") } +func (UnimplementedProductServiceServer) RequireStorageOperationReportById(context.Context, *RequireStorageOperationReportByIdRequest) (*RequireStorageOperationReportByIdResponse, error) { + return nil, status.Error(codes.Unimplemented, "method RequireStorageOperationReportById not implemented") +} func (UnimplementedProductServiceServer) RequireStorageOptionalProcessedMetadataById(context.Context, *RequireStorageOptionalProcessedMetadataByIdRequest) (*RequireStorageOptionalProcessedMetadataByIdResponse, error) { return nil, status.Error(codes.Unimplemented, "method RequireStorageOptionalProcessedMetadataById not implemented") } @@ -1335,6 +1428,9 @@ func (UnimplementedProductServiceServer) RequireStorageProcessedMetadataHistoryB func (UnimplementedProductServiceServer) RequireStorageProcessedTagsById(context.Context, *RequireStorageProcessedTagsByIdRequest) (*RequireStorageProcessedTagsByIdResponse, error) { return nil, status.Error(codes.Unimplemented, "method RequireStorageProcessedTagsById not implemented") } +func (UnimplementedProductServiceServer) RequireStorageSecuritySummaryById(context.Context, *RequireStorageSecuritySummaryByIdRequest) (*RequireStorageSecuritySummaryByIdResponse, error) { + return nil, status.Error(codes.Unimplemented, "method RequireStorageSecuritySummaryById not implemented") +} func (UnimplementedProductServiceServer) RequireStorageStockHealthScoreById(context.Context, *RequireStorageStockHealthScoreByIdRequest) (*RequireStorageStockHealthScoreByIdResponse, error) { return nil, status.Error(codes.Unimplemented, "method RequireStorageStockHealthScoreById not implemented") } @@ -2322,6 +2418,78 @@ func _ProductService_RequireStorageCategoryInfoSummaryById_Handler(srv interface return interceptor(ctx, in, info, handler) } +func _ProductService_RequireStorageDeepItemInfoById_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(RequireStorageDeepItemInfoByIdRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProductServiceServer).RequireStorageDeepItemInfoById(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ProductService_RequireStorageDeepItemInfoById_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProductServiceServer).RequireStorageDeepItemInfoById(ctx, req.(*RequireStorageDeepItemInfoByIdRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _ProductService_RequireStorageItemHandlerInfoById_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(RequireStorageItemHandlerInfoByIdRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProductServiceServer).RequireStorageItemHandlerInfoById(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ProductService_RequireStorageItemHandlerInfoById_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProductServiceServer).RequireStorageItemHandlerInfoById(ctx, req.(*RequireStorageItemHandlerInfoByIdRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _ProductService_RequireStorageItemInfoById_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(RequireStorageItemInfoByIdRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProductServiceServer).RequireStorageItemInfoById(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ProductService_RequireStorageItemInfoById_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProductServiceServer).RequireStorageItemInfoById(ctx, req.(*RequireStorageItemInfoByIdRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _ProductService_RequireStorageItemSpecsInfoById_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(RequireStorageItemSpecsInfoByIdRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProductServiceServer).RequireStorageItemSpecsInfoById(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ProductService_RequireStorageItemSpecsInfoById_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProductServiceServer).RequireStorageItemSpecsInfoById(ctx, req.(*RequireStorageItemSpecsInfoByIdRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _ProductService_RequireStorageKindSummaryById_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(RequireStorageKindSummaryByIdRequest) if err := dec(in); err != nil { @@ -2358,6 +2526,24 @@ func _ProductService_RequireStorageMetadataScoreById_Handler(srv interface{}, ct return interceptor(ctx, in, info, handler) } +func _ProductService_RequireStorageOperationReportById_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(RequireStorageOperationReportByIdRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProductServiceServer).RequireStorageOperationReportById(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ProductService_RequireStorageOperationReportById_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProductServiceServer).RequireStorageOperationReportById(ctx, req.(*RequireStorageOperationReportByIdRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _ProductService_RequireStorageOptionalProcessedMetadataById_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(RequireStorageOptionalProcessedMetadataByIdRequest) if err := dec(in); err != nil { @@ -2466,6 +2652,24 @@ func _ProductService_RequireStorageProcessedTagsById_Handler(srv interface{}, ct return interceptor(ctx, in, info, handler) } +func _ProductService_RequireStorageSecuritySummaryById_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(RequireStorageSecuritySummaryByIdRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProductServiceServer).RequireStorageSecuritySummaryById(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ProductService_RequireStorageSecuritySummaryById_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProductServiceServer).RequireStorageSecuritySummaryById(ctx, req.(*RequireStorageSecuritySummaryByIdRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _ProductService_RequireStorageStockHealthScoreById_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(RequireStorageStockHealthScoreByIdRequest) if err := dec(in); err != nil { @@ -3173,6 +3377,22 @@ var ProductService_ServiceDesc = grpc.ServiceDesc{ MethodName: "RequireStorageCategoryInfoSummaryById", Handler: _ProductService_RequireStorageCategoryInfoSummaryById_Handler, }, + { + MethodName: "RequireStorageDeepItemInfoById", + Handler: _ProductService_RequireStorageDeepItemInfoById_Handler, + }, + { + MethodName: "RequireStorageItemHandlerInfoById", + Handler: _ProductService_RequireStorageItemHandlerInfoById_Handler, + }, + { + MethodName: "RequireStorageItemInfoById", + Handler: _ProductService_RequireStorageItemInfoById_Handler, + }, + { + MethodName: "RequireStorageItemSpecsInfoById", + Handler: _ProductService_RequireStorageItemSpecsInfoById_Handler, + }, { MethodName: "RequireStorageKindSummaryById", Handler: _ProductService_RequireStorageKindSummaryById_Handler, @@ -3181,6 +3401,10 @@ var ProductService_ServiceDesc = grpc.ServiceDesc{ MethodName: "RequireStorageMetadataScoreById", Handler: _ProductService_RequireStorageMetadataScoreById_Handler, }, + { + MethodName: "RequireStorageOperationReportById", + Handler: _ProductService_RequireStorageOperationReportById_Handler, + }, { MethodName: "RequireStorageOptionalProcessedMetadataById", Handler: _ProductService_RequireStorageOptionalProcessedMetadataById_Handler, @@ -3205,6 +3429,10 @@ var ProductService_ServiceDesc = grpc.ServiceDesc{ MethodName: "RequireStorageProcessedTagsById", Handler: _ProductService_RequireStorageProcessedTagsById_Handler, }, + { + MethodName: "RequireStorageSecuritySummaryById", + Handler: _ProductService_RequireStorageSecuritySummaryById_Handler, + }, { MethodName: "RequireStorageStockHealthScoreById", Handler: _ProductService_RequireStorageStockHealthScoreById_Handler, diff --git a/v2/pkg/grpctest/testdata/products.graphqls b/v2/pkg/grpctest/testdata/products.graphqls index 0d3d1585b3..2017743903 100644 --- a/v2/pkg/grpctest/testdata/products.graphqls +++ b/v2/pkg/grpctest/testdata/products.graphqls @@ -57,6 +57,25 @@ type Storage @key(fields: "id") { kindSummary: String! @requires(fields: "storageKind") categoryInfoSummary: String! @requires(fields: "categoryInfo { kind name }") + # External abstract type fields for @requires testing + primaryItem: StorageItem! @external + lastStorageOperation: StorageOperationResult! @external + securitySetup: SecuritySetup! @external + + # @requires fields using abstract types + # Pattern 1: Flat abstract — interface + itemInfo: String! @requires(fields: "primaryItem { ... on PalletItem { __typename name palletCount } ... on ContainerItem { __typename name containerSize } }") + # Pattern 2: Flat abstract — union + operationReport: String! @requires(fields: "lastStorageOperation { ... on StorageSuccess { __typename message completedAt } ... on StorageFailure { __typename message errorCode } }") + # Pattern 3: Concrete wrapping abstract + securitySummary: String! @requires(fields: "securitySetup { securityLevel primaryItem { ... on PalletItem { __typename name palletCount } ... on ContainerItem { __typename name containerSize } } }") + # Pattern 4: Concrete message inside fragment + itemHandlerInfo: String! @requires(fields: "primaryItem { ... on PalletItem { __typename handler { name } } ... on ContainerItem { __typename handler { name } } }") + # Pattern 5: Deep concrete nesting inside fragment (specs → dimensions) + itemSpecsInfo: String! @requires(fields: "primaryItem { ... on PalletItem { __typename specs { name dimensions { length width } } } ... on ContainerItem { __typename specs { name dimensions { length width } } } }") + # Pattern 6: Nested abstract through concrete intermediary (handler → assignedItem) + deepItemInfo: String! @requires(fields: "primaryItem { ... on PalletItem { __typename handler { assignedItem { ... on ContainerItem { __typename name containerSize } ... on PalletItem { __typename name palletCount } } } } ... on ContainerItem { __typename handler { name } } }") + # @connect_fieldResolver fields storageStatus(checkHealth: Boolean!): ActionResult! @connect__fieldResolver(context: "id name") linkedStorages(depth: Int!): [Storage!]! @connect__fieldResolver(context: "id name location") @@ -292,6 +311,73 @@ type BreedCharacteristics { lifespan: String! } +# Storage abstract types for @requires testing + +interface StorageItem { + id: ID! + name: String! + weight: Float! +} + +type PalletItem implements StorageItem { + id: ID! + name: String! + weight: Float! + palletCount: Int! + handler: ItemHandler! + specs: PalletSpecs! +} + +type ContainerItem implements StorageItem { + id: ID! + name: String! + weight: Float! + containerSize: String! + handler: ItemHandler! + specs: ContainerSpecs! +} + +type ItemHandler { + id: ID! + name: String! + assignedItem: StorageItem! +} + +type PalletSpecs { + name: String! + maxWeight: Float! + dimensions: Dimensions! +} + +type ContainerSpecs { + name: String! + volume: Float! + dimensions: Dimensions! +} + +type Dimensions { + length: Float! + width: Float! + height: Float! +} + +union StorageOperationResult = StorageSuccess | StorageFailure + +type StorageSuccess { + message: String! + completedAt: String! +} + +type StorageFailure { + message: String! + errorCode: String! +} + +type SecuritySetup { + securityLevel: String! + primaryItem: StorageItem! +} + # Union Types for Testing # Search result union - tests union with existing types