diff --git a/v2/pkg/engine/datasource/grpc_datasource/compiler.go b/v2/pkg/engine/datasource/grpc_datasource/compiler.go index 5728bdd6cc..6988ff8fba 100644 --- a/v2/pkg/engine/datasource/grpc_datasource/compiler.go +++ b/v2/pkg/engine/datasource/grpc_datasource/compiler.go @@ -549,8 +549,8 @@ func (p *RPCCompiler) buildProtoMessageWithContext(inputMessage Message, rpcMess rootMessage := dynamicpb.NewMessage(inputMessage.Desc) - if len(inputMessage.Fields) != 2 { - return nil, fmt.Errorf("message %s must have exactly two fields: context and field_args", inputMessage.Name) + if len(inputMessage.Fields) < 1 { + return nil, fmt.Errorf("message %s must have at least the context field", inputMessage.Name) } contextSchemaField := inputMessage.GetField("context") @@ -587,24 +587,22 @@ func (p *RPCCompiler) buildProtoMessageWithContext(inputMessage Message, rpcMess contextList.Append(val) } - argsSchemaField := inputMessage.GetField("field_args") - if argsSchemaField == nil { - return nil, fmt.Errorf("field_args field not found in message %s", inputMessage.Name) - } - - argsMessage := p.doc.Messages[argsSchemaField.MessageRef] argsRPCField := rpcMessage.Fields.ByName("field_args") - if argsRPCField == nil { - return nil, fmt.Errorf("field_args field not found in message %s", rpcMessage.Name) - } + if argsRPCField != nil { + argsSchemaField := inputMessage.GetField("field_args") + if argsSchemaField == nil { + return nil, fmt.Errorf("field_args field not found in message %s", inputMessage.Name) + } - args, err := p.buildProtoMessage(argsMessage, argsRPCField.Message, data) - if err != nil { - return nil, err - } - // Set the args field - if err := p.setMessageValue(rootMessage, argsRPCField.Name, protoref.ValueOfMessage(args)); err != nil { - return nil, err + argsMessage := p.doc.Messages[argsSchemaField.MessageRef] + args, err := p.buildProtoMessage(argsMessage, argsRPCField.Message, data) + if err != nil { + return nil, err + } + // Set the args field + if err := p.setMessageValue(rootMessage, argsRPCField.Name, protoref.ValueOfMessage(args)); err != nil { + return nil, err + } } return rootMessage, nil diff --git a/v2/pkg/engine/datasource/grpc_datasource/execution_plan.go b/v2/pkg/engine/datasource/grpc_datasource/execution_plan.go index aa33442d55..33a959d293 100644 --- a/v2/pkg/engine/datasource/grpc_datasource/execution_plan.go +++ b/v2/pkg/engine/datasource/grpc_datasource/execution_plan.go @@ -925,7 +925,12 @@ func (r *rpcPlanningContext) isFieldResolver(fieldDefRef int, isRootField bool) return false } - return r.definition.FieldDefinitionHasArgumentsDefinitions(fieldDefRef) + return r.definition.FieldDefinitionHasArgumentsDefinitions(fieldDefRef) || r.hasFieldResolverDirective(fieldDefRef) +} + +// hasFieldResolverDirective checks if a field has a field resolver directive. +func (r *rpcPlanningContext) hasFieldResolverDirective(fieldDefRef int) bool { + return r.definition.FieldDefinitionHasNamedDirective(fieldDefRef, fieldResolverDirectiveName) } // isRequiredField checks if a field is a required field. @@ -986,12 +991,14 @@ func (r *rpcPlanningContext) setResolvedField(walker *astvisitor.Walker, fieldDe }) } - fieldArguments, err := r.parseFieldArguments(walker, fieldDefRef, fieldArgs) - if err != nil { - return err - } + if len(fieldArgs) > 0 { + fieldArguments, err := r.parseFieldArguments(walker, fieldDefRef, fieldArgs) + if err != nil { + return err + } - resolvedField.fieldArguments = fieldArguments + resolvedField.fieldArguments = fieldArguments + } fieldDefType := r.definition.FieldDefinitionType(fieldDefRef) if r.typeIsNullableOrNestedList(fieldDefType) { @@ -1446,8 +1453,11 @@ func (r *rpcPlanningContext) createResolverRPCCalls(subgraphName string, resolve Name: resolveConfig.RPC + "Context", } - fieldArgsMessage := &RPCMessage{ - Name: resolveConfig.RPC + "Args", + var fieldArgsMessage *RPCMessage + if len(resolvedField.fieldArguments) > 0 { + fieldArgsMessage = &RPCMessage{ + Name: resolveConfig.RPC + "Args", + } } call, err := r.newResolveRPCCall(&resolveRPCCallConfig{ @@ -1555,28 +1565,29 @@ func (r *rpcPlanningContext) newResolveRPCCall(config *resolveRPCCallConfig) (RP }, } + requestFields := RPCFields{ + { + Name: contextFieldName, + ProtoTypeName: DataTypeMessage, + Repeated: true, + Message: config.contextMessage, + }, + } + if config.fieldArgsMessage != nil { + requestFields = append(requestFields, RPCField{ + Name: fieldArgsFieldName, + ProtoTypeName: DataTypeMessage, + Message: config.fieldArgsMessage, + }) + } + return RPCCall{ ID: resolvedField.id, DependentCalls: []int{resolvedField.callerRef}, ResponsePath: resolvedField.responsePath, MethodName: resolveConfig.RPC, Kind: CallKindResolve, - Request: RPCMessage{ - Name: resolveConfig.Request, - Fields: RPCFields{ - { - Name: contextFieldName, - ProtoTypeName: DataTypeMessage, - Repeated: true, - Message: config.contextMessage, - }, - { - Name: fieldArgsFieldName, - ProtoTypeName: DataTypeMessage, - Message: config.fieldArgsMessage, - }, - }, - }, - Response: response, + Request: RPCMessage{Name: resolveConfig.Request, Fields: requestFields}, + Response: response, }, nil } diff --git a/v2/pkg/engine/datasource/grpc_datasource/execution_plan_field_resolvers_test.go b/v2/pkg/engine/datasource/grpc_datasource/execution_plan_field_resolvers_test.go index a580ca36d4..ae4a632173 100644 --- a/v2/pkg/engine/datasource/grpc_datasource/execution_plan_field_resolvers_test.go +++ b/v2/pkg/engine/datasource/grpc_datasource/execution_plan_field_resolvers_test.go @@ -1303,13 +1303,6 @@ func TestExecutionPlanFieldResolvers_WithNestedResolvers(t *testing.T) { }, }, }, - { - Name: "field_args", - ProtoTypeName: DataTypeMessage, - Message: &RPCMessage{ - Name: "ResolveCategoryChildCategoriesArgs", - }, - }, }, }, Response: RPCMessage{ @@ -1418,13 +1411,6 @@ func TestExecutionPlanFieldResolvers_WithNestedResolvers(t *testing.T) { }, }, }, - { - Name: "field_args", - ProtoTypeName: DataTypeMessage, - Message: &RPCMessage{ - Name: "ResolveCategoryChildCategoriesArgs", - }, - }, }, }, Response: RPCMessage{ @@ -1503,13 +1489,6 @@ func TestExecutionPlanFieldResolvers_WithNestedResolvers(t *testing.T) { }, }, }, - { - Name: "field_args", - ProtoTypeName: DataTypeMessage, - Message: &RPCMessage{ - Name: "ResolveCategoryChildCategoriesArgs", - }, - }, }, }, Response: RPCMessage{ @@ -1618,13 +1597,6 @@ func TestExecutionPlanFieldResolvers_WithNestedResolvers(t *testing.T) { }, }, }, - { - Name: "field_args", - ProtoTypeName: DataTypeMessage, - Message: &RPCMessage{ - Name: "ResolveCategoryChildCategoriesArgs", - }, - }, }, }, Response: RPCMessage{ @@ -1704,13 +1676,6 @@ func TestExecutionPlanFieldResolvers_WithNestedResolvers(t *testing.T) { }, }, }, - { - Name: "field_args", - ProtoTypeName: DataTypeMessage, - Message: &RPCMessage{ - Name: "ResolveCategoryChildCategoriesArgs", - }, - }, }, }, Response: RPCMessage{ @@ -1820,13 +1785,6 @@ func TestExecutionPlanFieldResolvers_WithNestedResolvers(t *testing.T) { }, }, }, - { - Name: "field_args", - ProtoTypeName: DataTypeMessage, - Message: &RPCMessage{ - Name: "ResolveCategoryChildCategoriesArgs", - }, - }, }, }, Response: RPCMessage{ @@ -1905,13 +1863,6 @@ func TestExecutionPlanFieldResolvers_WithNestedResolvers(t *testing.T) { }, }, }, - { - Name: "field_args", - ProtoTypeName: DataTypeMessage, - Message: &RPCMessage{ - Name: "ResolveCategoryChildCategoriesArgs", - }, - }, }, }, Response: RPCMessage{ @@ -1990,13 +1941,6 @@ func TestExecutionPlanFieldResolvers_WithNestedResolvers(t *testing.T) { }, }, }, - { - Name: "field_args", - ProtoTypeName: DataTypeMessage, - Message: &RPCMessage{ - Name: "ResolveCategoryChildCategoriesArgs", - }, - }, }, }, Response: RPCMessage{ @@ -2075,13 +2019,6 @@ func TestExecutionPlanFieldResolvers_WithNestedResolvers(t *testing.T) { }, }, }, - { - Name: "field_args", - ProtoTypeName: DataTypeMessage, - Message: &RPCMessage{ - Name: "ResolveCategoryChildCategoriesArgs", - }, - }, }, }, Response: RPCMessage{ @@ -2190,13 +2127,6 @@ func TestExecutionPlanFieldResolvers_WithNestedResolvers(t *testing.T) { }, }, }, - { - Name: "field_args", - ProtoTypeName: DataTypeMessage, - Message: &RPCMessage{ - Name: "ResolveCategoryOptionalCategoriesArgs", - }, - }, }, }, Response: RPCMessage{ @@ -2310,13 +2240,6 @@ func TestExecutionPlanFieldResolvers_WithNestedResolvers(t *testing.T) { }, }, }, - { - Name: "field_args", - ProtoTypeName: DataTypeMessage, - Message: &RPCMessage{ - Name: "ResolveCategoryOptionalCategoriesArgs", - }, - }, }, }, Response: RPCMessage{ @@ -2400,13 +2323,6 @@ func TestExecutionPlanFieldResolvers_WithNestedResolvers(t *testing.T) { }, }, }, - { - Name: "field_args", - ProtoTypeName: DataTypeMessage, - Message: &RPCMessage{ - Name: "ResolveCategoryOptionalCategoriesArgs", - }, - }, }, }, Response: RPCMessage{ @@ -2531,13 +2447,6 @@ func TestExecutionPlanFieldResolvers_WithNestedResolvers(t *testing.T) { }, }, }, - { - Name: "field_args", - ProtoTypeName: DataTypeMessage, - Message: &RPCMessage{ - Name: "ResolveCategoryChildCategoriesArgs", - }, - }, }, }, Response: RPCMessage{ @@ -2616,13 +2525,6 @@ func TestExecutionPlanFieldResolvers_WithNestedResolvers(t *testing.T) { }, }, }, - { - Name: "field_args", - ProtoTypeName: DataTypeMessage, - Message: &RPCMessage{ - Name: "ResolveCategoryOptionalCategoriesArgs", - }, - }, }, }, Response: RPCMessage{ @@ -2706,13 +2608,6 @@ func TestExecutionPlanFieldResolvers_WithNestedResolvers(t *testing.T) { }, }, }, - { - Name: "field_args", - ProtoTypeName: DataTypeMessage, - Message: &RPCMessage{ - Name: "ResolveCategoryOptionalCategoriesArgs", - }, - }, }, }, Response: RPCMessage{ @@ -2796,13 +2691,6 @@ func TestExecutionPlanFieldResolvers_WithNestedResolvers(t *testing.T) { }, }, }, - { - Name: "field_args", - ProtoTypeName: DataTypeMessage, - Message: &RPCMessage{ - Name: "ResolveCategoryChildCategoriesArgs", - }, - }, }, }, Response: RPCMessage{ @@ -4315,13 +4203,6 @@ func TestExecutionPlanFieldResolvers_CustomSchemas(t *testing.T) { }, }, }, - { - Name: "field_args", - ProtoTypeName: DataTypeMessage, - Message: &RPCMessage{ - Name: "ResolveFooFooResolverOptionalArgumentArgs", - }, - }, }, }, Response: RPCMessage{ @@ -5701,6 +5582,697 @@ type Query { return doc } +func TestExecutionPlanFieldResolvers_ArgumentLess(t *testing.T) { + t.Parallel() + tests := []struct { + name string + query string + expectedPlan *RPCExecutionPlan + expectedError string + }{ + { + name: "Argument-less field resolver returning scalar", + query: "query CategoriesWithTotalProducts { categories { id totalProducts } }", + expectedPlan: &RPCExecutionPlan{ + Calls: []RPCCall{ + { + ServiceName: "Products", + MethodName: "QueryCategories", + Request: RPCMessage{ + Name: "QueryCategoriesRequest", + }, + Response: RPCMessage{ + Name: "QueryCategoriesResponse", + Fields: []RPCField{ + { + Name: "categories", + ProtoTypeName: DataTypeMessage, + JSONPath: "categories", + Repeated: true, + Message: &RPCMessage{ + Name: "Category", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + }, + }, + }, + }, + }, + }, + }, + { + ID: 1, + DependentCalls: []int{0}, + ServiceName: "Products", + MethodName: "ResolveCategoryTotalProducts", + Kind: CallKindResolve, + ResponsePath: buildPath("categories.totalProducts"), + Request: RPCMessage{ + Name: "ResolveCategoryTotalProductsRequest", + Fields: []RPCField{ + { + Name: "context", + ProtoTypeName: DataTypeMessage, + JSONPath: "", + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryTotalProductsContext", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + ResolvePath: buildPath("categories.id"), + }, + }, + }, + }, + }, + }, + Response: RPCMessage{ + Name: "ResolveCategoryTotalProductsResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + JSONPath: "result", + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryTotalProductsResult", + Fields: []RPCField{ + { + Name: "total_products", + ProtoTypeName: DataTypeInt32, + JSONPath: "totalProducts", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + { + name: "Argument-less field resolver returning nullable object", + query: "query CategoriesWithTopSubcategory { categories { id name topSubcategory { id name } } }", + expectedPlan: &RPCExecutionPlan{ + Calls: []RPCCall{ + { + ServiceName: "Products", + MethodName: "QueryCategories", + Request: RPCMessage{ + Name: "QueryCategoriesRequest", + }, + Response: RPCMessage{ + Name: "QueryCategoriesResponse", + Fields: []RPCField{ + { + Name: "categories", + ProtoTypeName: DataTypeMessage, + JSONPath: "categories", + Repeated: true, + Message: &RPCMessage{ + Name: "Category", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + }, + }, + }, + }, + }, + }, + { + ID: 1, + DependentCalls: []int{0}, + ServiceName: "Products", + MethodName: "ResolveCategoryTopSubcategory", + Kind: CallKindResolve, + ResponsePath: buildPath("categories.topSubcategory"), + Request: RPCMessage{ + Name: "ResolveCategoryTopSubcategoryRequest", + Fields: []RPCField{ + { + Name: "context", + ProtoTypeName: DataTypeMessage, + JSONPath: "", + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryTopSubcategoryContext", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + ResolvePath: buildPath("categories.id"), + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + ResolvePath: buildPath("categories.name"), + }, + }, + }, + }, + }, + }, + Response: RPCMessage{ + Name: "ResolveCategoryTopSubcategoryResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + JSONPath: "result", + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryTopSubcategoryResult", + Fields: []RPCField{ + { + Name: "top_subcategory", + ProtoTypeName: DataTypeMessage, + JSONPath: "topSubcategory", + Optional: true, + Message: &RPCMessage{ + Name: "Subcategory", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + { + name: "Argument-less field resolver returning required list", + query: "query CategoriesWithActiveSubcategories { categories { id activeSubcategories { id name } } }", + expectedPlan: &RPCExecutionPlan{ + Calls: []RPCCall{ + { + ServiceName: "Products", + MethodName: "QueryCategories", + Request: RPCMessage{ + Name: "QueryCategoriesRequest", + }, + Response: RPCMessage{ + Name: "QueryCategoriesResponse", + Fields: []RPCField{ + { + Name: "categories", + ProtoTypeName: DataTypeMessage, + JSONPath: "categories", + Repeated: true, + Message: &RPCMessage{ + Name: "Category", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + }, + }, + }, + }, + }, + }, + }, + { + ID: 1, + DependentCalls: []int{0}, + ServiceName: "Products", + MethodName: "ResolveCategoryActiveSubcategories", + Kind: CallKindResolve, + ResponsePath: buildPath("categories.activeSubcategories"), + Request: RPCMessage{ + Name: "ResolveCategoryActiveSubcategoriesRequest", + Fields: []RPCField{ + { + Name: "context", + ProtoTypeName: DataTypeMessage, + JSONPath: "", + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryActiveSubcategoriesContext", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + ResolvePath: buildPath("categories.id"), + }, + }, + }, + }, + }, + }, + Response: RPCMessage{ + Name: "ResolveCategoryActiveSubcategoriesResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + JSONPath: "result", + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryActiveSubcategoriesResult", + Fields: []RPCField{ + { + Name: "active_subcategories", + ProtoTypeName: DataTypeMessage, + JSONPath: "activeSubcategories", + Repeated: true, + Message: &RPCMessage{ + Name: "Subcategory", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + { + name: "Nested argument-less resolver on CategoryMetrics", + query: "query CategoriesWithNestedArglessResolver($metricType: String!) { categories { id categoryMetrics(metricType: $metricType) { id averageScore } } }", + expectedPlan: &RPCExecutionPlan{ + Calls: []RPCCall{ + { + ServiceName: "Products", + MethodName: "QueryCategories", + Request: RPCMessage{ + Name: "QueryCategoriesRequest", + }, + Response: RPCMessage{ + Name: "QueryCategoriesResponse", + Fields: []RPCField{ + { + Name: "categories", + ProtoTypeName: DataTypeMessage, + JSONPath: "categories", + Repeated: true, + Message: &RPCMessage{ + Name: "Category", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + }, + }, + }, + }, + }, + }, + }, + { + ID: 1, + DependentCalls: []int{0}, + ServiceName: "Products", + MethodName: "ResolveCategoryCategoryMetrics", + Kind: CallKindResolve, + ResponsePath: buildPath("categories.categoryMetrics"), + Request: RPCMessage{ + Name: "ResolveCategoryCategoryMetricsRequest", + Fields: []RPCField{ + { + Name: "context", + ProtoTypeName: DataTypeMessage, + JSONPath: "", + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryCategoryMetricsContext", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + ResolvePath: buildPath("categories.id"), + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + ResolvePath: buildPath("categories.name"), + }, + }, + }, + }, + { + Name: "field_args", + ProtoTypeName: DataTypeMessage, + JSONPath: "", + Message: &RPCMessage{ + Name: "ResolveCategoryCategoryMetricsArgs", + Fields: []RPCField{ + { + Name: "metric_type", + ProtoTypeName: DataTypeString, + JSONPath: "metricType", + }, + }, + }, + }, + }, + }, + Response: RPCMessage{ + Name: "ResolveCategoryCategoryMetricsResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + JSONPath: "result", + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryCategoryMetricsResult", + Fields: []RPCField{ + { + Name: "category_metrics", + ProtoTypeName: DataTypeMessage, + JSONPath: "categoryMetrics", + Optional: true, + Message: &RPCMessage{ + Name: "CategoryMetrics", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + { + ID: 2, + DependentCalls: []int{1}, + ServiceName: "Products", + MethodName: "ResolveCategoryMetricsAverageScore", + Kind: CallKindResolve, + ResponsePath: buildPath("categories.categoryMetrics.averageScore"), + Request: RPCMessage{ + Name: "ResolveCategoryMetricsAverageScoreRequest", + Fields: []RPCField{ + { + Name: "context", + ProtoTypeName: DataTypeMessage, + JSONPath: "", + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryMetricsAverageScoreContext", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + ResolvePath: buildPath("result.category_metrics.id"), + }, + { + Name: "metric_type", + ProtoTypeName: DataTypeString, + JSONPath: "metricType", + ResolvePath: buildPath("result.category_metrics.metric_type"), + }, + }, + }, + }, + }, + }, + Response: RPCMessage{ + Name: "ResolveCategoryMetricsAverageScoreResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + JSONPath: "result", + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryMetricsAverageScoreResult", + Fields: []RPCField{ + { + Name: "average_score", + ProtoTypeName: DataTypeDouble, + JSONPath: "averageScore", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + { + name: "Mixed with-args and argument-less field resolvers", + query: "query CategoriesMixed($f: ProductCountFilter) { categories { id totalProducts productCount(filters: $f) } }", + expectedPlan: &RPCExecutionPlan{ + Calls: []RPCCall{ + { + ServiceName: "Products", + MethodName: "QueryCategories", + Request: RPCMessage{ + Name: "QueryCategoriesRequest", + }, + Response: RPCMessage{ + Name: "QueryCategoriesResponse", + Fields: []RPCField{ + { + Name: "categories", + ProtoTypeName: DataTypeMessage, + JSONPath: "categories", + Repeated: true, + Message: &RPCMessage{ + Name: "Category", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + }, + }, + }, + }, + }, + }, + }, + { + ID: 1, + DependentCalls: []int{0}, + ServiceName: "Products", + MethodName: "ResolveCategoryTotalProducts", + Kind: CallKindResolve, + ResponsePath: buildPath("categories.totalProducts"), + Request: RPCMessage{ + Name: "ResolveCategoryTotalProductsRequest", + Fields: []RPCField{ + { + Name: "context", + ProtoTypeName: DataTypeMessage, + JSONPath: "", + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryTotalProductsContext", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + ResolvePath: buildPath("categories.id"), + }, + }, + }, + }, + }, + }, + Response: RPCMessage{ + Name: "ResolveCategoryTotalProductsResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + JSONPath: "result", + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryTotalProductsResult", + Fields: []RPCField{ + { + Name: "total_products", + ProtoTypeName: DataTypeInt32, + JSONPath: "totalProducts", + }, + }, + }, + }, + }, + }, + }, + { + ID: 2, + DependentCalls: []int{0}, + ServiceName: "Products", + MethodName: "ResolveCategoryProductCount", + Kind: CallKindResolve, + ResponsePath: buildPath("categories.productCount"), + Request: RPCMessage{ + Name: "ResolveCategoryProductCountRequest", + Fields: []RPCField{ + { + Name: "context", + ProtoTypeName: DataTypeMessage, + JSONPath: "", + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryProductCountContext", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + ResolvePath: buildPath("categories.id"), + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + ResolvePath: buildPath("categories.name"), + }, + }, + }, + }, + { + Name: "field_args", + ProtoTypeName: DataTypeMessage, + JSONPath: "", + Message: &RPCMessage{ + Name: "ResolveCategoryProductCountArgs", + Fields: []RPCField{ + { + Name: "filters", + ProtoTypeName: DataTypeMessage, + JSONPath: "f", + Optional: true, + Message: &RPCMessage{ + Name: "ProductCountFilter", + Fields: []RPCField{ + { + Name: "min_price", + ProtoTypeName: DataTypeDouble, + JSONPath: "minPrice", + Optional: true, + }, + { + Name: "max_price", + ProtoTypeName: DataTypeDouble, + JSONPath: "maxPrice", + Optional: true, + }, + { + Name: "in_stock", + ProtoTypeName: DataTypeBool, + JSONPath: "inStock", + Optional: true, + }, + { + Name: "search_term", + ProtoTypeName: DataTypeString, + JSONPath: "searchTerm", + Optional: true, + }, + }, + }, + }, + }, + }, + }, + }, + }, + Response: RPCMessage{ + Name: "ResolveCategoryProductCountResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + JSONPath: "result", + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryProductCountResult", + Fields: []RPCField{ + { + Name: "product_count", + ProtoTypeName: DataTypeInt32, + JSONPath: "productCount", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + t.Parallel() + runTest(t, testCase{ + query: tt.query, + expectedPlan: tt.expectedPlan, + expectedError: tt.expectedError, + }) + }) + } +} + func mappingWithNestedResolverAndCompositeType(_ *testing.T) *GRPCMapping { return &GRPCMapping{ Service: "Foo", diff --git a/v2/pkg/engine/datasource/grpc_datasource/grpc_datasource_spy_test.go b/v2/pkg/engine/datasource/grpc_datasource/grpc_datasource_spy_test.go index f9e710d6a2..2ad9172916 100644 --- a/v2/pkg/engine/datasource/grpc_datasource/grpc_datasource_spy_test.go +++ b/v2/pkg/engine/datasource/grpc_datasource/grpc_datasource_spy_test.go @@ -7,6 +7,7 @@ import ( "sync/atomic" "testing" + "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "google.golang.org/grpc" "google.golang.org/grpc/credentials/insecure" @@ -21,14 +22,19 @@ import ( type mockServiceSpy struct { grpctest.MockService - categoriesCalls atomic.Int64 - categoryCalls atomic.Int64 - normalizedScoreCalls atomic.Int64 - relatedCategoryCalls atomic.Int64 - productCountCalls atomic.Int64 - popularityScoreCalls atomic.Int64 - categoryMetricsCalls atomic.Int64 - mascotCalls atomic.Int64 + categoriesCalls atomic.Int64 + categoryCalls atomic.Int64 + normalizedScoreCalls atomic.Int64 + relatedCategoryCalls atomic.Int64 + productCountCalls atomic.Int64 + popularityScoreCalls atomic.Int64 + categoryMetricsCalls atomic.Int64 + mascotCalls atomic.Int64 + totalProductsCalls atomic.Int64 + topSubcategoryCalls atomic.Int64 + activeSubcategoriesCalls atomic.Int64 + parentCategoryCalls atomic.Int64 + averageScoreCalls atomic.Int64 queryCategoryFunc func(ctx context.Context, req *productv1.QueryCategoryRequest) (*productv1.QueryCategoryResponse, error) } @@ -76,6 +82,31 @@ func (s *mockServiceSpy) ResolveCategoryMascot(ctx context.Context, req *product return s.MockService.ResolveCategoryMascot(ctx, req) } +func (s *mockServiceSpy) ResolveCategoryTotalProducts(ctx context.Context, req *productv1.ResolveCategoryTotalProductsRequest) (*productv1.ResolveCategoryTotalProductsResponse, error) { + s.totalProductsCalls.Add(1) + return s.MockService.ResolveCategoryTotalProducts(ctx, req) +} + +func (s *mockServiceSpy) ResolveCategoryTopSubcategory(ctx context.Context, req *productv1.ResolveCategoryTopSubcategoryRequest) (*productv1.ResolveCategoryTopSubcategoryResponse, error) { + s.topSubcategoryCalls.Add(1) + return s.MockService.ResolveCategoryTopSubcategory(ctx, req) +} + +func (s *mockServiceSpy) ResolveCategoryActiveSubcategories(ctx context.Context, req *productv1.ResolveCategoryActiveSubcategoriesRequest) (*productv1.ResolveCategoryActiveSubcategoriesResponse, error) { + s.activeSubcategoriesCalls.Add(1) + return s.MockService.ResolveCategoryActiveSubcategories(ctx, req) +} + +func (s *mockServiceSpy) ResolveSubcategoryParentCategory(ctx context.Context, req *productv1.ResolveSubcategoryParentCategoryRequest) (*productv1.ResolveSubcategoryParentCategoryResponse, error) { + s.parentCategoryCalls.Add(1) + return s.MockService.ResolveSubcategoryParentCategory(ctx, req) +} + +func (s *mockServiceSpy) ResolveCategoryMetricsAverageScore(ctx context.Context, req *productv1.ResolveCategoryMetricsAverageScoreRequest) (*productv1.ResolveCategoryMetricsAverageScoreResponse, error) { + s.averageScoreCalls.Add(1) + return s.MockService.ResolveCategoryMetricsAverageScore(ctx, req) +} + func setupSpyServer(t *testing.T) (*mockServiceSpy, *grpc.ClientConn, func()) { spy := &mockServiceSpy{} lis := bufconn.Listen(1024 * 1024) @@ -178,3 +209,79 @@ func Test_DataSource_Load_NullCategory_FieldResolversNotInvoked(t *testing.T) { require.Zero(t, spy.categoryMetricsCalls.Load(), "ResolveCategoryCategoryMetrics must not be called when category is null") require.Zero(t, spy.mascotCalls.Load(), "ResolveCategoryMascot must not be called when category is null") } + +// Test_DataSource_Load_ArgumentLessFieldResolversCalled verifies that argument-less field +// resolver RPCs are actually called by the engine. +func Test_DataSource_Load_ArgumentLessFieldResolversCalled(t *testing.T) { + spy, conn, cleanup := setupSpyServer(t) + t.Cleanup(cleanup) + + query := "query CategoriesWithArglessResolvers { categories { id totalProducts topSubcategory { id name } activeSubcategories { id name } } }" + vars := `{"variables":{}}` + + schemaDoc := grpctest.MustGraphQLSchema(t) + queryDoc, report := astparser.ParseGraphqlDocumentString(query) + require.False(t, report.HasErrors(), "failed to parse query: %s", report.Error()) + + compiler, err := NewProtoCompiler(grpctest.MustProtoSchema(t), testMapping()) + require.NoError(t, err) + + ds, err := NewDataSource(conn, DataSourceConfig{ + Operation: &queryDoc, + Definition: &schemaDoc, + SubgraphName: "Products", + Mapping: testMapping(), + Compiler: compiler, + }) + require.NoError(t, err) + + input := fmt.Sprintf(`{"query":%q,"body":%s}`, query, vars) + _, err = ds.Load(context.Background(), nil, []byte(input)) + require.NoError(t, err) + + assert.Equal(t, int64(1), spy.categoriesCalls.Load(), "QueryCategories must be called") + assert.Equal(t, int64(1), spy.totalProductsCalls.Load(), "ResolveCategoryTotalProducts must be called") + assert.Equal(t, int64(1), spy.topSubcategoryCalls.Load(), "ResolveCategoryTopSubcategory must be called") + assert.Equal(t, int64(1), spy.activeSubcategoriesCalls.Load(), "ResolveCategoryActiveSubcategories must be called") +} + +// Test_DataSource_Load_NullCategory_ArgumentLessFieldResolversNotInvoked verifies that when +// the top-level category query returns null, argument-less field resolver RPCs are not invoked. +func Test_DataSource_Load_NullCategory_ArgumentLessFieldResolversNotInvoked(t *testing.T) { + spy, conn, cleanup := setupSpyServer(t) + t.Cleanup(cleanup) + + spy.queryCategoryFunc = func(_ context.Context, _ *productv1.QueryCategoryRequest) (*productv1.QueryCategoryResponse, error) { + return &productv1.QueryCategoryResponse{ + Category: nil, + }, nil + } + + query := `query CategoryQuery($id: ID!) { category(id: $id) { id totalProducts topSubcategory { id name } activeSubcategories { id name } } }` + vars := `{"variables":{"id":"cat-1"}}` + + schemaDoc := grpctest.MustGraphQLSchema(t) + queryDoc, report := astparser.ParseGraphqlDocumentString(query) + require.False(t, report.HasErrors(), "failed to parse query: %s", report.Error()) + + compiler, err := NewProtoCompiler(grpctest.MustProtoSchema(t), testMapping()) + require.NoError(t, err) + + ds, err := NewDataSource(conn, DataSourceConfig{ + Operation: &queryDoc, + Definition: &schemaDoc, + SubgraphName: "Products", + Mapping: testMapping(), + Compiler: compiler, + }) + require.NoError(t, err) + + input := fmt.Sprintf(`{"query":%q,"body":%s}`, query, vars) + _, err = ds.Load(context.Background(), nil, []byte(input)) + require.NoError(t, err) + + require.Equal(t, int64(1), spy.categoryCalls.Load(), "QueryCategory must be called once") + require.Zero(t, spy.totalProductsCalls.Load(), "ResolveCategoryTotalProducts must not be called when category is null") + require.Zero(t, spy.topSubcategoryCalls.Load(), "ResolveCategoryTopSubcategory must not be called when category is null") + require.Zero(t, spy.activeSubcategoriesCalls.Load(), "ResolveCategoryActiveSubcategories must not be called when category is null") +} 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 53d5ac176c..193300b409 100644 --- a/v2/pkg/engine/datasource/grpc_datasource/mapping_test_helper.go +++ b/v2/pkg/engine/datasource/grpc_datasource/mapping_test_helper.go @@ -1,5 +1,6 @@ package grpcdatasource +// testMapping returns a hardcoded default mapping between GraphQL and Protobuf func testMapping() *GRPCMapping { return &GRPCMapping{ Service: "Products", @@ -312,6 +313,33 @@ func testMapping() *GRPCMapping { Request: "ResolveCategoryOptionalCategoriesRequest", Response: "ResolveCategoryOptionalCategoriesResponse", }, + "totalProducts": { + FieldMappingData: FieldMapData{ + TargetName: "total_products", + ArgumentMappings: FieldArgumentMap{}, + }, + RPC: "ResolveCategoryTotalProducts", + Request: "ResolveCategoryTotalProductsRequest", + Response: "ResolveCategoryTotalProductsResponse", + }, + "topSubcategory": { + FieldMappingData: FieldMapData{ + TargetName: "top_subcategory", + ArgumentMappings: FieldArgumentMap{}, + }, + RPC: "ResolveCategoryTopSubcategory", + Request: "ResolveCategoryTopSubcategoryRequest", + Response: "ResolveCategoryTopSubcategoryResponse", + }, + "activeSubcategories": { + FieldMappingData: FieldMapData{ + TargetName: "active_subcategories", + ArgumentMappings: FieldArgumentMap{}, + }, + RPC: "ResolveCategoryActiveSubcategories", + Request: "ResolveCategoryActiveSubcategoriesRequest", + Response: "ResolveCategoryActiveSubcategoriesResponse", + }, }, "CategoryMetrics": { "normalizedScore": { @@ -336,6 +364,15 @@ func testMapping() *GRPCMapping { Request: "ResolveCategoryMetricsRelatedCategoryRequest", Response: "ResolveCategoryMetricsRelatedCategoryResponse", }, + "averageScore": { + FieldMappingData: FieldMapData{ + TargetName: "average_score", + ArgumentMappings: FieldArgumentMap{}, + }, + RPC: "ResolveCategoryMetricsAverageScore", + Request: "ResolveCategoryMetricsAverageScoreRequest", + Response: "ResolveCategoryMetricsAverageScoreResponse", + }, }, "Product": { "shippingEstimate": { @@ -452,6 +489,15 @@ func testMapping() *GRPCMapping { Request: "ResolveSubcategoryFeaturedCategoryRequest", Response: "ResolveSubcategoryFeaturedCategoryResponse", }, + "parentCategory": { + FieldMappingData: FieldMapData{ + TargetName: "parent_category", + ArgumentMappings: FieldArgumentMap{}, + }, + RPC: "ResolveSubcategoryParentCategory", + Request: "ResolveSubcategoryParentCategoryRequest", + Response: "ResolveSubcategoryParentCategoryResponse", + }, }, "TestContainer": { "details": { @@ -1253,6 +1299,15 @@ func testMapping() *GRPCMapping { "nullMetrics": { TargetName: "null_metrics", }, + "totalProducts": { + TargetName: "total_products", + }, + "topSubcategory": { + TargetName: "top_subcategory", + }, + "activeSubcategories": { + TargetName: "active_subcategories", + }, }, "Subcategory": { "id": { @@ -1279,6 +1334,9 @@ func testMapping() *GRPCMapping { "includeChildren": "include_children", }, }, + "parentCategory": { + TargetName: "parent_category", + }, }, "CategoryMetrics": { "id": { @@ -1308,6 +1366,9 @@ func testMapping() *GRPCMapping { "include": "include", }, }, + "averageScore": { + TargetName: "average_score", + }, }, "Cat": { "id": { @@ -1820,5 +1881,4 @@ func testMapping() *GRPCMapping { }, }, } - } diff --git a/v2/pkg/grpctest/Makefile b/v2/pkg/grpctest/Makefile index 14e008ef17..bb8fd892b4 100644 --- a/v2/pkg/grpctest/Makefile +++ b/v2/pkg/grpctest/Makefile @@ -1,4 +1,5 @@ mkfile_dir := $(shell dirname $(abspath $(lastword $(MAKEFILE_LIST)))) +grpc_datasource_dir := $(mkfile_dir)/../engine/datasource/grpc_datasource .PHONY: install-protoc install-protoc: @@ -22,9 +23,20 @@ regenerate-proto: rm -f $(mkfile_dir)/testdata/service.proto.lock.json .PHONY: generate-mapping-code -generate-mapping-code: regenerate-proto +generate-mapping-code: cleanup-mapping-file + +.PHONY: generate-mapping-code-grpc-test +generate-mapping-code-grpc-test: regenerate-proto go run $(mkfile_dir)/cmd/mapping_helper/main.go $(mkfile_dir)/testdata/mapping.json $(mkfile_dir)/mapping/mapping.go go fmt $(mkfile_dir)/mapping/mapping.go + +.PHONY: generate-mapping-code-grpc-datasource +generate-mapping-code-grpc-datasource: generate-mapping-code-grpc-test + go run $(mkfile_dir)/cmd/mapping_helper/main.go -grpc-datasource $(mkfile_dir)/testdata/mapping.json $(grpc_datasource_dir)/mapping_test_helper.go + go fmt $(grpc_datasource_dir)/mapping_test_helper.go + +.PHONY: cleanup-mapping-file +cleanup-mapping-file: generate-mapping-code-grpc-datasource rm -f $(mkfile_dir)/testdata/mapping.json @@ -35,9 +47,20 @@ regenerate-proto-local: rm -f $(mkfile_dir)/testdata/service.proto.lock.json .PHONY: generate-mapping-code-local -generate-mapping-code-local: regenerate-proto-local +generate-mapping-code-local: cleanup-mapping-file-local + +.PHONY: generate-mapping-code-grpc-test-local +generate-mapping-code-grpc-test-local: regenerate-proto-local go run $(mkfile_dir)/cmd/mapping_helper/main.go $(mkfile_dir)/testdata/mapping.json $(mkfile_dir)/mapping/mapping.go go fmt $(mkfile_dir)/mapping/mapping.go + +.PHONY: generate-mapping-code-grpc-datasource-local +generate-mapping-code-grpc-datasource-local: generate-mapping-code-grpc-test-local + go run $(mkfile_dir)/cmd/mapping_helper/main.go -grpc-datasource $(mkfile_dir)/testdata/mapping.json $(grpc_datasource_dir)/mapping_test_helper.go + go fmt $(grpc_datasource_dir)/mapping_test_helper.go + +.PHONY: cleanup-mapping-file-local +cleanup-mapping-file-local: generate-mapping-code-grpc-datasource-local rm -f $(mkfile_dir)/testdata/mapping.json diff --git a/v2/pkg/grpctest/cmd/mapping_helper/main.go b/v2/pkg/grpctest/cmd/mapping_helper/main.go index b33cde4aa8..f0a35c50b0 100644 --- a/v2/pkg/grpctest/cmd/mapping_helper/main.go +++ b/v2/pkg/grpctest/cmd/mapping_helper/main.go @@ -6,9 +6,10 @@ import ( "bytes" _ "embed" "encoding/json" + "flag" + "html/template" "log" "os" - "text/template" ) type TemplateData struct { @@ -100,10 +101,21 @@ type EnumValue struct { var ( //go:embed templates/grpctest_mapping.tmpl tpl string + //go:embed templates/grcp_datasource_mapping_helper.tmpl + tplGRPCDatasource string + + grpcDatasource bool ) +// define flags for the command +func init() { + flag.BoolVar(&grpcDatasource, "grpc-datasource", false, "use the grpc_datasource package template") +} + func main() { - args := os.Args[1:] + flag.Parse() + + args := flag.Args() if len(args) < 2 { log.Fatal("No input file or output file provided") } @@ -146,7 +158,12 @@ func main() { data.ResolveRPCs[t] = item } - t := template.Must(template.New("mapping").Parse(tpl)) + var usedTemplate = tpl + if grpcDatasource { + usedTemplate = tplGRPCDatasource + } + + t := template.Must(template.New("mapping").Parse(usedTemplate)) buf := &bytes.Buffer{} if err := t.Execute(buf, data); err != nil { diff --git a/v2/pkg/grpctest/cmd/mapping_helper/templates/grcp_datasource_mapping_helper.tmpl b/v2/pkg/grpctest/cmd/mapping_helper/templates/grcp_datasource_mapping_helper.tmpl new file mode 100644 index 0000000000..67658391a7 --- /dev/null +++ b/v2/pkg/grpctest/cmd/mapping_helper/templates/grcp_datasource_mapping_helper.tmpl @@ -0,0 +1,117 @@ +package grpcdatasource + +// testMapping returns a hardcoded default mapping between GraphQL and Protobuf +func testMapping() *GRPCMapping { + return &GRPCMapping{ + Service: "Products", + QueryRPCs: RPCConfigMap[RPCConfig]{ + {{- range $index, $operation := .OperationMappings}} + {{- if eq $operation.Type "OPERATION_TYPE_QUERY"}} + "{{$operation.Original}}": { + RPC: "{{$operation.Mapped}}", + Request: "{{$operation.Request}}", + Response: "{{$operation.Response}}", + }, + {{- end }} + {{- end }} + }, + MutationRPCs: RPCConfigMap[RPCConfig]{ + {{- range $index, $operation := .OperationMappings}} + {{- if eq $operation.Type "OPERATION_TYPE_MUTATION"}} + "{{$operation.Original}}": { + RPC: "{{$operation.Mapped}}", + Request: "{{$operation.Request}}", + Response: "{{$operation.Response}}", + }, + {{- end }} + {{- end }} + }, + SubscriptionRPCs: RPCConfigMap[RPCConfig]{ + {{- range $index, $operation := .OperationMappings}} + {{- if eq $operation.Type "OPERATION_TYPE_SUBSCRIPTION"}} + "{{$operation.Original}}": { + RPC: "{{$operation.Mapped}}", + Request: "{{$operation.Request}}", + Response: "{{$operation.Response}}", + }, + {{- end }} + {{- end }} + }, + ResolveRPCs: RPCConfigMap[ResolveRPCMapping]{ + {{- range $type, $item := .ResolveRPCs}} + "{{$type}}": { + {{- range $index, $resolve := $item}} + "{{$resolve.LookupMapping.FieldMapping.Original}}": { + FieldMappingData: FieldMapData{ + TargetName: "{{$resolve.LookupMapping.FieldMapping.Mapped}}", + ArgumentMappings: FieldArgumentMap{ + {{- range $index, $argument := $resolve.LookupMapping.FieldMapping.ArgumentMappings}} + "{{$argument.Original}}": "{{$argument.Mapped}}", + {{- end }} + }, + }, + RPC: "{{$resolve.RPC}}", + Request: "{{$resolve.Request}}", + Response: "{{$resolve.Response}}", + }, + {{- end }} + }, + {{- end }} + }, + EntityRPCs: map[string][]EntityRPCConfig{ + {{- range $index, $entity := .EntityMappings}} + "{{$entity.TypeName}}": { + { + Key: "{{$entity.Key}}", + RPCConfig: RPCConfig{ + RPC: "{{$entity.RPC}}", + Request: "{{$entity.Request}}", + Response: "{{$entity.Response}}", + }, + {{- if $entity.RequiredFieldMappings}} + RequiredFields: RequiredFieldsRPCMapping{ + {{- range $idx, $required := $entity.RequiredFieldMappings}} + "{{$required.FieldMapping.Original}}": { + TargetName: "{{$required.FieldMapping.Mapped}}", + RPCConfig: RPCConfig{ + RPC: "{{$required.RPC}}", + Request: "{{$required.Request}}", + Response: "{{$required.Response}}", + }, + }, + {{- end}} + }, + {{- end}} + }, + }, + {{- end }} + }, + EnumValues: map[string][]EnumValueMapping{ + {{- range $index, $enum := .EnumMappings}} + "{{$enum.Type}}": { + {{- range $index, $value := .Values}} + {Value: "{{$value.Original}}", TargetValue: "{{$value.Mapped}}"}, + {{- end }} + }, + {{- end }} + }, + Fields: map[string]FieldMap{ + {{- range $index, $typeField := .TypeFieldMappings}} + "{{$typeField.Type}}": { + {{- range $index, $field := $typeField.FieldMappings}} + "{{$field.Original}}": { + TargetName: "{{$field.Mapped}}", + {{- if (gt (len $field.ArgumentMappings) 0)}} + ArgumentMappings: FieldArgumentMap{ + {{- range $index, $argument := $field.ArgumentMappings}} + "{{$argument.Original}}": "{{$argument.Mapped}}", + {{- end }} + }, + {{- end }} + }, + {{- end}} + }, + {{- end}} + }, + } +} diff --git a/v2/pkg/grpctest/mapping/mapping.go b/v2/pkg/grpctest/mapping/mapping.go index 1ded5e95cb..ac6d402522 100644 --- a/v2/pkg/grpctest/mapping/mapping.go +++ b/v2/pkg/grpctest/mapping/mapping.go @@ -319,6 +319,33 @@ func DefaultGRPCMapping() *grpcdatasource.GRPCMapping { Request: "ResolveCategoryOptionalCategoriesRequest", Response: "ResolveCategoryOptionalCategoriesResponse", }, + "totalProducts": { + FieldMappingData: grpcdatasource.FieldMapData{ + TargetName: "total_products", + ArgumentMappings: grpcdatasource.FieldArgumentMap{}, + }, + RPC: "ResolveCategoryTotalProducts", + Request: "ResolveCategoryTotalProductsRequest", + Response: "ResolveCategoryTotalProductsResponse", + }, + "topSubcategory": { + FieldMappingData: grpcdatasource.FieldMapData{ + TargetName: "top_subcategory", + ArgumentMappings: grpcdatasource.FieldArgumentMap{}, + }, + RPC: "ResolveCategoryTopSubcategory", + Request: "ResolveCategoryTopSubcategoryRequest", + Response: "ResolveCategoryTopSubcategoryResponse", + }, + "activeSubcategories": { + FieldMappingData: grpcdatasource.FieldMapData{ + TargetName: "active_subcategories", + ArgumentMappings: grpcdatasource.FieldArgumentMap{}, + }, + RPC: "ResolveCategoryActiveSubcategories", + Request: "ResolveCategoryActiveSubcategoriesRequest", + Response: "ResolveCategoryActiveSubcategoriesResponse", + }, }, "CategoryMetrics": { "normalizedScore": { @@ -343,6 +370,15 @@ func DefaultGRPCMapping() *grpcdatasource.GRPCMapping { Request: "ResolveCategoryMetricsRelatedCategoryRequest", Response: "ResolveCategoryMetricsRelatedCategoryResponse", }, + "averageScore": { + FieldMappingData: grpcdatasource.FieldMapData{ + TargetName: "average_score", + ArgumentMappings: grpcdatasource.FieldArgumentMap{}, + }, + RPC: "ResolveCategoryMetricsAverageScore", + Request: "ResolveCategoryMetricsAverageScoreRequest", + Response: "ResolveCategoryMetricsAverageScoreResponse", + }, }, "Product": { "shippingEstimate": { @@ -459,6 +495,15 @@ func DefaultGRPCMapping() *grpcdatasource.GRPCMapping { Request: "ResolveSubcategoryFeaturedCategoryRequest", Response: "ResolveSubcategoryFeaturedCategoryResponse", }, + "parentCategory": { + FieldMappingData: grpcdatasource.FieldMapData{ + TargetName: "parent_category", + ArgumentMappings: grpcdatasource.FieldArgumentMap{}, + }, + RPC: "ResolveSubcategoryParentCategory", + Request: "ResolveSubcategoryParentCategoryRequest", + Response: "ResolveSubcategoryParentCategoryResponse", + }, }, "TestContainer": { "details": { @@ -1260,6 +1305,15 @@ func DefaultGRPCMapping() *grpcdatasource.GRPCMapping { "nullMetrics": { TargetName: "null_metrics", }, + "totalProducts": { + TargetName: "total_products", + }, + "topSubcategory": { + TargetName: "top_subcategory", + }, + "activeSubcategories": { + TargetName: "active_subcategories", + }, }, "Subcategory": { "id": { @@ -1286,6 +1340,9 @@ func DefaultGRPCMapping() *grpcdatasource.GRPCMapping { "includeChildren": "include_children", }, }, + "parentCategory": { + TargetName: "parent_category", + }, }, "CategoryMetrics": { "id": { @@ -1315,6 +1372,9 @@ func DefaultGRPCMapping() *grpcdatasource.GRPCMapping { "include": "include", }, }, + "averageScore": { + TargetName: "average_score", + }, }, "Cat": { "id": { diff --git a/v2/pkg/grpctest/mockservice_resolve.go b/v2/pkg/grpctest/mockservice_resolve.go index 8cc6a0ea76..750cbbd338 100644 --- a/v2/pkg/grpctest/mockservice_resolve.go +++ b/v2/pkg/grpctest/mockservice_resolve.go @@ -1008,3 +1008,110 @@ func (s *MockService) ResolveStorageNearbyStorages(_ context.Context, req *produ Result: results, }, nil } + +// ResolveCategoryTotalProducts implements productv1.ProductServiceServer. +func (s *MockService) ResolveCategoryTotalProducts(_ context.Context, req *productv1.ResolveCategoryTotalProductsRequest) (*productv1.ResolveCategoryTotalProductsResponse, error) { + results := make([]*productv1.ResolveCategoryTotalProductsResult, 0, len(req.GetContext())) + + for i, ctx := range req.GetContext() { + _ = ctx + results = append(results, &productv1.ResolveCategoryTotalProductsResult{ + TotalProducts: int32((i + 1) * 42), + }) + } + + return &productv1.ResolveCategoryTotalProductsResponse{ + Result: results, + }, nil +} + +// ResolveCategoryTopSubcategory implements productv1.ProductServiceServer. +func (s *MockService) ResolveCategoryTopSubcategory(_ context.Context, req *productv1.ResolveCategoryTopSubcategoryRequest) (*productv1.ResolveCategoryTopSubcategoryResponse, error) { + results := make([]*productv1.ResolveCategoryTopSubcategoryResult, 0, len(req.GetContext())) + + for i, ctx := range req.GetContext() { + // Return nil for every other context to test nullable handling + var subcategory *productv1.Subcategory + if i%2 == 0 { + subcategory = &productv1.Subcategory{ + Id: fmt.Sprintf("top-sub-%s-%d", ctx.GetId(), i), + Name: fmt.Sprintf("Top Subcategory for %s", ctx.GetName()), + Description: wrapperspb.String(fmt.Sprintf("Top subcategory of %s", ctx.GetName())), + IsActive: true, + } + } + results = append(results, &productv1.ResolveCategoryTopSubcategoryResult{ + TopSubcategory: subcategory, + }) + } + + return &productv1.ResolveCategoryTopSubcategoryResponse{ + Result: results, + }, nil +} + +// ResolveCategoryActiveSubcategories implements productv1.ProductServiceServer. +func (s *MockService) ResolveCategoryActiveSubcategories(_ context.Context, req *productv1.ResolveCategoryActiveSubcategoriesRequest) (*productv1.ResolveCategoryActiveSubcategoriesResponse, error) { + results := make([]*productv1.ResolveCategoryActiveSubcategoriesResult, 0, len(req.GetContext())) + + for i, ctx := range req.GetContext() { + results = append(results, &productv1.ResolveCategoryActiveSubcategoriesResult{ + ActiveSubcategories: []*productv1.Subcategory{ + { + Id: fmt.Sprintf("active-sub-%s-%d-0", ctx.GetId(), i), + Name: fmt.Sprintf("Active Sub 0 for %s", ctx.GetId()), + IsActive: true, + }, + { + Id: fmt.Sprintf("active-sub-%s-%d-1", ctx.GetId(), i), + Name: fmt.Sprintf("Active Sub 1 for %s", ctx.GetId()), + IsActive: true, + }, + }, + }) + } + + return &productv1.ResolveCategoryActiveSubcategoriesResponse{ + Result: results, + }, nil +} + +// ResolveSubcategoryParentCategory implements productv1.ProductServiceServer. +func (s *MockService) ResolveSubcategoryParentCategory(_ context.Context, req *productv1.ResolveSubcategoryParentCategoryRequest) (*productv1.ResolveSubcategoryParentCategoryResponse, error) { + results := make([]*productv1.ResolveSubcategoryParentCategoryResult, 0, len(req.GetContext())) + + for i, ctx := range req.GetContext() { + // Return nil for every other context to test nullable handling + var category *productv1.Category + if i%2 == 0 { + category = &productv1.Category{ + Id: fmt.Sprintf("parent-cat-%s-%d", ctx.GetId(), i), + Name: fmt.Sprintf("Parent Category for %s", ctx.GetId()), + Kind: productv1.CategoryKind_CATEGORY_KIND_BOOK, + } + } + results = append(results, &productv1.ResolveSubcategoryParentCategoryResult{ + ParentCategory: category, + }) + } + + return &productv1.ResolveSubcategoryParentCategoryResponse{ + Result: results, + }, nil +} + +// ResolveCategoryMetricsAverageScore implements productv1.ProductServiceServer. +func (s *MockService) ResolveCategoryMetricsAverageScore(_ context.Context, req *productv1.ResolveCategoryMetricsAverageScoreRequest) (*productv1.ResolveCategoryMetricsAverageScoreResponse, error) { + results := make([]*productv1.ResolveCategoryMetricsAverageScoreResult, 0, len(req.GetContext())) + + for i, ctx := range req.GetContext() { + _ = ctx + results = append(results, &productv1.ResolveCategoryMetricsAverageScoreResult{ + AverageScore: float64(i+1) * 3.14, + }) + } + + return &productv1.ResolveCategoryMetricsAverageScoreResponse{ + Result: results, + }, nil +} diff --git a/v2/pkg/grpctest/product.proto b/v2/pkg/grpctest/product.proto index 11cb569d6e..61fcfaf857 100644 --- a/v2/pkg/grpctest/product.proto +++ b/v2/pkg/grpctest/product.proto @@ -70,15 +70,19 @@ service ProductService { rpc RequireStorageStockHealthScoreById(RequireStorageStockHealthScoreByIdRequest) returns (RequireStorageStockHealthScoreByIdResponse) {} rpc RequireStorageTagSummaryById(RequireStorageTagSummaryByIdRequest) returns (RequireStorageTagSummaryByIdResponse) {} rpc RequireWarehouseStockHealthScoreById(RequireWarehouseStockHealthScoreByIdRequest) returns (RequireWarehouseStockHealthScoreByIdResponse) {} + rpc ResolveCategoryActiveSubcategories(ResolveCategoryActiveSubcategoriesRequest) returns (ResolveCategoryActiveSubcategoriesResponse) {} rpc ResolveCategoryCategoryMetrics(ResolveCategoryCategoryMetricsRequest) returns (ResolveCategoryCategoryMetricsResponse) {} rpc ResolveCategoryCategoryStatus(ResolveCategoryCategoryStatusRequest) returns (ResolveCategoryCategoryStatusResponse) {} rpc ResolveCategoryChildCategories(ResolveCategoryChildCategoriesRequest) returns (ResolveCategoryChildCategoriesResponse) {} rpc ResolveCategoryMascot(ResolveCategoryMascotRequest) returns (ResolveCategoryMascotResponse) {} + rpc ResolveCategoryMetricsAverageScore(ResolveCategoryMetricsAverageScoreRequest) returns (ResolveCategoryMetricsAverageScoreResponse) {} rpc ResolveCategoryMetricsNormalizedScore(ResolveCategoryMetricsNormalizedScoreRequest) returns (ResolveCategoryMetricsNormalizedScoreResponse) {} rpc ResolveCategoryMetricsRelatedCategory(ResolveCategoryMetricsRelatedCategoryRequest) returns (ResolveCategoryMetricsRelatedCategoryResponse) {} rpc ResolveCategoryOptionalCategories(ResolveCategoryOptionalCategoriesRequest) returns (ResolveCategoryOptionalCategoriesResponse) {} rpc ResolveCategoryPopularityScore(ResolveCategoryPopularityScoreRequest) returns (ResolveCategoryPopularityScoreResponse) {} rpc ResolveCategoryProductCount(ResolveCategoryProductCountRequest) returns (ResolveCategoryProductCountResponse) {} + rpc ResolveCategoryTopSubcategory(ResolveCategoryTopSubcategoryRequest) returns (ResolveCategoryTopSubcategoryResponse) {} + rpc ResolveCategoryTotalProducts(ResolveCategoryTotalProductsRequest) returns (ResolveCategoryTotalProductsResponse) {} rpc ResolveProductMascotRecommendation(ResolveProductMascotRecommendationRequest) returns (ResolveProductMascotRecommendationResponse) {} rpc ResolveProductProductDetails(ResolveProductProductDetailsRequest) returns (ResolveProductProductDetailsResponse) {} rpc ResolveProductRecommendedCategory(ResolveProductRecommendedCategoryRequest) returns (ResolveProductRecommendedCategoryResponse) {} @@ -89,6 +93,7 @@ service ProductService { rpc ResolveStorageStorageStatus(ResolveStorageStorageStatusRequest) returns (ResolveStorageStorageStatusResponse) {} rpc ResolveSubcategoryFeaturedCategory(ResolveSubcategoryFeaturedCategoryRequest) returns (ResolveSubcategoryFeaturedCategoryResponse) {} rpc ResolveSubcategoryItemCount(ResolveSubcategoryItemCountRequest) returns (ResolveSubcategoryItemCountResponse) {} + rpc ResolveSubcategoryParentCategory(ResolveSubcategoryParentCategoryRequest) returns (ResolveSubcategoryParentCategoryResponse) {} rpc ResolveTestContainerDetails(ResolveTestContainerDetailsRequest) returns (ResolveTestContainerDetailsResponse) {} } @@ -1054,6 +1059,58 @@ message ResolveCategoryOptionalCategoriesResponse { repeated ResolveCategoryOptionalCategoriesResult result = 1; } +message ResolveCategoryTotalProductsContext { + string id = 1; +} + +message ResolveCategoryTotalProductsRequest { + // context provides the resolver context for the field totalProducts of type Category. + repeated ResolveCategoryTotalProductsContext context = 1; +} + +message ResolveCategoryTotalProductsResult { + int32 total_products = 1; +} + +message ResolveCategoryTotalProductsResponse { + repeated ResolveCategoryTotalProductsResult result = 1; +} + +message ResolveCategoryTopSubcategoryContext { + string id = 1; + string name = 2; +} + +message ResolveCategoryTopSubcategoryRequest { + // context provides the resolver context for the field topSubcategory of type Category. + repeated ResolveCategoryTopSubcategoryContext context = 1; +} + +message ResolveCategoryTopSubcategoryResult { + Subcategory top_subcategory = 1; +} + +message ResolveCategoryTopSubcategoryResponse { + repeated ResolveCategoryTopSubcategoryResult result = 1; +} + +message ResolveCategoryActiveSubcategoriesContext { + string id = 1; +} + +message ResolveCategoryActiveSubcategoriesRequest { + // context provides the resolver context for the field activeSubcategories of type Category. + repeated ResolveCategoryActiveSubcategoriesContext context = 1; +} + +message ResolveCategoryActiveSubcategoriesResult { + repeated Subcategory active_subcategories = 1; +} + +message ResolveCategoryActiveSubcategoriesResponse { + repeated ResolveCategoryActiveSubcategoriesResult result = 1; +} + message ResolveSubcategoryItemCountArgs { SubcategoryItemFilter filters = 1; } @@ -1100,6 +1157,23 @@ message ResolveSubcategoryFeaturedCategoryResponse { repeated ResolveSubcategoryFeaturedCategoryResult result = 1; } +message ResolveSubcategoryParentCategoryContext { + string id = 1; +} + +message ResolveSubcategoryParentCategoryRequest { + // context provides the resolver context for the field parentCategory of type Subcategory. + repeated ResolveSubcategoryParentCategoryContext context = 1; +} + +message ResolveSubcategoryParentCategoryResult { + Category parent_category = 1; +} + +message ResolveSubcategoryParentCategoryResponse { + repeated ResolveSubcategoryParentCategoryResult result = 1; +} + message ResolveCategoryMetricsNormalizedScoreArgs { double baseline = 1; } @@ -1148,6 +1222,24 @@ message ResolveCategoryMetricsRelatedCategoryResponse { repeated ResolveCategoryMetricsRelatedCategoryResult result = 1; } +message ResolveCategoryMetricsAverageScoreContext { + string id = 1; + string metric_type = 2; +} + +message ResolveCategoryMetricsAverageScoreRequest { + // context provides the resolver context for the field averageScore of type CategoryMetrics. + repeated ResolveCategoryMetricsAverageScoreContext context = 1; +} + +message ResolveCategoryMetricsAverageScoreResult { + double average_score = 1; +} + +message ResolveCategoryMetricsAverageScoreResponse { + repeated ResolveCategoryMetricsAverageScoreResult result = 1; +} + message ResolveTestContainerDetailsArgs { bool include_extended = 1; } diff --git a/v2/pkg/grpctest/productv1/product.pb.go b/v2/pkg/grpctest/productv1/product.pb.go index 2969c86e3f..d7dbf11daf 100644 --- a/v2/pkg/grpctest/productv1/product.pb.go +++ b/v2/pkg/grpctest/productv1/product.pb.go @@ -9091,6 +9091,545 @@ func (x *ResolveCategoryOptionalCategoriesResponse) GetResult() []*ResolveCatego return nil } +type ResolveCategoryTotalProductsContext struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryTotalProductsContext) Reset() { + *x = ResolveCategoryTotalProductsContext{} + mi := &file_product_proto_msgTypes[195] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryTotalProductsContext) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryTotalProductsContext) ProtoMessage() {} + +func (x *ResolveCategoryTotalProductsContext) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[195] + 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 ResolveCategoryTotalProductsContext.ProtoReflect.Descriptor instead. +func (*ResolveCategoryTotalProductsContext) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{195} +} + +func (x *ResolveCategoryTotalProductsContext) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +type ResolveCategoryTotalProductsRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // context provides the resolver context for the field totalProducts of type Category. + Context []*ResolveCategoryTotalProductsContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryTotalProductsRequest) Reset() { + *x = ResolveCategoryTotalProductsRequest{} + mi := &file_product_proto_msgTypes[196] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryTotalProductsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryTotalProductsRequest) ProtoMessage() {} + +func (x *ResolveCategoryTotalProductsRequest) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[196] + 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 ResolveCategoryTotalProductsRequest.ProtoReflect.Descriptor instead. +func (*ResolveCategoryTotalProductsRequest) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{196} +} + +func (x *ResolveCategoryTotalProductsRequest) GetContext() []*ResolveCategoryTotalProductsContext { + if x != nil { + return x.Context + } + return nil +} + +type ResolveCategoryTotalProductsResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + TotalProducts int32 `protobuf:"varint,1,opt,name=total_products,json=totalProducts,proto3" json:"total_products,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryTotalProductsResult) Reset() { + *x = ResolveCategoryTotalProductsResult{} + mi := &file_product_proto_msgTypes[197] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryTotalProductsResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryTotalProductsResult) ProtoMessage() {} + +func (x *ResolveCategoryTotalProductsResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[197] + 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 ResolveCategoryTotalProductsResult.ProtoReflect.Descriptor instead. +func (*ResolveCategoryTotalProductsResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{197} +} + +func (x *ResolveCategoryTotalProductsResult) GetTotalProducts() int32 { + if x != nil { + return x.TotalProducts + } + return 0 +} + +type ResolveCategoryTotalProductsResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Result []*ResolveCategoryTotalProductsResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryTotalProductsResponse) Reset() { + *x = ResolveCategoryTotalProductsResponse{} + mi := &file_product_proto_msgTypes[198] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryTotalProductsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryTotalProductsResponse) ProtoMessage() {} + +func (x *ResolveCategoryTotalProductsResponse) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[198] + 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 ResolveCategoryTotalProductsResponse.ProtoReflect.Descriptor instead. +func (*ResolveCategoryTotalProductsResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{198} +} + +func (x *ResolveCategoryTotalProductsResponse) GetResult() []*ResolveCategoryTotalProductsResult { + if x != nil { + return x.Result + } + return nil +} + +type ResolveCategoryTopSubcategoryContext 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 *ResolveCategoryTopSubcategoryContext) Reset() { + *x = ResolveCategoryTopSubcategoryContext{} + mi := &file_product_proto_msgTypes[199] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryTopSubcategoryContext) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryTopSubcategoryContext) ProtoMessage() {} + +func (x *ResolveCategoryTopSubcategoryContext) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[199] + 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 ResolveCategoryTopSubcategoryContext.ProtoReflect.Descriptor instead. +func (*ResolveCategoryTopSubcategoryContext) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{199} +} + +func (x *ResolveCategoryTopSubcategoryContext) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *ResolveCategoryTopSubcategoryContext) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +type ResolveCategoryTopSubcategoryRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // context provides the resolver context for the field topSubcategory of type Category. + Context []*ResolveCategoryTopSubcategoryContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryTopSubcategoryRequest) Reset() { + *x = ResolveCategoryTopSubcategoryRequest{} + mi := &file_product_proto_msgTypes[200] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryTopSubcategoryRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryTopSubcategoryRequest) ProtoMessage() {} + +func (x *ResolveCategoryTopSubcategoryRequest) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[200] + 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 ResolveCategoryTopSubcategoryRequest.ProtoReflect.Descriptor instead. +func (*ResolveCategoryTopSubcategoryRequest) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{200} +} + +func (x *ResolveCategoryTopSubcategoryRequest) GetContext() []*ResolveCategoryTopSubcategoryContext { + if x != nil { + return x.Context + } + return nil +} + +type ResolveCategoryTopSubcategoryResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + TopSubcategory *Subcategory `protobuf:"bytes,1,opt,name=top_subcategory,json=topSubcategory,proto3" json:"top_subcategory,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryTopSubcategoryResult) Reset() { + *x = ResolveCategoryTopSubcategoryResult{} + mi := &file_product_proto_msgTypes[201] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryTopSubcategoryResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryTopSubcategoryResult) ProtoMessage() {} + +func (x *ResolveCategoryTopSubcategoryResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[201] + 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 ResolveCategoryTopSubcategoryResult.ProtoReflect.Descriptor instead. +func (*ResolveCategoryTopSubcategoryResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{201} +} + +func (x *ResolveCategoryTopSubcategoryResult) GetTopSubcategory() *Subcategory { + if x != nil { + return x.TopSubcategory + } + return nil +} + +type ResolveCategoryTopSubcategoryResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Result []*ResolveCategoryTopSubcategoryResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryTopSubcategoryResponse) Reset() { + *x = ResolveCategoryTopSubcategoryResponse{} + mi := &file_product_proto_msgTypes[202] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryTopSubcategoryResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryTopSubcategoryResponse) ProtoMessage() {} + +func (x *ResolveCategoryTopSubcategoryResponse) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[202] + 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 ResolveCategoryTopSubcategoryResponse.ProtoReflect.Descriptor instead. +func (*ResolveCategoryTopSubcategoryResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{202} +} + +func (x *ResolveCategoryTopSubcategoryResponse) GetResult() []*ResolveCategoryTopSubcategoryResult { + if x != nil { + return x.Result + } + return nil +} + +type ResolveCategoryActiveSubcategoriesContext struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryActiveSubcategoriesContext) Reset() { + *x = ResolveCategoryActiveSubcategoriesContext{} + mi := &file_product_proto_msgTypes[203] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryActiveSubcategoriesContext) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryActiveSubcategoriesContext) ProtoMessage() {} + +func (x *ResolveCategoryActiveSubcategoriesContext) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[203] + 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 ResolveCategoryActiveSubcategoriesContext.ProtoReflect.Descriptor instead. +func (*ResolveCategoryActiveSubcategoriesContext) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{203} +} + +func (x *ResolveCategoryActiveSubcategoriesContext) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +type ResolveCategoryActiveSubcategoriesRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // context provides the resolver context for the field activeSubcategories of type Category. + Context []*ResolveCategoryActiveSubcategoriesContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryActiveSubcategoriesRequest) Reset() { + *x = ResolveCategoryActiveSubcategoriesRequest{} + mi := &file_product_proto_msgTypes[204] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryActiveSubcategoriesRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryActiveSubcategoriesRequest) ProtoMessage() {} + +func (x *ResolveCategoryActiveSubcategoriesRequest) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[204] + 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 ResolveCategoryActiveSubcategoriesRequest.ProtoReflect.Descriptor instead. +func (*ResolveCategoryActiveSubcategoriesRequest) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{204} +} + +func (x *ResolveCategoryActiveSubcategoriesRequest) GetContext() []*ResolveCategoryActiveSubcategoriesContext { + if x != nil { + return x.Context + } + return nil +} + +type ResolveCategoryActiveSubcategoriesResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + ActiveSubcategories []*Subcategory `protobuf:"bytes,1,rep,name=active_subcategories,json=activeSubcategories,proto3" json:"active_subcategories,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryActiveSubcategoriesResult) Reset() { + *x = ResolveCategoryActiveSubcategoriesResult{} + mi := &file_product_proto_msgTypes[205] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryActiveSubcategoriesResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryActiveSubcategoriesResult) ProtoMessage() {} + +func (x *ResolveCategoryActiveSubcategoriesResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[205] + 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 ResolveCategoryActiveSubcategoriesResult.ProtoReflect.Descriptor instead. +func (*ResolveCategoryActiveSubcategoriesResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{205} +} + +func (x *ResolveCategoryActiveSubcategoriesResult) GetActiveSubcategories() []*Subcategory { + if x != nil { + return x.ActiveSubcategories + } + return nil +} + +type ResolveCategoryActiveSubcategoriesResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Result []*ResolveCategoryActiveSubcategoriesResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryActiveSubcategoriesResponse) Reset() { + *x = ResolveCategoryActiveSubcategoriesResponse{} + mi := &file_product_proto_msgTypes[206] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryActiveSubcategoriesResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryActiveSubcategoriesResponse) ProtoMessage() {} + +func (x *ResolveCategoryActiveSubcategoriesResponse) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[206] + 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 ResolveCategoryActiveSubcategoriesResponse.ProtoReflect.Descriptor instead. +func (*ResolveCategoryActiveSubcategoriesResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{206} +} + +func (x *ResolveCategoryActiveSubcategoriesResponse) GetResult() []*ResolveCategoryActiveSubcategoriesResult { + if x != nil { + return x.Result + } + return nil +} + type ResolveSubcategoryItemCountArgs struct { state protoimpl.MessageState `protogen:"open.v1"` Filters *SubcategoryItemFilter `protobuf:"bytes,1,opt,name=filters,proto3" json:"filters,omitempty"` @@ -9100,7 +9639,7 @@ type ResolveSubcategoryItemCountArgs struct { func (x *ResolveSubcategoryItemCountArgs) Reset() { *x = ResolveSubcategoryItemCountArgs{} - mi := &file_product_proto_msgTypes[195] + mi := &file_product_proto_msgTypes[207] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9112,7 +9651,7 @@ func (x *ResolveSubcategoryItemCountArgs) String() string { func (*ResolveSubcategoryItemCountArgs) ProtoMessage() {} func (x *ResolveSubcategoryItemCountArgs) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[195] + mi := &file_product_proto_msgTypes[207] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9125,7 +9664,7 @@ func (x *ResolveSubcategoryItemCountArgs) ProtoReflect() protoreflect.Message { // Deprecated: Use ResolveSubcategoryItemCountArgs.ProtoReflect.Descriptor instead. func (*ResolveSubcategoryItemCountArgs) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{195} + return file_product_proto_rawDescGZIP(), []int{207} } func (x *ResolveSubcategoryItemCountArgs) GetFilters() *SubcategoryItemFilter { @@ -9144,7 +9683,7 @@ type ResolveSubcategoryItemCountContext struct { func (x *ResolveSubcategoryItemCountContext) Reset() { *x = ResolveSubcategoryItemCountContext{} - mi := &file_product_proto_msgTypes[196] + mi := &file_product_proto_msgTypes[208] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9156,7 +9695,7 @@ func (x *ResolveSubcategoryItemCountContext) String() string { func (*ResolveSubcategoryItemCountContext) ProtoMessage() {} func (x *ResolveSubcategoryItemCountContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[196] + mi := &file_product_proto_msgTypes[208] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9169,7 +9708,7 @@ func (x *ResolveSubcategoryItemCountContext) ProtoReflect() protoreflect.Message // Deprecated: Use ResolveSubcategoryItemCountContext.ProtoReflect.Descriptor instead. func (*ResolveSubcategoryItemCountContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{196} + return file_product_proto_rawDescGZIP(), []int{208} } func (x *ResolveSubcategoryItemCountContext) GetId() string { @@ -9191,7 +9730,7 @@ type ResolveSubcategoryItemCountRequest struct { func (x *ResolveSubcategoryItemCountRequest) Reset() { *x = ResolveSubcategoryItemCountRequest{} - mi := &file_product_proto_msgTypes[197] + mi := &file_product_proto_msgTypes[209] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9203,7 +9742,7 @@ func (x *ResolveSubcategoryItemCountRequest) String() string { func (*ResolveSubcategoryItemCountRequest) ProtoMessage() {} func (x *ResolveSubcategoryItemCountRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[197] + mi := &file_product_proto_msgTypes[209] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9216,7 +9755,7 @@ func (x *ResolveSubcategoryItemCountRequest) ProtoReflect() protoreflect.Message // Deprecated: Use ResolveSubcategoryItemCountRequest.ProtoReflect.Descriptor instead. func (*ResolveSubcategoryItemCountRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{197} + return file_product_proto_rawDescGZIP(), []int{209} } func (x *ResolveSubcategoryItemCountRequest) GetContext() []*ResolveSubcategoryItemCountContext { @@ -9242,7 +9781,7 @@ type ResolveSubcategoryItemCountResult struct { func (x *ResolveSubcategoryItemCountResult) Reset() { *x = ResolveSubcategoryItemCountResult{} - mi := &file_product_proto_msgTypes[198] + mi := &file_product_proto_msgTypes[210] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9254,7 +9793,7 @@ func (x *ResolveSubcategoryItemCountResult) String() string { func (*ResolveSubcategoryItemCountResult) ProtoMessage() {} func (x *ResolveSubcategoryItemCountResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[198] + mi := &file_product_proto_msgTypes[210] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9267,7 +9806,7 @@ func (x *ResolveSubcategoryItemCountResult) ProtoReflect() protoreflect.Message // Deprecated: Use ResolveSubcategoryItemCountResult.ProtoReflect.Descriptor instead. func (*ResolveSubcategoryItemCountResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{198} + return file_product_proto_rawDescGZIP(), []int{210} } func (x *ResolveSubcategoryItemCountResult) GetItemCount() int32 { @@ -9286,7 +9825,7 @@ type ResolveSubcategoryItemCountResponse struct { func (x *ResolveSubcategoryItemCountResponse) Reset() { *x = ResolveSubcategoryItemCountResponse{} - mi := &file_product_proto_msgTypes[199] + mi := &file_product_proto_msgTypes[211] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9298,7 +9837,7 @@ func (x *ResolveSubcategoryItemCountResponse) String() string { func (*ResolveSubcategoryItemCountResponse) ProtoMessage() {} func (x *ResolveSubcategoryItemCountResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[199] + mi := &file_product_proto_msgTypes[211] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9311,7 +9850,7 @@ func (x *ResolveSubcategoryItemCountResponse) ProtoReflect() protoreflect.Messag // Deprecated: Use ResolveSubcategoryItemCountResponse.ProtoReflect.Descriptor instead. func (*ResolveSubcategoryItemCountResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{199} + return file_product_proto_rawDescGZIP(), []int{211} } func (x *ResolveSubcategoryItemCountResponse) GetResult() []*ResolveSubcategoryItemCountResult { @@ -9330,7 +9869,7 @@ type ResolveSubcategoryFeaturedCategoryArgs struct { func (x *ResolveSubcategoryFeaturedCategoryArgs) Reset() { *x = ResolveSubcategoryFeaturedCategoryArgs{} - mi := &file_product_proto_msgTypes[200] + mi := &file_product_proto_msgTypes[212] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9342,7 +9881,7 @@ func (x *ResolveSubcategoryFeaturedCategoryArgs) String() string { func (*ResolveSubcategoryFeaturedCategoryArgs) ProtoMessage() {} func (x *ResolveSubcategoryFeaturedCategoryArgs) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[200] + mi := &file_product_proto_msgTypes[212] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9355,7 +9894,7 @@ func (x *ResolveSubcategoryFeaturedCategoryArgs) ProtoReflect() protoreflect.Mes // Deprecated: Use ResolveSubcategoryFeaturedCategoryArgs.ProtoReflect.Descriptor instead. func (*ResolveSubcategoryFeaturedCategoryArgs) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{200} + return file_product_proto_rawDescGZIP(), []int{212} } func (x *ResolveSubcategoryFeaturedCategoryArgs) GetIncludeChildren() bool { @@ -9374,7 +9913,7 @@ type ResolveSubcategoryFeaturedCategoryContext struct { func (x *ResolveSubcategoryFeaturedCategoryContext) Reset() { *x = ResolveSubcategoryFeaturedCategoryContext{} - mi := &file_product_proto_msgTypes[201] + mi := &file_product_proto_msgTypes[213] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9386,7 +9925,7 @@ func (x *ResolveSubcategoryFeaturedCategoryContext) String() string { func (*ResolveSubcategoryFeaturedCategoryContext) ProtoMessage() {} func (x *ResolveSubcategoryFeaturedCategoryContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[201] + mi := &file_product_proto_msgTypes[213] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9399,7 +9938,7 @@ func (x *ResolveSubcategoryFeaturedCategoryContext) ProtoReflect() protoreflect. // Deprecated: Use ResolveSubcategoryFeaturedCategoryContext.ProtoReflect.Descriptor instead. func (*ResolveSubcategoryFeaturedCategoryContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{201} + return file_product_proto_rawDescGZIP(), []int{213} } func (x *ResolveSubcategoryFeaturedCategoryContext) GetId() string { @@ -9421,7 +9960,7 @@ type ResolveSubcategoryFeaturedCategoryRequest struct { func (x *ResolveSubcategoryFeaturedCategoryRequest) Reset() { *x = ResolveSubcategoryFeaturedCategoryRequest{} - mi := &file_product_proto_msgTypes[202] + mi := &file_product_proto_msgTypes[214] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9433,7 +9972,7 @@ func (x *ResolveSubcategoryFeaturedCategoryRequest) String() string { func (*ResolveSubcategoryFeaturedCategoryRequest) ProtoMessage() {} func (x *ResolveSubcategoryFeaturedCategoryRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[202] + mi := &file_product_proto_msgTypes[214] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9446,7 +9985,7 @@ func (x *ResolveSubcategoryFeaturedCategoryRequest) ProtoReflect() protoreflect. // Deprecated: Use ResolveSubcategoryFeaturedCategoryRequest.ProtoReflect.Descriptor instead. func (*ResolveSubcategoryFeaturedCategoryRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{202} + return file_product_proto_rawDescGZIP(), []int{214} } func (x *ResolveSubcategoryFeaturedCategoryRequest) GetContext() []*ResolveSubcategoryFeaturedCategoryContext { @@ -9472,19 +10011,196 @@ type ResolveSubcategoryFeaturedCategoryResult struct { func (x *ResolveSubcategoryFeaturedCategoryResult) Reset() { *x = ResolveSubcategoryFeaturedCategoryResult{} - mi := &file_product_proto_msgTypes[203] + mi := &file_product_proto_msgTypes[215] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveSubcategoryFeaturedCategoryResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveSubcategoryFeaturedCategoryResult) ProtoMessage() {} + +func (x *ResolveSubcategoryFeaturedCategoryResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[215] + 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 ResolveSubcategoryFeaturedCategoryResult.ProtoReflect.Descriptor instead. +func (*ResolveSubcategoryFeaturedCategoryResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{215} +} + +func (x *ResolveSubcategoryFeaturedCategoryResult) GetFeaturedCategory() *Category { + if x != nil { + return x.FeaturedCategory + } + return nil +} + +type ResolveSubcategoryFeaturedCategoryResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Result []*ResolveSubcategoryFeaturedCategoryResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveSubcategoryFeaturedCategoryResponse) Reset() { + *x = ResolveSubcategoryFeaturedCategoryResponse{} + mi := &file_product_proto_msgTypes[216] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveSubcategoryFeaturedCategoryResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveSubcategoryFeaturedCategoryResponse) ProtoMessage() {} + +func (x *ResolveSubcategoryFeaturedCategoryResponse) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[216] + 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 ResolveSubcategoryFeaturedCategoryResponse.ProtoReflect.Descriptor instead. +func (*ResolveSubcategoryFeaturedCategoryResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{216} +} + +func (x *ResolveSubcategoryFeaturedCategoryResponse) GetResult() []*ResolveSubcategoryFeaturedCategoryResult { + if x != nil { + return x.Result + } + return nil +} + +type ResolveSubcategoryParentCategoryContext struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveSubcategoryParentCategoryContext) Reset() { + *x = ResolveSubcategoryParentCategoryContext{} + mi := &file_product_proto_msgTypes[217] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveSubcategoryParentCategoryContext) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveSubcategoryParentCategoryContext) ProtoMessage() {} + +func (x *ResolveSubcategoryParentCategoryContext) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[217] + 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 ResolveSubcategoryParentCategoryContext.ProtoReflect.Descriptor instead. +func (*ResolveSubcategoryParentCategoryContext) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{217} +} + +func (x *ResolveSubcategoryParentCategoryContext) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +type ResolveSubcategoryParentCategoryRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // context provides the resolver context for the field parentCategory of type Subcategory. + Context []*ResolveSubcategoryParentCategoryContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveSubcategoryParentCategoryRequest) Reset() { + *x = ResolveSubcategoryParentCategoryRequest{} + mi := &file_product_proto_msgTypes[218] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveSubcategoryParentCategoryRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveSubcategoryParentCategoryRequest) ProtoMessage() {} + +func (x *ResolveSubcategoryParentCategoryRequest) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[218] + 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 ResolveSubcategoryParentCategoryRequest.ProtoReflect.Descriptor instead. +func (*ResolveSubcategoryParentCategoryRequest) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{218} +} + +func (x *ResolveSubcategoryParentCategoryRequest) GetContext() []*ResolveSubcategoryParentCategoryContext { + if x != nil { + return x.Context + } + return nil +} + +type ResolveSubcategoryParentCategoryResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + ParentCategory *Category `protobuf:"bytes,1,opt,name=parent_category,json=parentCategory,proto3" json:"parent_category,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveSubcategoryParentCategoryResult) Reset() { + *x = ResolveSubcategoryParentCategoryResult{} + mi := &file_product_proto_msgTypes[219] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveSubcategoryFeaturedCategoryResult) String() string { +func (x *ResolveSubcategoryParentCategoryResult) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveSubcategoryFeaturedCategoryResult) ProtoMessage() {} +func (*ResolveSubcategoryParentCategoryResult) ProtoMessage() {} -func (x *ResolveSubcategoryFeaturedCategoryResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[203] +func (x *ResolveSubcategoryParentCategoryResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[219] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9495,40 +10211,40 @@ func (x *ResolveSubcategoryFeaturedCategoryResult) ProtoReflect() protoreflect.M return mi.MessageOf(x) } -// Deprecated: Use ResolveSubcategoryFeaturedCategoryResult.ProtoReflect.Descriptor instead. -func (*ResolveSubcategoryFeaturedCategoryResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{203} +// Deprecated: Use ResolveSubcategoryParentCategoryResult.ProtoReflect.Descriptor instead. +func (*ResolveSubcategoryParentCategoryResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{219} } -func (x *ResolveSubcategoryFeaturedCategoryResult) GetFeaturedCategory() *Category { +func (x *ResolveSubcategoryParentCategoryResult) GetParentCategory() *Category { if x != nil { - return x.FeaturedCategory + return x.ParentCategory } return nil } -type ResolveSubcategoryFeaturedCategoryResponse struct { - state protoimpl.MessageState `protogen:"open.v1"` - Result []*ResolveSubcategoryFeaturedCategoryResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` +type ResolveSubcategoryParentCategoryResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Result []*ResolveSubcategoryParentCategoryResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ResolveSubcategoryFeaturedCategoryResponse) Reset() { - *x = ResolveSubcategoryFeaturedCategoryResponse{} - mi := &file_product_proto_msgTypes[204] +func (x *ResolveSubcategoryParentCategoryResponse) Reset() { + *x = ResolveSubcategoryParentCategoryResponse{} + mi := &file_product_proto_msgTypes[220] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveSubcategoryFeaturedCategoryResponse) String() string { +func (x *ResolveSubcategoryParentCategoryResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveSubcategoryFeaturedCategoryResponse) ProtoMessage() {} +func (*ResolveSubcategoryParentCategoryResponse) ProtoMessage() {} -func (x *ResolveSubcategoryFeaturedCategoryResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[204] +func (x *ResolveSubcategoryParentCategoryResponse) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[220] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9539,12 +10255,12 @@ func (x *ResolveSubcategoryFeaturedCategoryResponse) ProtoReflect() protoreflect return mi.MessageOf(x) } -// Deprecated: Use ResolveSubcategoryFeaturedCategoryResponse.ProtoReflect.Descriptor instead. -func (*ResolveSubcategoryFeaturedCategoryResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{204} +// Deprecated: Use ResolveSubcategoryParentCategoryResponse.ProtoReflect.Descriptor instead. +func (*ResolveSubcategoryParentCategoryResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{220} } -func (x *ResolveSubcategoryFeaturedCategoryResponse) GetResult() []*ResolveSubcategoryFeaturedCategoryResult { +func (x *ResolveSubcategoryParentCategoryResponse) GetResult() []*ResolveSubcategoryParentCategoryResult { if x != nil { return x.Result } @@ -9560,7 +10276,7 @@ type ResolveCategoryMetricsNormalizedScoreArgs struct { func (x *ResolveCategoryMetricsNormalizedScoreArgs) Reset() { *x = ResolveCategoryMetricsNormalizedScoreArgs{} - mi := &file_product_proto_msgTypes[205] + mi := &file_product_proto_msgTypes[221] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9572,7 +10288,7 @@ func (x *ResolveCategoryMetricsNormalizedScoreArgs) String() string { func (*ResolveCategoryMetricsNormalizedScoreArgs) ProtoMessage() {} func (x *ResolveCategoryMetricsNormalizedScoreArgs) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[205] + mi := &file_product_proto_msgTypes[221] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9585,7 +10301,7 @@ func (x *ResolveCategoryMetricsNormalizedScoreArgs) ProtoReflect() protoreflect. // Deprecated: Use ResolveCategoryMetricsNormalizedScoreArgs.ProtoReflect.Descriptor instead. func (*ResolveCategoryMetricsNormalizedScoreArgs) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{205} + return file_product_proto_rawDescGZIP(), []int{221} } func (x *ResolveCategoryMetricsNormalizedScoreArgs) GetBaseline() float64 { @@ -9606,7 +10322,7 @@ type ResolveCategoryMetricsNormalizedScoreContext struct { func (x *ResolveCategoryMetricsNormalizedScoreContext) Reset() { *x = ResolveCategoryMetricsNormalizedScoreContext{} - mi := &file_product_proto_msgTypes[206] + mi := &file_product_proto_msgTypes[222] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9618,7 +10334,7 @@ func (x *ResolveCategoryMetricsNormalizedScoreContext) String() string { func (*ResolveCategoryMetricsNormalizedScoreContext) ProtoMessage() {} func (x *ResolveCategoryMetricsNormalizedScoreContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[206] + mi := &file_product_proto_msgTypes[222] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9631,7 +10347,7 @@ func (x *ResolveCategoryMetricsNormalizedScoreContext) ProtoReflect() protorefle // Deprecated: Use ResolveCategoryMetricsNormalizedScoreContext.ProtoReflect.Descriptor instead. func (*ResolveCategoryMetricsNormalizedScoreContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{206} + return file_product_proto_rawDescGZIP(), []int{222} } func (x *ResolveCategoryMetricsNormalizedScoreContext) GetId() string { @@ -9667,7 +10383,7 @@ type ResolveCategoryMetricsNormalizedScoreRequest struct { func (x *ResolveCategoryMetricsNormalizedScoreRequest) Reset() { *x = ResolveCategoryMetricsNormalizedScoreRequest{} - mi := &file_product_proto_msgTypes[207] + mi := &file_product_proto_msgTypes[223] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9679,7 +10395,7 @@ func (x *ResolveCategoryMetricsNormalizedScoreRequest) String() string { func (*ResolveCategoryMetricsNormalizedScoreRequest) ProtoMessage() {} func (x *ResolveCategoryMetricsNormalizedScoreRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[207] + mi := &file_product_proto_msgTypes[223] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9692,7 +10408,7 @@ func (x *ResolveCategoryMetricsNormalizedScoreRequest) ProtoReflect() protorefle // Deprecated: Use ResolveCategoryMetricsNormalizedScoreRequest.ProtoReflect.Descriptor instead. func (*ResolveCategoryMetricsNormalizedScoreRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{207} + return file_product_proto_rawDescGZIP(), []int{223} } func (x *ResolveCategoryMetricsNormalizedScoreRequest) GetContext() []*ResolveCategoryMetricsNormalizedScoreContext { @@ -9718,7 +10434,7 @@ type ResolveCategoryMetricsNormalizedScoreResult struct { func (x *ResolveCategoryMetricsNormalizedScoreResult) Reset() { *x = ResolveCategoryMetricsNormalizedScoreResult{} - mi := &file_product_proto_msgTypes[208] + mi := &file_product_proto_msgTypes[224] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9730,7 +10446,7 @@ func (x *ResolveCategoryMetricsNormalizedScoreResult) String() string { func (*ResolveCategoryMetricsNormalizedScoreResult) ProtoMessage() {} func (x *ResolveCategoryMetricsNormalizedScoreResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[208] + mi := &file_product_proto_msgTypes[224] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9743,7 +10459,7 @@ func (x *ResolveCategoryMetricsNormalizedScoreResult) ProtoReflect() protoreflec // Deprecated: Use ResolveCategoryMetricsNormalizedScoreResult.ProtoReflect.Descriptor instead. func (*ResolveCategoryMetricsNormalizedScoreResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{208} + return file_product_proto_rawDescGZIP(), []int{224} } func (x *ResolveCategoryMetricsNormalizedScoreResult) GetNormalizedScore() float64 { @@ -9762,7 +10478,7 @@ type ResolveCategoryMetricsNormalizedScoreResponse struct { func (x *ResolveCategoryMetricsNormalizedScoreResponse) Reset() { *x = ResolveCategoryMetricsNormalizedScoreResponse{} - mi := &file_product_proto_msgTypes[209] + mi := &file_product_proto_msgTypes[225] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9774,7 +10490,7 @@ func (x *ResolveCategoryMetricsNormalizedScoreResponse) String() string { func (*ResolveCategoryMetricsNormalizedScoreResponse) ProtoMessage() {} func (x *ResolveCategoryMetricsNormalizedScoreResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[209] + mi := &file_product_proto_msgTypes[225] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9787,7 +10503,7 @@ func (x *ResolveCategoryMetricsNormalizedScoreResponse) ProtoReflect() protorefl // Deprecated: Use ResolveCategoryMetricsNormalizedScoreResponse.ProtoReflect.Descriptor instead. func (*ResolveCategoryMetricsNormalizedScoreResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{209} + return file_product_proto_rawDescGZIP(), []int{225} } func (x *ResolveCategoryMetricsNormalizedScoreResponse) GetResult() []*ResolveCategoryMetricsNormalizedScoreResult { @@ -9806,7 +10522,7 @@ type ResolveCategoryMetricsRelatedCategoryArgs struct { func (x *ResolveCategoryMetricsRelatedCategoryArgs) Reset() { *x = ResolveCategoryMetricsRelatedCategoryArgs{} - mi := &file_product_proto_msgTypes[210] + mi := &file_product_proto_msgTypes[226] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9818,7 +10534,7 @@ func (x *ResolveCategoryMetricsRelatedCategoryArgs) String() string { func (*ResolveCategoryMetricsRelatedCategoryArgs) ProtoMessage() {} func (x *ResolveCategoryMetricsRelatedCategoryArgs) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[210] + mi := &file_product_proto_msgTypes[226] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9831,7 +10547,7 @@ func (x *ResolveCategoryMetricsRelatedCategoryArgs) ProtoReflect() protoreflect. // Deprecated: Use ResolveCategoryMetricsRelatedCategoryArgs.ProtoReflect.Descriptor instead. func (*ResolveCategoryMetricsRelatedCategoryArgs) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{210} + return file_product_proto_rawDescGZIP(), []int{226} } func (x *ResolveCategoryMetricsRelatedCategoryArgs) GetInclude() *wrapperspb.BoolValue { @@ -9850,7 +10566,7 @@ type ResolveCategoryMetricsRelatedCategoryContext struct { func (x *ResolveCategoryMetricsRelatedCategoryContext) Reset() { *x = ResolveCategoryMetricsRelatedCategoryContext{} - mi := &file_product_proto_msgTypes[211] + mi := &file_product_proto_msgTypes[227] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9862,7 +10578,7 @@ func (x *ResolveCategoryMetricsRelatedCategoryContext) String() string { func (*ResolveCategoryMetricsRelatedCategoryContext) ProtoMessage() {} func (x *ResolveCategoryMetricsRelatedCategoryContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[211] + mi := &file_product_proto_msgTypes[227] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9875,7 +10591,7 @@ func (x *ResolveCategoryMetricsRelatedCategoryContext) ProtoReflect() protorefle // Deprecated: Use ResolveCategoryMetricsRelatedCategoryContext.ProtoReflect.Descriptor instead. func (*ResolveCategoryMetricsRelatedCategoryContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{211} + return file_product_proto_rawDescGZIP(), []int{227} } func (x *ResolveCategoryMetricsRelatedCategoryContext) GetCategoryId() string { @@ -9897,7 +10613,7 @@ type ResolveCategoryMetricsRelatedCategoryRequest struct { func (x *ResolveCategoryMetricsRelatedCategoryRequest) Reset() { *x = ResolveCategoryMetricsRelatedCategoryRequest{} - mi := &file_product_proto_msgTypes[212] + mi := &file_product_proto_msgTypes[228] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9909,7 +10625,7 @@ func (x *ResolveCategoryMetricsRelatedCategoryRequest) String() string { func (*ResolveCategoryMetricsRelatedCategoryRequest) ProtoMessage() {} func (x *ResolveCategoryMetricsRelatedCategoryRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[212] + mi := &file_product_proto_msgTypes[228] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9922,7 +10638,7 @@ func (x *ResolveCategoryMetricsRelatedCategoryRequest) ProtoReflect() protorefle // Deprecated: Use ResolveCategoryMetricsRelatedCategoryRequest.ProtoReflect.Descriptor instead. func (*ResolveCategoryMetricsRelatedCategoryRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{212} + return file_product_proto_rawDescGZIP(), []int{228} } func (x *ResolveCategoryMetricsRelatedCategoryRequest) GetContext() []*ResolveCategoryMetricsRelatedCategoryContext { @@ -9948,7 +10664,7 @@ type ResolveCategoryMetricsRelatedCategoryResult struct { func (x *ResolveCategoryMetricsRelatedCategoryResult) Reset() { *x = ResolveCategoryMetricsRelatedCategoryResult{} - mi := &file_product_proto_msgTypes[213] + mi := &file_product_proto_msgTypes[229] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9960,7 +10676,7 @@ func (x *ResolveCategoryMetricsRelatedCategoryResult) String() string { func (*ResolveCategoryMetricsRelatedCategoryResult) ProtoMessage() {} func (x *ResolveCategoryMetricsRelatedCategoryResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[213] + mi := &file_product_proto_msgTypes[229] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9973,7 +10689,7 @@ func (x *ResolveCategoryMetricsRelatedCategoryResult) ProtoReflect() protoreflec // Deprecated: Use ResolveCategoryMetricsRelatedCategoryResult.ProtoReflect.Descriptor instead. func (*ResolveCategoryMetricsRelatedCategoryResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{213} + return file_product_proto_rawDescGZIP(), []int{229} } func (x *ResolveCategoryMetricsRelatedCategoryResult) GetRelatedCategory() *Category { @@ -9992,7 +10708,7 @@ type ResolveCategoryMetricsRelatedCategoryResponse struct { func (x *ResolveCategoryMetricsRelatedCategoryResponse) Reset() { *x = ResolveCategoryMetricsRelatedCategoryResponse{} - mi := &file_product_proto_msgTypes[214] + mi := &file_product_proto_msgTypes[230] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10004,7 +10720,7 @@ func (x *ResolveCategoryMetricsRelatedCategoryResponse) String() string { func (*ResolveCategoryMetricsRelatedCategoryResponse) ProtoMessage() {} func (x *ResolveCategoryMetricsRelatedCategoryResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[214] + mi := &file_product_proto_msgTypes[230] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10017,7 +10733,7 @@ func (x *ResolveCategoryMetricsRelatedCategoryResponse) ProtoReflect() protorefl // Deprecated: Use ResolveCategoryMetricsRelatedCategoryResponse.ProtoReflect.Descriptor instead. func (*ResolveCategoryMetricsRelatedCategoryResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{214} + return file_product_proto_rawDescGZIP(), []int{230} } func (x *ResolveCategoryMetricsRelatedCategoryResponse) GetResult() []*ResolveCategoryMetricsRelatedCategoryResult { @@ -10027,6 +10743,191 @@ func (x *ResolveCategoryMetricsRelatedCategoryResponse) GetResult() []*ResolveCa return nil } +type ResolveCategoryMetricsAverageScoreContext 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"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryMetricsAverageScoreContext) Reset() { + *x = ResolveCategoryMetricsAverageScoreContext{} + mi := &file_product_proto_msgTypes[231] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryMetricsAverageScoreContext) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryMetricsAverageScoreContext) ProtoMessage() {} + +func (x *ResolveCategoryMetricsAverageScoreContext) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[231] + 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 ResolveCategoryMetricsAverageScoreContext.ProtoReflect.Descriptor instead. +func (*ResolveCategoryMetricsAverageScoreContext) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{231} +} + +func (x *ResolveCategoryMetricsAverageScoreContext) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *ResolveCategoryMetricsAverageScoreContext) GetMetricType() string { + if x != nil { + return x.MetricType + } + return "" +} + +type ResolveCategoryMetricsAverageScoreRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // context provides the resolver context for the field averageScore of type CategoryMetrics. + Context []*ResolveCategoryMetricsAverageScoreContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryMetricsAverageScoreRequest) Reset() { + *x = ResolveCategoryMetricsAverageScoreRequest{} + mi := &file_product_proto_msgTypes[232] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryMetricsAverageScoreRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryMetricsAverageScoreRequest) ProtoMessage() {} + +func (x *ResolveCategoryMetricsAverageScoreRequest) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[232] + 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 ResolveCategoryMetricsAverageScoreRequest.ProtoReflect.Descriptor instead. +func (*ResolveCategoryMetricsAverageScoreRequest) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{232} +} + +func (x *ResolveCategoryMetricsAverageScoreRequest) GetContext() []*ResolveCategoryMetricsAverageScoreContext { + if x != nil { + return x.Context + } + return nil +} + +type ResolveCategoryMetricsAverageScoreResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + AverageScore float64 `protobuf:"fixed64,1,opt,name=average_score,json=averageScore,proto3" json:"average_score,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryMetricsAverageScoreResult) Reset() { + *x = ResolveCategoryMetricsAverageScoreResult{} + mi := &file_product_proto_msgTypes[233] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryMetricsAverageScoreResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryMetricsAverageScoreResult) ProtoMessage() {} + +func (x *ResolveCategoryMetricsAverageScoreResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[233] + 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 ResolveCategoryMetricsAverageScoreResult.ProtoReflect.Descriptor instead. +func (*ResolveCategoryMetricsAverageScoreResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{233} +} + +func (x *ResolveCategoryMetricsAverageScoreResult) GetAverageScore() float64 { + if x != nil { + return x.AverageScore + } + return 0 +} + +type ResolveCategoryMetricsAverageScoreResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Result []*ResolveCategoryMetricsAverageScoreResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryMetricsAverageScoreResponse) Reset() { + *x = ResolveCategoryMetricsAverageScoreResponse{} + mi := &file_product_proto_msgTypes[234] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryMetricsAverageScoreResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryMetricsAverageScoreResponse) ProtoMessage() {} + +func (x *ResolveCategoryMetricsAverageScoreResponse) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[234] + 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 ResolveCategoryMetricsAverageScoreResponse.ProtoReflect.Descriptor instead. +func (*ResolveCategoryMetricsAverageScoreResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{234} +} + +func (x *ResolveCategoryMetricsAverageScoreResponse) GetResult() []*ResolveCategoryMetricsAverageScoreResult { + if x != nil { + return x.Result + } + return nil +} + type ResolveTestContainerDetailsArgs struct { state protoimpl.MessageState `protogen:"open.v1"` IncludeExtended bool `protobuf:"varint,1,opt,name=include_extended,json=includeExtended,proto3" json:"include_extended,omitempty"` @@ -10036,7 +10937,7 @@ type ResolveTestContainerDetailsArgs struct { func (x *ResolveTestContainerDetailsArgs) Reset() { *x = ResolveTestContainerDetailsArgs{} - mi := &file_product_proto_msgTypes[215] + mi := &file_product_proto_msgTypes[235] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10048,7 +10949,7 @@ func (x *ResolveTestContainerDetailsArgs) String() string { func (*ResolveTestContainerDetailsArgs) ProtoMessage() {} func (x *ResolveTestContainerDetailsArgs) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[215] + mi := &file_product_proto_msgTypes[235] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10061,7 +10962,7 @@ func (x *ResolveTestContainerDetailsArgs) ProtoReflect() protoreflect.Message { // Deprecated: Use ResolveTestContainerDetailsArgs.ProtoReflect.Descriptor instead. func (*ResolveTestContainerDetailsArgs) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{215} + return file_product_proto_rawDescGZIP(), []int{235} } func (x *ResolveTestContainerDetailsArgs) GetIncludeExtended() bool { @@ -10081,7 +10982,7 @@ type ResolveTestContainerDetailsContext struct { func (x *ResolveTestContainerDetailsContext) Reset() { *x = ResolveTestContainerDetailsContext{} - mi := &file_product_proto_msgTypes[216] + mi := &file_product_proto_msgTypes[236] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10093,7 +10994,7 @@ func (x *ResolveTestContainerDetailsContext) String() string { func (*ResolveTestContainerDetailsContext) ProtoMessage() {} func (x *ResolveTestContainerDetailsContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[216] + mi := &file_product_proto_msgTypes[236] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10106,7 +11007,7 @@ func (x *ResolveTestContainerDetailsContext) ProtoReflect() protoreflect.Message // Deprecated: Use ResolveTestContainerDetailsContext.ProtoReflect.Descriptor instead. func (*ResolveTestContainerDetailsContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{216} + return file_product_proto_rawDescGZIP(), []int{236} } func (x *ResolveTestContainerDetailsContext) GetId() string { @@ -10135,7 +11036,7 @@ type ResolveTestContainerDetailsRequest struct { func (x *ResolveTestContainerDetailsRequest) Reset() { *x = ResolveTestContainerDetailsRequest{} - mi := &file_product_proto_msgTypes[217] + mi := &file_product_proto_msgTypes[237] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10147,7 +11048,7 @@ func (x *ResolveTestContainerDetailsRequest) String() string { func (*ResolveTestContainerDetailsRequest) ProtoMessage() {} func (x *ResolveTestContainerDetailsRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[217] + mi := &file_product_proto_msgTypes[237] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10160,7 +11061,7 @@ func (x *ResolveTestContainerDetailsRequest) ProtoReflect() protoreflect.Message // Deprecated: Use ResolveTestContainerDetailsRequest.ProtoReflect.Descriptor instead. func (*ResolveTestContainerDetailsRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{217} + return file_product_proto_rawDescGZIP(), []int{237} } func (x *ResolveTestContainerDetailsRequest) GetContext() []*ResolveTestContainerDetailsContext { @@ -10186,7 +11087,7 @@ type ResolveTestContainerDetailsResult struct { func (x *ResolveTestContainerDetailsResult) Reset() { *x = ResolveTestContainerDetailsResult{} - mi := &file_product_proto_msgTypes[218] + mi := &file_product_proto_msgTypes[238] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10198,7 +11099,7 @@ func (x *ResolveTestContainerDetailsResult) String() string { func (*ResolveTestContainerDetailsResult) ProtoMessage() {} func (x *ResolveTestContainerDetailsResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[218] + mi := &file_product_proto_msgTypes[238] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10211,7 +11112,7 @@ func (x *ResolveTestContainerDetailsResult) ProtoReflect() protoreflect.Message // Deprecated: Use ResolveTestContainerDetailsResult.ProtoReflect.Descriptor instead. func (*ResolveTestContainerDetailsResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{218} + return file_product_proto_rawDescGZIP(), []int{238} } func (x *ResolveTestContainerDetailsResult) GetDetails() *TestDetails { @@ -10230,7 +11131,7 @@ type ResolveTestContainerDetailsResponse struct { func (x *ResolveTestContainerDetailsResponse) Reset() { *x = ResolveTestContainerDetailsResponse{} - mi := &file_product_proto_msgTypes[219] + mi := &file_product_proto_msgTypes[239] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10242,7 +11143,7 @@ func (x *ResolveTestContainerDetailsResponse) String() string { func (*ResolveTestContainerDetailsResponse) ProtoMessage() {} func (x *ResolveTestContainerDetailsResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[219] + mi := &file_product_proto_msgTypes[239] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10255,7 +11156,7 @@ func (x *ResolveTestContainerDetailsResponse) ProtoReflect() protoreflect.Messag // Deprecated: Use ResolveTestContainerDetailsResponse.ProtoReflect.Descriptor instead. func (*ResolveTestContainerDetailsResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{219} + return file_product_proto_rawDescGZIP(), []int{239} } func (x *ResolveTestContainerDetailsResponse) GetResult() []*ResolveTestContainerDetailsResult { @@ -10275,7 +11176,7 @@ type RequireStorageStockHealthScoreByIdRequest struct { func (x *RequireStorageStockHealthScoreByIdRequest) Reset() { *x = RequireStorageStockHealthScoreByIdRequest{} - mi := &file_product_proto_msgTypes[220] + mi := &file_product_proto_msgTypes[240] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10287,7 +11188,7 @@ func (x *RequireStorageStockHealthScoreByIdRequest) String() string { func (*RequireStorageStockHealthScoreByIdRequest) ProtoMessage() {} func (x *RequireStorageStockHealthScoreByIdRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[220] + mi := &file_product_proto_msgTypes[240] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10300,7 +11201,7 @@ func (x *RequireStorageStockHealthScoreByIdRequest) ProtoReflect() protoreflect. // Deprecated: Use RequireStorageStockHealthScoreByIdRequest.ProtoReflect.Descriptor instead. func (*RequireStorageStockHealthScoreByIdRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{220} + return file_product_proto_rawDescGZIP(), []int{240} } func (x *RequireStorageStockHealthScoreByIdRequest) GetContext() []*RequireStorageStockHealthScoreByIdContext { @@ -10320,7 +11221,7 @@ type RequireStorageStockHealthScoreByIdContext struct { func (x *RequireStorageStockHealthScoreByIdContext) Reset() { *x = RequireStorageStockHealthScoreByIdContext{} - mi := &file_product_proto_msgTypes[221] + mi := &file_product_proto_msgTypes[241] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10332,7 +11233,7 @@ func (x *RequireStorageStockHealthScoreByIdContext) String() string { func (*RequireStorageStockHealthScoreByIdContext) ProtoMessage() {} func (x *RequireStorageStockHealthScoreByIdContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[221] + mi := &file_product_proto_msgTypes[241] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10345,7 +11246,7 @@ func (x *RequireStorageStockHealthScoreByIdContext) ProtoReflect() protoreflect. // Deprecated: Use RequireStorageStockHealthScoreByIdContext.ProtoReflect.Descriptor instead. func (*RequireStorageStockHealthScoreByIdContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{221} + return file_product_proto_rawDescGZIP(), []int{241} } func (x *RequireStorageStockHealthScoreByIdContext) GetKey() *LookupStorageByIdRequestKey { @@ -10372,7 +11273,7 @@ type RequireStorageStockHealthScoreByIdResponse struct { func (x *RequireStorageStockHealthScoreByIdResponse) Reset() { *x = RequireStorageStockHealthScoreByIdResponse{} - mi := &file_product_proto_msgTypes[222] + mi := &file_product_proto_msgTypes[242] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10384,7 +11285,7 @@ func (x *RequireStorageStockHealthScoreByIdResponse) String() string { func (*RequireStorageStockHealthScoreByIdResponse) ProtoMessage() {} func (x *RequireStorageStockHealthScoreByIdResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[222] + mi := &file_product_proto_msgTypes[242] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10397,7 +11298,7 @@ func (x *RequireStorageStockHealthScoreByIdResponse) ProtoReflect() protoreflect // Deprecated: Use RequireStorageStockHealthScoreByIdResponse.ProtoReflect.Descriptor instead. func (*RequireStorageStockHealthScoreByIdResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{222} + return file_product_proto_rawDescGZIP(), []int{242} } func (x *RequireStorageStockHealthScoreByIdResponse) GetResult() []*RequireStorageStockHealthScoreByIdResult { @@ -10416,7 +11317,7 @@ type RequireStorageStockHealthScoreByIdResult struct { func (x *RequireStorageStockHealthScoreByIdResult) Reset() { *x = RequireStorageStockHealthScoreByIdResult{} - mi := &file_product_proto_msgTypes[223] + mi := &file_product_proto_msgTypes[243] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10428,7 +11329,7 @@ func (x *RequireStorageStockHealthScoreByIdResult) String() string { func (*RequireStorageStockHealthScoreByIdResult) ProtoMessage() {} func (x *RequireStorageStockHealthScoreByIdResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[223] + mi := &file_product_proto_msgTypes[243] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10441,7 +11342,7 @@ func (x *RequireStorageStockHealthScoreByIdResult) ProtoReflect() protoreflect.M // Deprecated: Use RequireStorageStockHealthScoreByIdResult.ProtoReflect.Descriptor instead. func (*RequireStorageStockHealthScoreByIdResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{223} + return file_product_proto_rawDescGZIP(), []int{243} } func (x *RequireStorageStockHealthScoreByIdResult) GetStockHealthScore() float64 { @@ -10461,7 +11362,7 @@ type RequireStorageStockHealthScoreByIdFields struct { func (x *RequireStorageStockHealthScoreByIdFields) Reset() { *x = RequireStorageStockHealthScoreByIdFields{} - mi := &file_product_proto_msgTypes[224] + mi := &file_product_proto_msgTypes[244] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10473,7 +11374,7 @@ func (x *RequireStorageStockHealthScoreByIdFields) String() string { func (*RequireStorageStockHealthScoreByIdFields) ProtoMessage() {} func (x *RequireStorageStockHealthScoreByIdFields) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[224] + mi := &file_product_proto_msgTypes[244] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10486,7 +11387,7 @@ func (x *RequireStorageStockHealthScoreByIdFields) ProtoReflect() protoreflect.M // Deprecated: Use RequireStorageStockHealthScoreByIdFields.ProtoReflect.Descriptor instead. func (*RequireStorageStockHealthScoreByIdFields) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{224} + return file_product_proto_rawDescGZIP(), []int{244} } func (x *RequireStorageStockHealthScoreByIdFields) GetItemCount() int32 { @@ -10513,7 +11414,7 @@ type RequireStorageTagSummaryByIdRequest struct { func (x *RequireStorageTagSummaryByIdRequest) Reset() { *x = RequireStorageTagSummaryByIdRequest{} - mi := &file_product_proto_msgTypes[225] + mi := &file_product_proto_msgTypes[245] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10525,7 +11426,7 @@ func (x *RequireStorageTagSummaryByIdRequest) String() string { func (*RequireStorageTagSummaryByIdRequest) ProtoMessage() {} func (x *RequireStorageTagSummaryByIdRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[225] + mi := &file_product_proto_msgTypes[245] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10538,7 +11439,7 @@ func (x *RequireStorageTagSummaryByIdRequest) ProtoReflect() protoreflect.Messag // Deprecated: Use RequireStorageTagSummaryByIdRequest.ProtoReflect.Descriptor instead. func (*RequireStorageTagSummaryByIdRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{225} + return file_product_proto_rawDescGZIP(), []int{245} } func (x *RequireStorageTagSummaryByIdRequest) GetContext() []*RequireStorageTagSummaryByIdContext { @@ -10558,7 +11459,7 @@ type RequireStorageTagSummaryByIdContext struct { func (x *RequireStorageTagSummaryByIdContext) Reset() { *x = RequireStorageTagSummaryByIdContext{} - mi := &file_product_proto_msgTypes[226] + mi := &file_product_proto_msgTypes[246] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10570,7 +11471,7 @@ func (x *RequireStorageTagSummaryByIdContext) String() string { func (*RequireStorageTagSummaryByIdContext) ProtoMessage() {} func (x *RequireStorageTagSummaryByIdContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[226] + mi := &file_product_proto_msgTypes[246] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10583,7 +11484,7 @@ func (x *RequireStorageTagSummaryByIdContext) ProtoReflect() protoreflect.Messag // Deprecated: Use RequireStorageTagSummaryByIdContext.ProtoReflect.Descriptor instead. func (*RequireStorageTagSummaryByIdContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{226} + return file_product_proto_rawDescGZIP(), []int{246} } func (x *RequireStorageTagSummaryByIdContext) GetKey() *LookupStorageByIdRequestKey { @@ -10610,7 +11511,7 @@ type RequireStorageTagSummaryByIdResponse struct { func (x *RequireStorageTagSummaryByIdResponse) Reset() { *x = RequireStorageTagSummaryByIdResponse{} - mi := &file_product_proto_msgTypes[227] + mi := &file_product_proto_msgTypes[247] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10622,7 +11523,7 @@ func (x *RequireStorageTagSummaryByIdResponse) String() string { func (*RequireStorageTagSummaryByIdResponse) ProtoMessage() {} func (x *RequireStorageTagSummaryByIdResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[227] + mi := &file_product_proto_msgTypes[247] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10635,7 +11536,7 @@ func (x *RequireStorageTagSummaryByIdResponse) ProtoReflect() protoreflect.Messa // Deprecated: Use RequireStorageTagSummaryByIdResponse.ProtoReflect.Descriptor instead. func (*RequireStorageTagSummaryByIdResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{227} + return file_product_proto_rawDescGZIP(), []int{247} } func (x *RequireStorageTagSummaryByIdResponse) GetResult() []*RequireStorageTagSummaryByIdResult { @@ -10654,7 +11555,7 @@ type RequireStorageTagSummaryByIdResult struct { func (x *RequireStorageTagSummaryByIdResult) Reset() { *x = RequireStorageTagSummaryByIdResult{} - mi := &file_product_proto_msgTypes[228] + mi := &file_product_proto_msgTypes[248] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10666,7 +11567,7 @@ func (x *RequireStorageTagSummaryByIdResult) String() string { func (*RequireStorageTagSummaryByIdResult) ProtoMessage() {} func (x *RequireStorageTagSummaryByIdResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[228] + mi := &file_product_proto_msgTypes[248] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10679,7 +11580,7 @@ func (x *RequireStorageTagSummaryByIdResult) ProtoReflect() protoreflect.Message // Deprecated: Use RequireStorageTagSummaryByIdResult.ProtoReflect.Descriptor instead. func (*RequireStorageTagSummaryByIdResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{228} + return file_product_proto_rawDescGZIP(), []int{248} } func (x *RequireStorageTagSummaryByIdResult) GetTagSummary() string { @@ -10698,7 +11599,7 @@ type RequireStorageTagSummaryByIdFields struct { func (x *RequireStorageTagSummaryByIdFields) Reset() { *x = RequireStorageTagSummaryByIdFields{} - mi := &file_product_proto_msgTypes[229] + mi := &file_product_proto_msgTypes[249] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10710,7 +11611,7 @@ func (x *RequireStorageTagSummaryByIdFields) String() string { func (*RequireStorageTagSummaryByIdFields) ProtoMessage() {} func (x *RequireStorageTagSummaryByIdFields) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[229] + mi := &file_product_proto_msgTypes[249] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10723,7 +11624,7 @@ func (x *RequireStorageTagSummaryByIdFields) ProtoReflect() protoreflect.Message // Deprecated: Use RequireStorageTagSummaryByIdFields.ProtoReflect.Descriptor instead. func (*RequireStorageTagSummaryByIdFields) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{229} + return file_product_proto_rawDescGZIP(), []int{249} } func (x *RequireStorageTagSummaryByIdFields) GetTags() []string { @@ -10743,7 +11644,7 @@ type RequireStorageOptionalTagSummaryByIdRequest struct { func (x *RequireStorageOptionalTagSummaryByIdRequest) Reset() { *x = RequireStorageOptionalTagSummaryByIdRequest{} - mi := &file_product_proto_msgTypes[230] + mi := &file_product_proto_msgTypes[250] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10755,7 +11656,7 @@ func (x *RequireStorageOptionalTagSummaryByIdRequest) String() string { func (*RequireStorageOptionalTagSummaryByIdRequest) ProtoMessage() {} func (x *RequireStorageOptionalTagSummaryByIdRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[230] + mi := &file_product_proto_msgTypes[250] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10768,7 +11669,7 @@ func (x *RequireStorageOptionalTagSummaryByIdRequest) ProtoReflect() protoreflec // Deprecated: Use RequireStorageOptionalTagSummaryByIdRequest.ProtoReflect.Descriptor instead. func (*RequireStorageOptionalTagSummaryByIdRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{230} + return file_product_proto_rawDescGZIP(), []int{250} } func (x *RequireStorageOptionalTagSummaryByIdRequest) GetContext() []*RequireStorageOptionalTagSummaryByIdContext { @@ -10788,7 +11689,7 @@ type RequireStorageOptionalTagSummaryByIdContext struct { func (x *RequireStorageOptionalTagSummaryByIdContext) Reset() { *x = RequireStorageOptionalTagSummaryByIdContext{} - mi := &file_product_proto_msgTypes[231] + mi := &file_product_proto_msgTypes[251] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10800,7 +11701,7 @@ func (x *RequireStorageOptionalTagSummaryByIdContext) String() string { func (*RequireStorageOptionalTagSummaryByIdContext) ProtoMessage() {} func (x *RequireStorageOptionalTagSummaryByIdContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[231] + mi := &file_product_proto_msgTypes[251] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10813,7 +11714,7 @@ func (x *RequireStorageOptionalTagSummaryByIdContext) ProtoReflect() protoreflec // Deprecated: Use RequireStorageOptionalTagSummaryByIdContext.ProtoReflect.Descriptor instead. func (*RequireStorageOptionalTagSummaryByIdContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{231} + return file_product_proto_rawDescGZIP(), []int{251} } func (x *RequireStorageOptionalTagSummaryByIdContext) GetKey() *LookupStorageByIdRequestKey { @@ -10840,7 +11741,7 @@ type RequireStorageOptionalTagSummaryByIdResponse struct { func (x *RequireStorageOptionalTagSummaryByIdResponse) Reset() { *x = RequireStorageOptionalTagSummaryByIdResponse{} - mi := &file_product_proto_msgTypes[232] + mi := &file_product_proto_msgTypes[252] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10852,7 +11753,7 @@ func (x *RequireStorageOptionalTagSummaryByIdResponse) String() string { func (*RequireStorageOptionalTagSummaryByIdResponse) ProtoMessage() {} func (x *RequireStorageOptionalTagSummaryByIdResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[232] + mi := &file_product_proto_msgTypes[252] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10865,7 +11766,7 @@ func (x *RequireStorageOptionalTagSummaryByIdResponse) ProtoReflect() protorefle // Deprecated: Use RequireStorageOptionalTagSummaryByIdResponse.ProtoReflect.Descriptor instead. func (*RequireStorageOptionalTagSummaryByIdResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{232} + return file_product_proto_rawDescGZIP(), []int{252} } func (x *RequireStorageOptionalTagSummaryByIdResponse) GetResult() []*RequireStorageOptionalTagSummaryByIdResult { @@ -10884,7 +11785,7 @@ type RequireStorageOptionalTagSummaryByIdResult struct { func (x *RequireStorageOptionalTagSummaryByIdResult) Reset() { *x = RequireStorageOptionalTagSummaryByIdResult{} - mi := &file_product_proto_msgTypes[233] + mi := &file_product_proto_msgTypes[253] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10896,7 +11797,7 @@ func (x *RequireStorageOptionalTagSummaryByIdResult) String() string { func (*RequireStorageOptionalTagSummaryByIdResult) ProtoMessage() {} func (x *RequireStorageOptionalTagSummaryByIdResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[233] + mi := &file_product_proto_msgTypes[253] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10909,7 +11810,7 @@ func (x *RequireStorageOptionalTagSummaryByIdResult) ProtoReflect() protoreflect // Deprecated: Use RequireStorageOptionalTagSummaryByIdResult.ProtoReflect.Descriptor instead. func (*RequireStorageOptionalTagSummaryByIdResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{233} + return file_product_proto_rawDescGZIP(), []int{253} } func (x *RequireStorageOptionalTagSummaryByIdResult) GetOptionalTagSummary() *wrapperspb.StringValue { @@ -10928,7 +11829,7 @@ type RequireStorageOptionalTagSummaryByIdFields struct { func (x *RequireStorageOptionalTagSummaryByIdFields) Reset() { *x = RequireStorageOptionalTagSummaryByIdFields{} - mi := &file_product_proto_msgTypes[234] + mi := &file_product_proto_msgTypes[254] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10940,7 +11841,7 @@ func (x *RequireStorageOptionalTagSummaryByIdFields) String() string { func (*RequireStorageOptionalTagSummaryByIdFields) ProtoMessage() {} func (x *RequireStorageOptionalTagSummaryByIdFields) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[234] + mi := &file_product_proto_msgTypes[254] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10953,7 +11854,7 @@ func (x *RequireStorageOptionalTagSummaryByIdFields) ProtoReflect() protoreflect // Deprecated: Use RequireStorageOptionalTagSummaryByIdFields.ProtoReflect.Descriptor instead. func (*RequireStorageOptionalTagSummaryByIdFields) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{234} + return file_product_proto_rawDescGZIP(), []int{254} } func (x *RequireStorageOptionalTagSummaryByIdFields) GetOptionalTags() *ListOfString { @@ -10973,7 +11874,7 @@ type RequireStorageMetadataScoreByIdRequest struct { func (x *RequireStorageMetadataScoreByIdRequest) Reset() { *x = RequireStorageMetadataScoreByIdRequest{} - mi := &file_product_proto_msgTypes[235] + mi := &file_product_proto_msgTypes[255] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10985,7 +11886,7 @@ func (x *RequireStorageMetadataScoreByIdRequest) String() string { func (*RequireStorageMetadataScoreByIdRequest) ProtoMessage() {} func (x *RequireStorageMetadataScoreByIdRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[235] + mi := &file_product_proto_msgTypes[255] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10998,7 +11899,7 @@ func (x *RequireStorageMetadataScoreByIdRequest) ProtoReflect() protoreflect.Mes // Deprecated: Use RequireStorageMetadataScoreByIdRequest.ProtoReflect.Descriptor instead. func (*RequireStorageMetadataScoreByIdRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{235} + return file_product_proto_rawDescGZIP(), []int{255} } func (x *RequireStorageMetadataScoreByIdRequest) GetContext() []*RequireStorageMetadataScoreByIdContext { @@ -11018,7 +11919,7 @@ type RequireStorageMetadataScoreByIdContext struct { func (x *RequireStorageMetadataScoreByIdContext) Reset() { *x = RequireStorageMetadataScoreByIdContext{} - mi := &file_product_proto_msgTypes[236] + mi := &file_product_proto_msgTypes[256] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11030,7 +11931,7 @@ func (x *RequireStorageMetadataScoreByIdContext) String() string { func (*RequireStorageMetadataScoreByIdContext) ProtoMessage() {} func (x *RequireStorageMetadataScoreByIdContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[236] + mi := &file_product_proto_msgTypes[256] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11043,7 +11944,7 @@ func (x *RequireStorageMetadataScoreByIdContext) ProtoReflect() protoreflect.Mes // Deprecated: Use RequireStorageMetadataScoreByIdContext.ProtoReflect.Descriptor instead. func (*RequireStorageMetadataScoreByIdContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{236} + return file_product_proto_rawDescGZIP(), []int{256} } func (x *RequireStorageMetadataScoreByIdContext) GetKey() *LookupStorageByIdRequestKey { @@ -11070,7 +11971,7 @@ type RequireStorageMetadataScoreByIdResponse struct { func (x *RequireStorageMetadataScoreByIdResponse) Reset() { *x = RequireStorageMetadataScoreByIdResponse{} - mi := &file_product_proto_msgTypes[237] + mi := &file_product_proto_msgTypes[257] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11082,7 +11983,7 @@ func (x *RequireStorageMetadataScoreByIdResponse) String() string { func (*RequireStorageMetadataScoreByIdResponse) ProtoMessage() {} func (x *RequireStorageMetadataScoreByIdResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[237] + mi := &file_product_proto_msgTypes[257] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11095,7 +11996,7 @@ func (x *RequireStorageMetadataScoreByIdResponse) ProtoReflect() protoreflect.Me // Deprecated: Use RequireStorageMetadataScoreByIdResponse.ProtoReflect.Descriptor instead. func (*RequireStorageMetadataScoreByIdResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{237} + return file_product_proto_rawDescGZIP(), []int{257} } func (x *RequireStorageMetadataScoreByIdResponse) GetResult() []*RequireStorageMetadataScoreByIdResult { @@ -11114,7 +12015,7 @@ type RequireStorageMetadataScoreByIdResult struct { func (x *RequireStorageMetadataScoreByIdResult) Reset() { *x = RequireStorageMetadataScoreByIdResult{} - mi := &file_product_proto_msgTypes[238] + mi := &file_product_proto_msgTypes[258] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11126,7 +12027,7 @@ func (x *RequireStorageMetadataScoreByIdResult) String() string { func (*RequireStorageMetadataScoreByIdResult) ProtoMessage() {} func (x *RequireStorageMetadataScoreByIdResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[238] + mi := &file_product_proto_msgTypes[258] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11139,7 +12040,7 @@ func (x *RequireStorageMetadataScoreByIdResult) ProtoReflect() protoreflect.Mess // Deprecated: Use RequireStorageMetadataScoreByIdResult.ProtoReflect.Descriptor instead. func (*RequireStorageMetadataScoreByIdResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{238} + return file_product_proto_rawDescGZIP(), []int{258} } func (x *RequireStorageMetadataScoreByIdResult) GetMetadataScore() float64 { @@ -11158,7 +12059,7 @@ type RequireStorageMetadataScoreByIdFields struct { func (x *RequireStorageMetadataScoreByIdFields) Reset() { *x = RequireStorageMetadataScoreByIdFields{} - mi := &file_product_proto_msgTypes[239] + mi := &file_product_proto_msgTypes[259] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11170,7 +12071,7 @@ func (x *RequireStorageMetadataScoreByIdFields) String() string { func (*RequireStorageMetadataScoreByIdFields) ProtoMessage() {} func (x *RequireStorageMetadataScoreByIdFields) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[239] + mi := &file_product_proto_msgTypes[259] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11183,7 +12084,7 @@ func (x *RequireStorageMetadataScoreByIdFields) ProtoReflect() protoreflect.Mess // Deprecated: Use RequireStorageMetadataScoreByIdFields.ProtoReflect.Descriptor instead. func (*RequireStorageMetadataScoreByIdFields) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{239} + return file_product_proto_rawDescGZIP(), []int{259} } func (x *RequireStorageMetadataScoreByIdFields) GetMetadata() *RequireStorageMetadataScoreByIdFields_StorageMetadata { @@ -11203,7 +12104,7 @@ type RequireStorageProcessedMetadataByIdRequest struct { func (x *RequireStorageProcessedMetadataByIdRequest) Reset() { *x = RequireStorageProcessedMetadataByIdRequest{} - mi := &file_product_proto_msgTypes[240] + mi := &file_product_proto_msgTypes[260] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11215,7 +12116,7 @@ func (x *RequireStorageProcessedMetadataByIdRequest) String() string { func (*RequireStorageProcessedMetadataByIdRequest) ProtoMessage() {} func (x *RequireStorageProcessedMetadataByIdRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[240] + mi := &file_product_proto_msgTypes[260] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11228,7 +12129,7 @@ func (x *RequireStorageProcessedMetadataByIdRequest) ProtoReflect() protoreflect // Deprecated: Use RequireStorageProcessedMetadataByIdRequest.ProtoReflect.Descriptor instead. func (*RequireStorageProcessedMetadataByIdRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{240} + return file_product_proto_rawDescGZIP(), []int{260} } func (x *RequireStorageProcessedMetadataByIdRequest) GetContext() []*RequireStorageProcessedMetadataByIdContext { @@ -11248,7 +12149,7 @@ type RequireStorageProcessedMetadataByIdContext struct { func (x *RequireStorageProcessedMetadataByIdContext) Reset() { *x = RequireStorageProcessedMetadataByIdContext{} - mi := &file_product_proto_msgTypes[241] + mi := &file_product_proto_msgTypes[261] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11260,7 +12161,7 @@ func (x *RequireStorageProcessedMetadataByIdContext) String() string { func (*RequireStorageProcessedMetadataByIdContext) ProtoMessage() {} func (x *RequireStorageProcessedMetadataByIdContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[241] + mi := &file_product_proto_msgTypes[261] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11273,7 +12174,7 @@ func (x *RequireStorageProcessedMetadataByIdContext) ProtoReflect() protoreflect // Deprecated: Use RequireStorageProcessedMetadataByIdContext.ProtoReflect.Descriptor instead. func (*RequireStorageProcessedMetadataByIdContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{241} + return file_product_proto_rawDescGZIP(), []int{261} } func (x *RequireStorageProcessedMetadataByIdContext) GetKey() *LookupStorageByIdRequestKey { @@ -11300,7 +12201,7 @@ type RequireStorageProcessedMetadataByIdResponse struct { func (x *RequireStorageProcessedMetadataByIdResponse) Reset() { *x = RequireStorageProcessedMetadataByIdResponse{} - mi := &file_product_proto_msgTypes[242] + mi := &file_product_proto_msgTypes[262] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11312,7 +12213,7 @@ func (x *RequireStorageProcessedMetadataByIdResponse) String() string { func (*RequireStorageProcessedMetadataByIdResponse) ProtoMessage() {} func (x *RequireStorageProcessedMetadataByIdResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[242] + mi := &file_product_proto_msgTypes[262] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11325,7 +12226,7 @@ func (x *RequireStorageProcessedMetadataByIdResponse) ProtoReflect() protoreflec // Deprecated: Use RequireStorageProcessedMetadataByIdResponse.ProtoReflect.Descriptor instead. func (*RequireStorageProcessedMetadataByIdResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{242} + return file_product_proto_rawDescGZIP(), []int{262} } func (x *RequireStorageProcessedMetadataByIdResponse) GetResult() []*RequireStorageProcessedMetadataByIdResult { @@ -11344,7 +12245,7 @@ type RequireStorageProcessedMetadataByIdResult struct { func (x *RequireStorageProcessedMetadataByIdResult) Reset() { *x = RequireStorageProcessedMetadataByIdResult{} - mi := &file_product_proto_msgTypes[243] + mi := &file_product_proto_msgTypes[263] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11356,7 +12257,7 @@ func (x *RequireStorageProcessedMetadataByIdResult) String() string { func (*RequireStorageProcessedMetadataByIdResult) ProtoMessage() {} func (x *RequireStorageProcessedMetadataByIdResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[243] + mi := &file_product_proto_msgTypes[263] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11369,7 +12270,7 @@ func (x *RequireStorageProcessedMetadataByIdResult) ProtoReflect() protoreflect. // Deprecated: Use RequireStorageProcessedMetadataByIdResult.ProtoReflect.Descriptor instead. func (*RequireStorageProcessedMetadataByIdResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{243} + return file_product_proto_rawDescGZIP(), []int{263} } func (x *RequireStorageProcessedMetadataByIdResult) GetProcessedMetadata() *StorageMetadata { @@ -11388,7 +12289,7 @@ type RequireStorageProcessedMetadataByIdFields struct { func (x *RequireStorageProcessedMetadataByIdFields) Reset() { *x = RequireStorageProcessedMetadataByIdFields{} - mi := &file_product_proto_msgTypes[244] + mi := &file_product_proto_msgTypes[264] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11400,7 +12301,7 @@ func (x *RequireStorageProcessedMetadataByIdFields) String() string { func (*RequireStorageProcessedMetadataByIdFields) ProtoMessage() {} func (x *RequireStorageProcessedMetadataByIdFields) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[244] + mi := &file_product_proto_msgTypes[264] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11413,7 +12314,7 @@ func (x *RequireStorageProcessedMetadataByIdFields) ProtoReflect() protoreflect. // Deprecated: Use RequireStorageProcessedMetadataByIdFields.ProtoReflect.Descriptor instead. func (*RequireStorageProcessedMetadataByIdFields) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{244} + return file_product_proto_rawDescGZIP(), []int{264} } func (x *RequireStorageProcessedMetadataByIdFields) GetMetadata() *RequireStorageProcessedMetadataByIdFields_StorageMetadata { @@ -11433,7 +12334,7 @@ type RequireStorageOptionalProcessedMetadataByIdRequest struct { func (x *RequireStorageOptionalProcessedMetadataByIdRequest) Reset() { *x = RequireStorageOptionalProcessedMetadataByIdRequest{} - mi := &file_product_proto_msgTypes[245] + mi := &file_product_proto_msgTypes[265] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11445,7 +12346,7 @@ func (x *RequireStorageOptionalProcessedMetadataByIdRequest) String() string { func (*RequireStorageOptionalProcessedMetadataByIdRequest) ProtoMessage() {} func (x *RequireStorageOptionalProcessedMetadataByIdRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[245] + mi := &file_product_proto_msgTypes[265] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11458,7 +12359,7 @@ func (x *RequireStorageOptionalProcessedMetadataByIdRequest) ProtoReflect() prot // Deprecated: Use RequireStorageOptionalProcessedMetadataByIdRequest.ProtoReflect.Descriptor instead. func (*RequireStorageOptionalProcessedMetadataByIdRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{245} + return file_product_proto_rawDescGZIP(), []int{265} } func (x *RequireStorageOptionalProcessedMetadataByIdRequest) GetContext() []*RequireStorageOptionalProcessedMetadataByIdContext { @@ -11478,7 +12379,7 @@ type RequireStorageOptionalProcessedMetadataByIdContext struct { func (x *RequireStorageOptionalProcessedMetadataByIdContext) Reset() { *x = RequireStorageOptionalProcessedMetadataByIdContext{} - mi := &file_product_proto_msgTypes[246] + mi := &file_product_proto_msgTypes[266] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11490,7 +12391,7 @@ func (x *RequireStorageOptionalProcessedMetadataByIdContext) String() string { func (*RequireStorageOptionalProcessedMetadataByIdContext) ProtoMessage() {} func (x *RequireStorageOptionalProcessedMetadataByIdContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[246] + mi := &file_product_proto_msgTypes[266] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11503,7 +12404,7 @@ func (x *RequireStorageOptionalProcessedMetadataByIdContext) ProtoReflect() prot // Deprecated: Use RequireStorageOptionalProcessedMetadataByIdContext.ProtoReflect.Descriptor instead. func (*RequireStorageOptionalProcessedMetadataByIdContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{246} + return file_product_proto_rawDescGZIP(), []int{266} } func (x *RequireStorageOptionalProcessedMetadataByIdContext) GetKey() *LookupStorageByIdRequestKey { @@ -11530,7 +12431,7 @@ type RequireStorageOptionalProcessedMetadataByIdResponse struct { func (x *RequireStorageOptionalProcessedMetadataByIdResponse) Reset() { *x = RequireStorageOptionalProcessedMetadataByIdResponse{} - mi := &file_product_proto_msgTypes[247] + mi := &file_product_proto_msgTypes[267] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11542,7 +12443,7 @@ func (x *RequireStorageOptionalProcessedMetadataByIdResponse) String() string { func (*RequireStorageOptionalProcessedMetadataByIdResponse) ProtoMessage() {} func (x *RequireStorageOptionalProcessedMetadataByIdResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[247] + mi := &file_product_proto_msgTypes[267] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11555,7 +12456,7 @@ func (x *RequireStorageOptionalProcessedMetadataByIdResponse) ProtoReflect() pro // Deprecated: Use RequireStorageOptionalProcessedMetadataByIdResponse.ProtoReflect.Descriptor instead. func (*RequireStorageOptionalProcessedMetadataByIdResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{247} + return file_product_proto_rawDescGZIP(), []int{267} } func (x *RequireStorageOptionalProcessedMetadataByIdResponse) GetResult() []*RequireStorageOptionalProcessedMetadataByIdResult { @@ -11574,7 +12475,7 @@ type RequireStorageOptionalProcessedMetadataByIdResult struct { func (x *RequireStorageOptionalProcessedMetadataByIdResult) Reset() { *x = RequireStorageOptionalProcessedMetadataByIdResult{} - mi := &file_product_proto_msgTypes[248] + mi := &file_product_proto_msgTypes[268] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11586,7 +12487,7 @@ func (x *RequireStorageOptionalProcessedMetadataByIdResult) String() string { func (*RequireStorageOptionalProcessedMetadataByIdResult) ProtoMessage() {} func (x *RequireStorageOptionalProcessedMetadataByIdResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[248] + mi := &file_product_proto_msgTypes[268] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11599,7 +12500,7 @@ func (x *RequireStorageOptionalProcessedMetadataByIdResult) ProtoReflect() proto // Deprecated: Use RequireStorageOptionalProcessedMetadataByIdResult.ProtoReflect.Descriptor instead. func (*RequireStorageOptionalProcessedMetadataByIdResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{248} + return file_product_proto_rawDescGZIP(), []int{268} } func (x *RequireStorageOptionalProcessedMetadataByIdResult) GetOptionalProcessedMetadata() *StorageMetadata { @@ -11618,7 +12519,7 @@ type RequireStorageOptionalProcessedMetadataByIdFields struct { func (x *RequireStorageOptionalProcessedMetadataByIdFields) Reset() { *x = RequireStorageOptionalProcessedMetadataByIdFields{} - mi := &file_product_proto_msgTypes[249] + mi := &file_product_proto_msgTypes[269] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11630,7 +12531,7 @@ func (x *RequireStorageOptionalProcessedMetadataByIdFields) String() string { func (*RequireStorageOptionalProcessedMetadataByIdFields) ProtoMessage() {} func (x *RequireStorageOptionalProcessedMetadataByIdFields) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[249] + mi := &file_product_proto_msgTypes[269] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11643,7 +12544,7 @@ func (x *RequireStorageOptionalProcessedMetadataByIdFields) ProtoReflect() proto // Deprecated: Use RequireStorageOptionalProcessedMetadataByIdFields.ProtoReflect.Descriptor instead. func (*RequireStorageOptionalProcessedMetadataByIdFields) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{249} + return file_product_proto_rawDescGZIP(), []int{269} } func (x *RequireStorageOptionalProcessedMetadataByIdFields) GetMetadata() *RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata { @@ -11663,7 +12564,7 @@ type RequireStorageProcessedTagsByIdRequest struct { func (x *RequireStorageProcessedTagsByIdRequest) Reset() { *x = RequireStorageProcessedTagsByIdRequest{} - mi := &file_product_proto_msgTypes[250] + mi := &file_product_proto_msgTypes[270] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11675,7 +12576,7 @@ func (x *RequireStorageProcessedTagsByIdRequest) String() string { func (*RequireStorageProcessedTagsByIdRequest) ProtoMessage() {} func (x *RequireStorageProcessedTagsByIdRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[250] + mi := &file_product_proto_msgTypes[270] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11688,7 +12589,7 @@ func (x *RequireStorageProcessedTagsByIdRequest) ProtoReflect() protoreflect.Mes // Deprecated: Use RequireStorageProcessedTagsByIdRequest.ProtoReflect.Descriptor instead. func (*RequireStorageProcessedTagsByIdRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{250} + return file_product_proto_rawDescGZIP(), []int{270} } func (x *RequireStorageProcessedTagsByIdRequest) GetContext() []*RequireStorageProcessedTagsByIdContext { @@ -11708,7 +12609,7 @@ type RequireStorageProcessedTagsByIdContext struct { func (x *RequireStorageProcessedTagsByIdContext) Reset() { *x = RequireStorageProcessedTagsByIdContext{} - mi := &file_product_proto_msgTypes[251] + mi := &file_product_proto_msgTypes[271] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11720,7 +12621,7 @@ func (x *RequireStorageProcessedTagsByIdContext) String() string { func (*RequireStorageProcessedTagsByIdContext) ProtoMessage() {} func (x *RequireStorageProcessedTagsByIdContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[251] + mi := &file_product_proto_msgTypes[271] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11733,7 +12634,7 @@ func (x *RequireStorageProcessedTagsByIdContext) ProtoReflect() protoreflect.Mes // Deprecated: Use RequireStorageProcessedTagsByIdContext.ProtoReflect.Descriptor instead. func (*RequireStorageProcessedTagsByIdContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{251} + return file_product_proto_rawDescGZIP(), []int{271} } func (x *RequireStorageProcessedTagsByIdContext) GetKey() *LookupStorageByIdRequestKey { @@ -11760,7 +12661,7 @@ type RequireStorageProcessedTagsByIdResponse struct { func (x *RequireStorageProcessedTagsByIdResponse) Reset() { *x = RequireStorageProcessedTagsByIdResponse{} - mi := &file_product_proto_msgTypes[252] + mi := &file_product_proto_msgTypes[272] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11772,7 +12673,7 @@ func (x *RequireStorageProcessedTagsByIdResponse) String() string { func (*RequireStorageProcessedTagsByIdResponse) ProtoMessage() {} func (x *RequireStorageProcessedTagsByIdResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[252] + mi := &file_product_proto_msgTypes[272] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11785,7 +12686,7 @@ func (x *RequireStorageProcessedTagsByIdResponse) ProtoReflect() protoreflect.Me // Deprecated: Use RequireStorageProcessedTagsByIdResponse.ProtoReflect.Descriptor instead. func (*RequireStorageProcessedTagsByIdResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{252} + return file_product_proto_rawDescGZIP(), []int{272} } func (x *RequireStorageProcessedTagsByIdResponse) GetResult() []*RequireStorageProcessedTagsByIdResult { @@ -11804,7 +12705,7 @@ type RequireStorageProcessedTagsByIdResult struct { func (x *RequireStorageProcessedTagsByIdResult) Reset() { *x = RequireStorageProcessedTagsByIdResult{} - mi := &file_product_proto_msgTypes[253] + mi := &file_product_proto_msgTypes[273] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11816,7 +12717,7 @@ func (x *RequireStorageProcessedTagsByIdResult) String() string { func (*RequireStorageProcessedTagsByIdResult) ProtoMessage() {} func (x *RequireStorageProcessedTagsByIdResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[253] + mi := &file_product_proto_msgTypes[273] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11829,7 +12730,7 @@ func (x *RequireStorageProcessedTagsByIdResult) ProtoReflect() protoreflect.Mess // Deprecated: Use RequireStorageProcessedTagsByIdResult.ProtoReflect.Descriptor instead. func (*RequireStorageProcessedTagsByIdResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{253} + return file_product_proto_rawDescGZIP(), []int{273} } func (x *RequireStorageProcessedTagsByIdResult) GetProcessedTags() []string { @@ -11848,7 +12749,7 @@ type RequireStorageProcessedTagsByIdFields struct { func (x *RequireStorageProcessedTagsByIdFields) Reset() { *x = RequireStorageProcessedTagsByIdFields{} - mi := &file_product_proto_msgTypes[254] + mi := &file_product_proto_msgTypes[274] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11860,7 +12761,7 @@ func (x *RequireStorageProcessedTagsByIdFields) String() string { func (*RequireStorageProcessedTagsByIdFields) ProtoMessage() {} func (x *RequireStorageProcessedTagsByIdFields) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[254] + mi := &file_product_proto_msgTypes[274] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11873,7 +12774,7 @@ func (x *RequireStorageProcessedTagsByIdFields) ProtoReflect() protoreflect.Mess // Deprecated: Use RequireStorageProcessedTagsByIdFields.ProtoReflect.Descriptor instead. func (*RequireStorageProcessedTagsByIdFields) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{254} + return file_product_proto_rawDescGZIP(), []int{274} } func (x *RequireStorageProcessedTagsByIdFields) GetTags() []string { @@ -11893,7 +12794,7 @@ type RequireStorageOptionalProcessedTagsByIdRequest struct { func (x *RequireStorageOptionalProcessedTagsByIdRequest) Reset() { *x = RequireStorageOptionalProcessedTagsByIdRequest{} - mi := &file_product_proto_msgTypes[255] + mi := &file_product_proto_msgTypes[275] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11905,7 +12806,7 @@ func (x *RequireStorageOptionalProcessedTagsByIdRequest) String() string { func (*RequireStorageOptionalProcessedTagsByIdRequest) ProtoMessage() {} func (x *RequireStorageOptionalProcessedTagsByIdRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[255] + mi := &file_product_proto_msgTypes[275] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11918,7 +12819,7 @@ func (x *RequireStorageOptionalProcessedTagsByIdRequest) ProtoReflect() protoref // Deprecated: Use RequireStorageOptionalProcessedTagsByIdRequest.ProtoReflect.Descriptor instead. func (*RequireStorageOptionalProcessedTagsByIdRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{255} + return file_product_proto_rawDescGZIP(), []int{275} } func (x *RequireStorageOptionalProcessedTagsByIdRequest) GetContext() []*RequireStorageOptionalProcessedTagsByIdContext { @@ -11938,7 +12839,7 @@ type RequireStorageOptionalProcessedTagsByIdContext struct { func (x *RequireStorageOptionalProcessedTagsByIdContext) Reset() { *x = RequireStorageOptionalProcessedTagsByIdContext{} - mi := &file_product_proto_msgTypes[256] + mi := &file_product_proto_msgTypes[276] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11950,7 +12851,7 @@ func (x *RequireStorageOptionalProcessedTagsByIdContext) String() string { func (*RequireStorageOptionalProcessedTagsByIdContext) ProtoMessage() {} func (x *RequireStorageOptionalProcessedTagsByIdContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[256] + mi := &file_product_proto_msgTypes[276] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11963,7 +12864,7 @@ func (x *RequireStorageOptionalProcessedTagsByIdContext) ProtoReflect() protoref // Deprecated: Use RequireStorageOptionalProcessedTagsByIdContext.ProtoReflect.Descriptor instead. func (*RequireStorageOptionalProcessedTagsByIdContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{256} + return file_product_proto_rawDescGZIP(), []int{276} } func (x *RequireStorageOptionalProcessedTagsByIdContext) GetKey() *LookupStorageByIdRequestKey { @@ -11990,7 +12891,7 @@ type RequireStorageOptionalProcessedTagsByIdResponse struct { func (x *RequireStorageOptionalProcessedTagsByIdResponse) Reset() { *x = RequireStorageOptionalProcessedTagsByIdResponse{} - mi := &file_product_proto_msgTypes[257] + mi := &file_product_proto_msgTypes[277] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12002,7 +12903,7 @@ func (x *RequireStorageOptionalProcessedTagsByIdResponse) String() string { func (*RequireStorageOptionalProcessedTagsByIdResponse) ProtoMessage() {} func (x *RequireStorageOptionalProcessedTagsByIdResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[257] + mi := &file_product_proto_msgTypes[277] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12015,7 +12916,7 @@ func (x *RequireStorageOptionalProcessedTagsByIdResponse) ProtoReflect() protore // Deprecated: Use RequireStorageOptionalProcessedTagsByIdResponse.ProtoReflect.Descriptor instead. func (*RequireStorageOptionalProcessedTagsByIdResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{257} + return file_product_proto_rawDescGZIP(), []int{277} } func (x *RequireStorageOptionalProcessedTagsByIdResponse) GetResult() []*RequireStorageOptionalProcessedTagsByIdResult { @@ -12034,7 +12935,7 @@ type RequireStorageOptionalProcessedTagsByIdResult struct { func (x *RequireStorageOptionalProcessedTagsByIdResult) Reset() { *x = RequireStorageOptionalProcessedTagsByIdResult{} - mi := &file_product_proto_msgTypes[258] + mi := &file_product_proto_msgTypes[278] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12046,7 +12947,7 @@ func (x *RequireStorageOptionalProcessedTagsByIdResult) String() string { func (*RequireStorageOptionalProcessedTagsByIdResult) ProtoMessage() {} func (x *RequireStorageOptionalProcessedTagsByIdResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[258] + mi := &file_product_proto_msgTypes[278] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12059,7 +12960,7 @@ func (x *RequireStorageOptionalProcessedTagsByIdResult) ProtoReflect() protorefl // Deprecated: Use RequireStorageOptionalProcessedTagsByIdResult.ProtoReflect.Descriptor instead. func (*RequireStorageOptionalProcessedTagsByIdResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{258} + return file_product_proto_rawDescGZIP(), []int{278} } func (x *RequireStorageOptionalProcessedTagsByIdResult) GetOptionalProcessedTags() *ListOfString { @@ -12078,7 +12979,7 @@ type RequireStorageOptionalProcessedTagsByIdFields struct { func (x *RequireStorageOptionalProcessedTagsByIdFields) Reset() { *x = RequireStorageOptionalProcessedTagsByIdFields{} - mi := &file_product_proto_msgTypes[259] + mi := &file_product_proto_msgTypes[279] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12090,7 +12991,7 @@ func (x *RequireStorageOptionalProcessedTagsByIdFields) String() string { func (*RequireStorageOptionalProcessedTagsByIdFields) ProtoMessage() {} func (x *RequireStorageOptionalProcessedTagsByIdFields) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[259] + mi := &file_product_proto_msgTypes[279] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12103,7 +13004,7 @@ func (x *RequireStorageOptionalProcessedTagsByIdFields) ProtoReflect() protorefl // Deprecated: Use RequireStorageOptionalProcessedTagsByIdFields.ProtoReflect.Descriptor instead. func (*RequireStorageOptionalProcessedTagsByIdFields) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{259} + return file_product_proto_rawDescGZIP(), []int{279} } func (x *RequireStorageOptionalProcessedTagsByIdFields) GetOptionalTags() *ListOfString { @@ -12123,7 +13024,7 @@ type RequireStorageProcessedMetadataHistoryByIdRequest struct { func (x *RequireStorageProcessedMetadataHistoryByIdRequest) Reset() { *x = RequireStorageProcessedMetadataHistoryByIdRequest{} - mi := &file_product_proto_msgTypes[260] + mi := &file_product_proto_msgTypes[280] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12135,7 +13036,7 @@ func (x *RequireStorageProcessedMetadataHistoryByIdRequest) String() string { func (*RequireStorageProcessedMetadataHistoryByIdRequest) ProtoMessage() {} func (x *RequireStorageProcessedMetadataHistoryByIdRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[260] + mi := &file_product_proto_msgTypes[280] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12148,7 +13049,7 @@ func (x *RequireStorageProcessedMetadataHistoryByIdRequest) ProtoReflect() proto // Deprecated: Use RequireStorageProcessedMetadataHistoryByIdRequest.ProtoReflect.Descriptor instead. func (*RequireStorageProcessedMetadataHistoryByIdRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{260} + return file_product_proto_rawDescGZIP(), []int{280} } func (x *RequireStorageProcessedMetadataHistoryByIdRequest) GetContext() []*RequireStorageProcessedMetadataHistoryByIdContext { @@ -12168,7 +13069,7 @@ type RequireStorageProcessedMetadataHistoryByIdContext struct { func (x *RequireStorageProcessedMetadataHistoryByIdContext) Reset() { *x = RequireStorageProcessedMetadataHistoryByIdContext{} - mi := &file_product_proto_msgTypes[261] + mi := &file_product_proto_msgTypes[281] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12180,7 +13081,7 @@ func (x *RequireStorageProcessedMetadataHistoryByIdContext) String() string { func (*RequireStorageProcessedMetadataHistoryByIdContext) ProtoMessage() {} func (x *RequireStorageProcessedMetadataHistoryByIdContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[261] + mi := &file_product_proto_msgTypes[281] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12193,7 +13094,7 @@ func (x *RequireStorageProcessedMetadataHistoryByIdContext) ProtoReflect() proto // Deprecated: Use RequireStorageProcessedMetadataHistoryByIdContext.ProtoReflect.Descriptor instead. func (*RequireStorageProcessedMetadataHistoryByIdContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{261} + return file_product_proto_rawDescGZIP(), []int{281} } func (x *RequireStorageProcessedMetadataHistoryByIdContext) GetKey() *LookupStorageByIdRequestKey { @@ -12220,7 +13121,7 @@ type RequireStorageProcessedMetadataHistoryByIdResponse struct { func (x *RequireStorageProcessedMetadataHistoryByIdResponse) Reset() { *x = RequireStorageProcessedMetadataHistoryByIdResponse{} - mi := &file_product_proto_msgTypes[262] + mi := &file_product_proto_msgTypes[282] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12232,7 +13133,7 @@ func (x *RequireStorageProcessedMetadataHistoryByIdResponse) String() string { func (*RequireStorageProcessedMetadataHistoryByIdResponse) ProtoMessage() {} func (x *RequireStorageProcessedMetadataHistoryByIdResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[262] + mi := &file_product_proto_msgTypes[282] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12245,7 +13146,7 @@ func (x *RequireStorageProcessedMetadataHistoryByIdResponse) ProtoReflect() prot // Deprecated: Use RequireStorageProcessedMetadataHistoryByIdResponse.ProtoReflect.Descriptor instead. func (*RequireStorageProcessedMetadataHistoryByIdResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{262} + return file_product_proto_rawDescGZIP(), []int{282} } func (x *RequireStorageProcessedMetadataHistoryByIdResponse) GetResult() []*RequireStorageProcessedMetadataHistoryByIdResult { @@ -12264,7 +13165,7 @@ type RequireStorageProcessedMetadataHistoryByIdResult struct { func (x *RequireStorageProcessedMetadataHistoryByIdResult) Reset() { *x = RequireStorageProcessedMetadataHistoryByIdResult{} - mi := &file_product_proto_msgTypes[263] + mi := &file_product_proto_msgTypes[283] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12276,7 +13177,7 @@ func (x *RequireStorageProcessedMetadataHistoryByIdResult) String() string { func (*RequireStorageProcessedMetadataHistoryByIdResult) ProtoMessage() {} func (x *RequireStorageProcessedMetadataHistoryByIdResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[263] + mi := &file_product_proto_msgTypes[283] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12289,7 +13190,7 @@ func (x *RequireStorageProcessedMetadataHistoryByIdResult) ProtoReflect() protor // Deprecated: Use RequireStorageProcessedMetadataHistoryByIdResult.ProtoReflect.Descriptor instead. func (*RequireStorageProcessedMetadataHistoryByIdResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{263} + return file_product_proto_rawDescGZIP(), []int{283} } func (x *RequireStorageProcessedMetadataHistoryByIdResult) GetProcessedMetadataHistory() []*StorageMetadata { @@ -12308,7 +13209,7 @@ type RequireStorageProcessedMetadataHistoryByIdFields struct { func (x *RequireStorageProcessedMetadataHistoryByIdFields) Reset() { *x = RequireStorageProcessedMetadataHistoryByIdFields{} - mi := &file_product_proto_msgTypes[264] + mi := &file_product_proto_msgTypes[284] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12320,7 +13221,7 @@ func (x *RequireStorageProcessedMetadataHistoryByIdFields) String() string { func (*RequireStorageProcessedMetadataHistoryByIdFields) ProtoMessage() {} func (x *RequireStorageProcessedMetadataHistoryByIdFields) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[264] + mi := &file_product_proto_msgTypes[284] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12333,7 +13234,7 @@ func (x *RequireStorageProcessedMetadataHistoryByIdFields) ProtoReflect() protor // Deprecated: Use RequireStorageProcessedMetadataHistoryByIdFields.ProtoReflect.Descriptor instead. func (*RequireStorageProcessedMetadataHistoryByIdFields) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{264} + return file_product_proto_rawDescGZIP(), []int{284} } func (x *RequireStorageProcessedMetadataHistoryByIdFields) GetMetadataHistory() []*RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata { @@ -12353,7 +13254,7 @@ type RequireStorageKindSummaryByIdRequest struct { func (x *RequireStorageKindSummaryByIdRequest) Reset() { *x = RequireStorageKindSummaryByIdRequest{} - mi := &file_product_proto_msgTypes[265] + mi := &file_product_proto_msgTypes[285] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12365,7 +13266,7 @@ func (x *RequireStorageKindSummaryByIdRequest) String() string { func (*RequireStorageKindSummaryByIdRequest) ProtoMessage() {} func (x *RequireStorageKindSummaryByIdRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[265] + mi := &file_product_proto_msgTypes[285] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12378,7 +13279,7 @@ func (x *RequireStorageKindSummaryByIdRequest) ProtoReflect() protoreflect.Messa // Deprecated: Use RequireStorageKindSummaryByIdRequest.ProtoReflect.Descriptor instead. func (*RequireStorageKindSummaryByIdRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{265} + return file_product_proto_rawDescGZIP(), []int{285} } func (x *RequireStorageKindSummaryByIdRequest) GetContext() []*RequireStorageKindSummaryByIdContext { @@ -12398,7 +13299,7 @@ type RequireStorageKindSummaryByIdContext struct { func (x *RequireStorageKindSummaryByIdContext) Reset() { *x = RequireStorageKindSummaryByIdContext{} - mi := &file_product_proto_msgTypes[266] + mi := &file_product_proto_msgTypes[286] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12410,7 +13311,7 @@ func (x *RequireStorageKindSummaryByIdContext) String() string { func (*RequireStorageKindSummaryByIdContext) ProtoMessage() {} func (x *RequireStorageKindSummaryByIdContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[266] + mi := &file_product_proto_msgTypes[286] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12423,7 +13324,7 @@ func (x *RequireStorageKindSummaryByIdContext) ProtoReflect() protoreflect.Messa // Deprecated: Use RequireStorageKindSummaryByIdContext.ProtoReflect.Descriptor instead. func (*RequireStorageKindSummaryByIdContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{266} + return file_product_proto_rawDescGZIP(), []int{286} } func (x *RequireStorageKindSummaryByIdContext) GetKey() *LookupStorageByIdRequestKey { @@ -12450,7 +13351,7 @@ type RequireStorageKindSummaryByIdResponse struct { func (x *RequireStorageKindSummaryByIdResponse) Reset() { *x = RequireStorageKindSummaryByIdResponse{} - mi := &file_product_proto_msgTypes[267] + mi := &file_product_proto_msgTypes[287] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12462,7 +13363,7 @@ func (x *RequireStorageKindSummaryByIdResponse) String() string { func (*RequireStorageKindSummaryByIdResponse) ProtoMessage() {} func (x *RequireStorageKindSummaryByIdResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[267] + mi := &file_product_proto_msgTypes[287] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12475,7 +13376,7 @@ func (x *RequireStorageKindSummaryByIdResponse) ProtoReflect() protoreflect.Mess // Deprecated: Use RequireStorageKindSummaryByIdResponse.ProtoReflect.Descriptor instead. func (*RequireStorageKindSummaryByIdResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{267} + return file_product_proto_rawDescGZIP(), []int{287} } func (x *RequireStorageKindSummaryByIdResponse) GetResult() []*RequireStorageKindSummaryByIdResult { @@ -12494,7 +13395,7 @@ type RequireStorageKindSummaryByIdResult struct { func (x *RequireStorageKindSummaryByIdResult) Reset() { *x = RequireStorageKindSummaryByIdResult{} - mi := &file_product_proto_msgTypes[268] + mi := &file_product_proto_msgTypes[288] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12506,7 +13407,7 @@ func (x *RequireStorageKindSummaryByIdResult) String() string { func (*RequireStorageKindSummaryByIdResult) ProtoMessage() {} func (x *RequireStorageKindSummaryByIdResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[268] + mi := &file_product_proto_msgTypes[288] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12519,7 +13420,7 @@ func (x *RequireStorageKindSummaryByIdResult) ProtoReflect() protoreflect.Messag // Deprecated: Use RequireStorageKindSummaryByIdResult.ProtoReflect.Descriptor instead. func (*RequireStorageKindSummaryByIdResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{268} + return file_product_proto_rawDescGZIP(), []int{288} } func (x *RequireStorageKindSummaryByIdResult) GetKindSummary() string { @@ -12538,7 +13439,7 @@ type RequireStorageKindSummaryByIdFields struct { func (x *RequireStorageKindSummaryByIdFields) Reset() { *x = RequireStorageKindSummaryByIdFields{} - mi := &file_product_proto_msgTypes[269] + mi := &file_product_proto_msgTypes[289] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12550,7 +13451,7 @@ func (x *RequireStorageKindSummaryByIdFields) String() string { func (*RequireStorageKindSummaryByIdFields) ProtoMessage() {} func (x *RequireStorageKindSummaryByIdFields) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[269] + mi := &file_product_proto_msgTypes[289] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12563,7 +13464,7 @@ func (x *RequireStorageKindSummaryByIdFields) ProtoReflect() protoreflect.Messag // Deprecated: Use RequireStorageKindSummaryByIdFields.ProtoReflect.Descriptor instead. func (*RequireStorageKindSummaryByIdFields) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{269} + return file_product_proto_rawDescGZIP(), []int{289} } func (x *RequireStorageKindSummaryByIdFields) GetStorageKind() CategoryKind { @@ -12583,7 +13484,7 @@ type RequireStorageCategoryInfoSummaryByIdRequest struct { func (x *RequireStorageCategoryInfoSummaryByIdRequest) Reset() { *x = RequireStorageCategoryInfoSummaryByIdRequest{} - mi := &file_product_proto_msgTypes[270] + mi := &file_product_proto_msgTypes[290] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12595,7 +13496,7 @@ func (x *RequireStorageCategoryInfoSummaryByIdRequest) String() string { func (*RequireStorageCategoryInfoSummaryByIdRequest) ProtoMessage() {} func (x *RequireStorageCategoryInfoSummaryByIdRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[270] + mi := &file_product_proto_msgTypes[290] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12608,7 +13509,7 @@ func (x *RequireStorageCategoryInfoSummaryByIdRequest) ProtoReflect() protorefle // Deprecated: Use RequireStorageCategoryInfoSummaryByIdRequest.ProtoReflect.Descriptor instead. func (*RequireStorageCategoryInfoSummaryByIdRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{270} + return file_product_proto_rawDescGZIP(), []int{290} } func (x *RequireStorageCategoryInfoSummaryByIdRequest) GetContext() []*RequireStorageCategoryInfoSummaryByIdContext { @@ -12628,7 +13529,7 @@ type RequireStorageCategoryInfoSummaryByIdContext struct { func (x *RequireStorageCategoryInfoSummaryByIdContext) Reset() { *x = RequireStorageCategoryInfoSummaryByIdContext{} - mi := &file_product_proto_msgTypes[271] + mi := &file_product_proto_msgTypes[291] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12640,7 +13541,7 @@ func (x *RequireStorageCategoryInfoSummaryByIdContext) String() string { func (*RequireStorageCategoryInfoSummaryByIdContext) ProtoMessage() {} func (x *RequireStorageCategoryInfoSummaryByIdContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[271] + mi := &file_product_proto_msgTypes[291] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12653,7 +13554,7 @@ func (x *RequireStorageCategoryInfoSummaryByIdContext) ProtoReflect() protorefle // Deprecated: Use RequireStorageCategoryInfoSummaryByIdContext.ProtoReflect.Descriptor instead. func (*RequireStorageCategoryInfoSummaryByIdContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{271} + return file_product_proto_rawDescGZIP(), []int{291} } func (x *RequireStorageCategoryInfoSummaryByIdContext) GetKey() *LookupStorageByIdRequestKey { @@ -12680,7 +13581,7 @@ type RequireStorageCategoryInfoSummaryByIdResponse struct { func (x *RequireStorageCategoryInfoSummaryByIdResponse) Reset() { *x = RequireStorageCategoryInfoSummaryByIdResponse{} - mi := &file_product_proto_msgTypes[272] + mi := &file_product_proto_msgTypes[292] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12692,7 +13593,7 @@ func (x *RequireStorageCategoryInfoSummaryByIdResponse) String() string { func (*RequireStorageCategoryInfoSummaryByIdResponse) ProtoMessage() {} func (x *RequireStorageCategoryInfoSummaryByIdResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[272] + mi := &file_product_proto_msgTypes[292] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12705,7 +13606,7 @@ func (x *RequireStorageCategoryInfoSummaryByIdResponse) ProtoReflect() protorefl // Deprecated: Use RequireStorageCategoryInfoSummaryByIdResponse.ProtoReflect.Descriptor instead. func (*RequireStorageCategoryInfoSummaryByIdResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{272} + return file_product_proto_rawDescGZIP(), []int{292} } func (x *RequireStorageCategoryInfoSummaryByIdResponse) GetResult() []*RequireStorageCategoryInfoSummaryByIdResult { @@ -12724,7 +13625,7 @@ type RequireStorageCategoryInfoSummaryByIdResult struct { func (x *RequireStorageCategoryInfoSummaryByIdResult) Reset() { *x = RequireStorageCategoryInfoSummaryByIdResult{} - mi := &file_product_proto_msgTypes[273] + mi := &file_product_proto_msgTypes[293] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12736,7 +13637,7 @@ func (x *RequireStorageCategoryInfoSummaryByIdResult) String() string { func (*RequireStorageCategoryInfoSummaryByIdResult) ProtoMessage() {} func (x *RequireStorageCategoryInfoSummaryByIdResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[273] + mi := &file_product_proto_msgTypes[293] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12749,7 +13650,7 @@ func (x *RequireStorageCategoryInfoSummaryByIdResult) ProtoReflect() protoreflec // Deprecated: Use RequireStorageCategoryInfoSummaryByIdResult.ProtoReflect.Descriptor instead. func (*RequireStorageCategoryInfoSummaryByIdResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{273} + return file_product_proto_rawDescGZIP(), []int{293} } func (x *RequireStorageCategoryInfoSummaryByIdResult) GetCategoryInfoSummary() string { @@ -12768,7 +13669,7 @@ type RequireStorageCategoryInfoSummaryByIdFields struct { func (x *RequireStorageCategoryInfoSummaryByIdFields) Reset() { *x = RequireStorageCategoryInfoSummaryByIdFields{} - mi := &file_product_proto_msgTypes[274] + mi := &file_product_proto_msgTypes[294] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12780,7 +13681,7 @@ func (x *RequireStorageCategoryInfoSummaryByIdFields) String() string { func (*RequireStorageCategoryInfoSummaryByIdFields) ProtoMessage() {} func (x *RequireStorageCategoryInfoSummaryByIdFields) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[274] + mi := &file_product_proto_msgTypes[294] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12793,7 +13694,7 @@ func (x *RequireStorageCategoryInfoSummaryByIdFields) ProtoReflect() protoreflec // Deprecated: Use RequireStorageCategoryInfoSummaryByIdFields.ProtoReflect.Descriptor instead. func (*RequireStorageCategoryInfoSummaryByIdFields) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{274} + return file_product_proto_rawDescGZIP(), []int{294} } func (x *RequireStorageCategoryInfoSummaryByIdFields) GetCategoryInfo() *RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo { @@ -12813,7 +13714,7 @@ type RequireWarehouseStockHealthScoreByIdRequest struct { func (x *RequireWarehouseStockHealthScoreByIdRequest) Reset() { *x = RequireWarehouseStockHealthScoreByIdRequest{} - mi := &file_product_proto_msgTypes[275] + mi := &file_product_proto_msgTypes[295] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12825,7 +13726,7 @@ func (x *RequireWarehouseStockHealthScoreByIdRequest) String() string { func (*RequireWarehouseStockHealthScoreByIdRequest) ProtoMessage() {} func (x *RequireWarehouseStockHealthScoreByIdRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[275] + mi := &file_product_proto_msgTypes[295] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12838,7 +13739,7 @@ func (x *RequireWarehouseStockHealthScoreByIdRequest) ProtoReflect() protoreflec // Deprecated: Use RequireWarehouseStockHealthScoreByIdRequest.ProtoReflect.Descriptor instead. func (*RequireWarehouseStockHealthScoreByIdRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{275} + return file_product_proto_rawDescGZIP(), []int{295} } func (x *RequireWarehouseStockHealthScoreByIdRequest) GetContext() []*RequireWarehouseStockHealthScoreByIdContext { @@ -12858,7 +13759,7 @@ type RequireWarehouseStockHealthScoreByIdContext struct { func (x *RequireWarehouseStockHealthScoreByIdContext) Reset() { *x = RequireWarehouseStockHealthScoreByIdContext{} - mi := &file_product_proto_msgTypes[276] + mi := &file_product_proto_msgTypes[296] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12870,7 +13771,7 @@ func (x *RequireWarehouseStockHealthScoreByIdContext) String() string { func (*RequireWarehouseStockHealthScoreByIdContext) ProtoMessage() {} func (x *RequireWarehouseStockHealthScoreByIdContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[276] + mi := &file_product_proto_msgTypes[296] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12883,7 +13784,7 @@ func (x *RequireWarehouseStockHealthScoreByIdContext) ProtoReflect() protoreflec // Deprecated: Use RequireWarehouseStockHealthScoreByIdContext.ProtoReflect.Descriptor instead. func (*RequireWarehouseStockHealthScoreByIdContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{276} + return file_product_proto_rawDescGZIP(), []int{296} } func (x *RequireWarehouseStockHealthScoreByIdContext) GetKey() *LookupWarehouseByIdRequestKey { @@ -12910,7 +13811,7 @@ type RequireWarehouseStockHealthScoreByIdResponse struct { func (x *RequireWarehouseStockHealthScoreByIdResponse) Reset() { *x = RequireWarehouseStockHealthScoreByIdResponse{} - mi := &file_product_proto_msgTypes[277] + mi := &file_product_proto_msgTypes[297] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12922,7 +13823,7 @@ func (x *RequireWarehouseStockHealthScoreByIdResponse) String() string { func (*RequireWarehouseStockHealthScoreByIdResponse) ProtoMessage() {} func (x *RequireWarehouseStockHealthScoreByIdResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[277] + mi := &file_product_proto_msgTypes[297] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12935,7 +13836,7 @@ func (x *RequireWarehouseStockHealthScoreByIdResponse) ProtoReflect() protorefle // Deprecated: Use RequireWarehouseStockHealthScoreByIdResponse.ProtoReflect.Descriptor instead. func (*RequireWarehouseStockHealthScoreByIdResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{277} + return file_product_proto_rawDescGZIP(), []int{297} } func (x *RequireWarehouseStockHealthScoreByIdResponse) GetResult() []*RequireWarehouseStockHealthScoreByIdResult { @@ -12954,7 +13855,7 @@ type RequireWarehouseStockHealthScoreByIdResult struct { func (x *RequireWarehouseStockHealthScoreByIdResult) Reset() { *x = RequireWarehouseStockHealthScoreByIdResult{} - mi := &file_product_proto_msgTypes[278] + mi := &file_product_proto_msgTypes[298] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12966,7 +13867,7 @@ func (x *RequireWarehouseStockHealthScoreByIdResult) String() string { func (*RequireWarehouseStockHealthScoreByIdResult) ProtoMessage() {} func (x *RequireWarehouseStockHealthScoreByIdResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[278] + mi := &file_product_proto_msgTypes[298] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12979,7 +13880,7 @@ func (x *RequireWarehouseStockHealthScoreByIdResult) ProtoReflect() protoreflect // Deprecated: Use RequireWarehouseStockHealthScoreByIdResult.ProtoReflect.Descriptor instead. func (*RequireWarehouseStockHealthScoreByIdResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{278} + return file_product_proto_rawDescGZIP(), []int{298} } func (x *RequireWarehouseStockHealthScoreByIdResult) GetStockHealthScore() float64 { @@ -12999,7 +13900,7 @@ type RequireWarehouseStockHealthScoreByIdFields struct { func (x *RequireWarehouseStockHealthScoreByIdFields) Reset() { *x = RequireWarehouseStockHealthScoreByIdFields{} - mi := &file_product_proto_msgTypes[279] + mi := &file_product_proto_msgTypes[299] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13011,7 +13912,7 @@ func (x *RequireWarehouseStockHealthScoreByIdFields) String() string { func (*RequireWarehouseStockHealthScoreByIdFields) ProtoMessage() {} func (x *RequireWarehouseStockHealthScoreByIdFields) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[279] + mi := &file_product_proto_msgTypes[299] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13024,7 +13925,7 @@ func (x *RequireWarehouseStockHealthScoreByIdFields) ProtoReflect() protoreflect // Deprecated: Use RequireWarehouseStockHealthScoreByIdFields.ProtoReflect.Descriptor instead. func (*RequireWarehouseStockHealthScoreByIdFields) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{279} + return file_product_proto_rawDescGZIP(), []int{299} } func (x *RequireWarehouseStockHealthScoreByIdFields) GetInventoryCount() int32 { @@ -13052,7 +13953,7 @@ type Product struct { func (x *Product) Reset() { *x = Product{} - mi := &file_product_proto_msgTypes[280] + mi := &file_product_proto_msgTypes[300] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13064,7 +13965,7 @@ func (x *Product) String() string { func (*Product) ProtoMessage() {} func (x *Product) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[280] + mi := &file_product_proto_msgTypes[300] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13077,7 +13978,7 @@ func (x *Product) ProtoReflect() protoreflect.Message { // Deprecated: Use Product.ProtoReflect.Descriptor instead. func (*Product) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{280} + return file_product_proto_rawDescGZIP(), []int{300} } func (x *Product) GetId() string { @@ -13112,7 +14013,7 @@ type Storage struct { func (x *Storage) Reset() { *x = Storage{} - mi := &file_product_proto_msgTypes[281] + mi := &file_product_proto_msgTypes[301] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13124,7 +14025,7 @@ func (x *Storage) String() string { func (*Storage) ProtoMessage() {} func (x *Storage) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[281] + mi := &file_product_proto_msgTypes[301] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13137,7 +14038,7 @@ func (x *Storage) ProtoReflect() protoreflect.Message { // Deprecated: Use Storage.ProtoReflect.Descriptor instead. func (*Storage) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{281} + return file_product_proto_rawDescGZIP(), []int{301} } func (x *Storage) GetId() string { @@ -13172,7 +14073,7 @@ type Warehouse struct { func (x *Warehouse) Reset() { *x = Warehouse{} - mi := &file_product_proto_msgTypes[282] + mi := &file_product_proto_msgTypes[302] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13184,7 +14085,7 @@ func (x *Warehouse) String() string { func (*Warehouse) ProtoMessage() {} func (x *Warehouse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[282] + mi := &file_product_proto_msgTypes[302] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13197,7 +14098,7 @@ func (x *Warehouse) ProtoReflect() protoreflect.Message { // Deprecated: Use Warehouse.ProtoReflect.Descriptor instead. func (*Warehouse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{282} + return file_product_proto_rawDescGZIP(), []int{302} } func (x *Warehouse) GetId() string { @@ -13231,7 +14132,7 @@ type User struct { func (x *User) Reset() { *x = User{} - mi := &file_product_proto_msgTypes[283] + mi := &file_product_proto_msgTypes[303] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13243,7 +14144,7 @@ func (x *User) String() string { func (*User) ProtoMessage() {} func (x *User) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[283] + mi := &file_product_proto_msgTypes[303] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13256,7 +14157,7 @@ func (x *User) ProtoReflect() protoreflect.Message { // Deprecated: Use User.ProtoReflect.Descriptor instead. func (*User) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{283} + return file_product_proto_rawDescGZIP(), []int{303} } func (x *User) GetId() string { @@ -13284,7 +14185,7 @@ type NestedTypeA struct { func (x *NestedTypeA) Reset() { *x = NestedTypeA{} - mi := &file_product_proto_msgTypes[284] + mi := &file_product_proto_msgTypes[304] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13296,7 +14197,7 @@ func (x *NestedTypeA) String() string { func (*NestedTypeA) ProtoMessage() {} func (x *NestedTypeA) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[284] + mi := &file_product_proto_msgTypes[304] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13309,7 +14210,7 @@ func (x *NestedTypeA) ProtoReflect() protoreflect.Message { // Deprecated: Use NestedTypeA.ProtoReflect.Descriptor instead. func (*NestedTypeA) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{284} + return file_product_proto_rawDescGZIP(), []int{304} } func (x *NestedTypeA) GetId() string { @@ -13344,7 +14245,7 @@ type RecursiveType struct { func (x *RecursiveType) Reset() { *x = RecursiveType{} - mi := &file_product_proto_msgTypes[285] + mi := &file_product_proto_msgTypes[305] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13356,7 +14257,7 @@ func (x *RecursiveType) String() string { func (*RecursiveType) ProtoMessage() {} func (x *RecursiveType) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[285] + mi := &file_product_proto_msgTypes[305] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13369,7 +14270,7 @@ func (x *RecursiveType) ProtoReflect() protoreflect.Message { // Deprecated: Use RecursiveType.ProtoReflect.Descriptor instead. func (*RecursiveType) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{285} + return file_product_proto_rawDescGZIP(), []int{305} } func (x *RecursiveType) GetId() string { @@ -13405,7 +14306,7 @@ type TypeWithMultipleFilterFields struct { func (x *TypeWithMultipleFilterFields) Reset() { *x = TypeWithMultipleFilterFields{} - mi := &file_product_proto_msgTypes[286] + mi := &file_product_proto_msgTypes[306] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13417,7 +14318,7 @@ func (x *TypeWithMultipleFilterFields) String() string { func (*TypeWithMultipleFilterFields) ProtoMessage() {} func (x *TypeWithMultipleFilterFields) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[286] + mi := &file_product_proto_msgTypes[306] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13430,7 +14331,7 @@ func (x *TypeWithMultipleFilterFields) ProtoReflect() protoreflect.Message { // Deprecated: Use TypeWithMultipleFilterFields.ProtoReflect.Descriptor instead. func (*TypeWithMultipleFilterFields) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{286} + return file_product_proto_rawDescGZIP(), []int{306} } func (x *TypeWithMultipleFilterFields) GetId() string { @@ -13471,7 +14372,7 @@ type FilterTypeInput struct { func (x *FilterTypeInput) Reset() { *x = FilterTypeInput{} - mi := &file_product_proto_msgTypes[287] + mi := &file_product_proto_msgTypes[307] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13483,7 +14384,7 @@ func (x *FilterTypeInput) String() string { func (*FilterTypeInput) ProtoMessage() {} func (x *FilterTypeInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[287] + mi := &file_product_proto_msgTypes[307] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13496,7 +14397,7 @@ func (x *FilterTypeInput) ProtoReflect() protoreflect.Message { // Deprecated: Use FilterTypeInput.ProtoReflect.Descriptor instead. func (*FilterTypeInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{287} + return file_product_proto_rawDescGZIP(), []int{307} } func (x *FilterTypeInput) GetFilterField_1() string { @@ -13522,7 +14423,7 @@ type ComplexFilterTypeInput struct { func (x *ComplexFilterTypeInput) Reset() { *x = ComplexFilterTypeInput{} - mi := &file_product_proto_msgTypes[288] + mi := &file_product_proto_msgTypes[308] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13534,7 +14435,7 @@ func (x *ComplexFilterTypeInput) String() string { func (*ComplexFilterTypeInput) ProtoMessage() {} func (x *ComplexFilterTypeInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[288] + mi := &file_product_proto_msgTypes[308] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13547,7 +14448,7 @@ func (x *ComplexFilterTypeInput) ProtoReflect() protoreflect.Message { // Deprecated: Use ComplexFilterTypeInput.ProtoReflect.Descriptor instead. func (*ComplexFilterTypeInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{288} + return file_product_proto_rawDescGZIP(), []int{308} } func (x *ComplexFilterTypeInput) GetFilter() *FilterType { @@ -13567,7 +14468,7 @@ type TypeWithComplexFilterInput struct { func (x *TypeWithComplexFilterInput) Reset() { *x = TypeWithComplexFilterInput{} - mi := &file_product_proto_msgTypes[289] + mi := &file_product_proto_msgTypes[309] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13579,7 +14480,7 @@ func (x *TypeWithComplexFilterInput) String() string { func (*TypeWithComplexFilterInput) ProtoMessage() {} func (x *TypeWithComplexFilterInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[289] + mi := &file_product_proto_msgTypes[309] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13592,7 +14493,7 @@ func (x *TypeWithComplexFilterInput) ProtoReflect() protoreflect.Message { // Deprecated: Use TypeWithComplexFilterInput.ProtoReflect.Descriptor instead. func (*TypeWithComplexFilterInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{289} + return file_product_proto_rawDescGZIP(), []int{309} } func (x *TypeWithComplexFilterInput) GetId() string { @@ -13620,7 +14521,7 @@ type OrderInput struct { func (x *OrderInput) Reset() { *x = OrderInput{} - mi := &file_product_proto_msgTypes[290] + mi := &file_product_proto_msgTypes[310] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13632,7 +14533,7 @@ func (x *OrderInput) String() string { func (*OrderInput) ProtoMessage() {} func (x *OrderInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[290] + mi := &file_product_proto_msgTypes[310] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13645,7 +14546,7 @@ func (x *OrderInput) ProtoReflect() protoreflect.Message { // Deprecated: Use OrderInput.ProtoReflect.Descriptor instead. func (*OrderInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{290} + return file_product_proto_rawDescGZIP(), []int{310} } func (x *OrderInput) GetOrderId() string { @@ -13681,7 +14582,7 @@ type Order struct { func (x *Order) Reset() { *x = Order{} - mi := &file_product_proto_msgTypes[291] + mi := &file_product_proto_msgTypes[311] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13693,7 +14594,7 @@ func (x *Order) String() string { func (*Order) ProtoMessage() {} func (x *Order) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[291] + mi := &file_product_proto_msgTypes[311] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13706,7 +14607,7 @@ func (x *Order) ProtoReflect() protoreflect.Message { // Deprecated: Use Order.ProtoReflect.Descriptor instead. func (*Order) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{291} + return file_product_proto_rawDescGZIP(), []int{311} } func (x *Order) GetOrderId() string { @@ -13750,7 +14651,7 @@ type Category struct { func (x *Category) Reset() { *x = Category{} - mi := &file_product_proto_msgTypes[292] + mi := &file_product_proto_msgTypes[312] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13762,7 +14663,7 @@ func (x *Category) String() string { func (*Category) ProtoMessage() {} func (x *Category) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[292] + mi := &file_product_proto_msgTypes[312] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13775,7 +14676,7 @@ func (x *Category) ProtoReflect() protoreflect.Message { // Deprecated: Use Category.ProtoReflect.Descriptor instead. func (*Category) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{292} + return file_product_proto_rawDescGZIP(), []int{312} } func (x *Category) GetId() string { @@ -13823,7 +14724,7 @@ type CategoryFilter struct { func (x *CategoryFilter) Reset() { *x = CategoryFilter{} - mi := &file_product_proto_msgTypes[293] + mi := &file_product_proto_msgTypes[313] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13835,7 +14736,7 @@ func (x *CategoryFilter) String() string { func (*CategoryFilter) ProtoMessage() {} func (x *CategoryFilter) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[293] + mi := &file_product_proto_msgTypes[313] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13848,7 +14749,7 @@ func (x *CategoryFilter) ProtoReflect() protoreflect.Message { // Deprecated: Use CategoryFilter.ProtoReflect.Descriptor instead. func (*CategoryFilter) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{293} + return file_product_proto_rawDescGZIP(), []int{313} } func (x *CategoryFilter) GetCategory() CategoryKind { @@ -13878,7 +14779,7 @@ type Animal struct { func (x *Animal) Reset() { *x = Animal{} - mi := &file_product_proto_msgTypes[294] + mi := &file_product_proto_msgTypes[314] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13890,7 +14791,7 @@ func (x *Animal) String() string { func (*Animal) ProtoMessage() {} func (x *Animal) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[294] + mi := &file_product_proto_msgTypes[314] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13903,7 +14804,7 @@ func (x *Animal) ProtoReflect() protoreflect.Message { // Deprecated: Use Animal.ProtoReflect.Descriptor instead. func (*Animal) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{294} + return file_product_proto_rawDescGZIP(), []int{314} } func (x *Animal) GetInstance() isAnimal_Instance { @@ -13957,7 +14858,7 @@ type SearchInput struct { func (x *SearchInput) Reset() { *x = SearchInput{} - mi := &file_product_proto_msgTypes[295] + mi := &file_product_proto_msgTypes[315] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13969,7 +14870,7 @@ func (x *SearchInput) String() string { func (*SearchInput) ProtoMessage() {} func (x *SearchInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[295] + mi := &file_product_proto_msgTypes[315] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13982,7 +14883,7 @@ func (x *SearchInput) ProtoReflect() protoreflect.Message { // Deprecated: Use SearchInput.ProtoReflect.Descriptor instead. func (*SearchInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{295} + return file_product_proto_rawDescGZIP(), []int{315} } func (x *SearchInput) GetQuery() string { @@ -14013,7 +14914,7 @@ type SearchResult struct { func (x *SearchResult) Reset() { *x = SearchResult{} - mi := &file_product_proto_msgTypes[296] + mi := &file_product_proto_msgTypes[316] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14025,7 +14926,7 @@ func (x *SearchResult) String() string { func (*SearchResult) ProtoMessage() {} func (x *SearchResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[296] + mi := &file_product_proto_msgTypes[316] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14038,7 +14939,7 @@ func (x *SearchResult) ProtoReflect() protoreflect.Message { // Deprecated: Use SearchResult.ProtoReflect.Descriptor instead. func (*SearchResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{296} + return file_product_proto_rawDescGZIP(), []int{316} } func (x *SearchResult) GetValue() isSearchResult_Value { @@ -14113,7 +15014,7 @@ type NullableFieldsType struct { func (x *NullableFieldsType) Reset() { *x = NullableFieldsType{} - mi := &file_product_proto_msgTypes[297] + mi := &file_product_proto_msgTypes[317] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14125,7 +15026,7 @@ func (x *NullableFieldsType) String() string { func (*NullableFieldsType) ProtoMessage() {} func (x *NullableFieldsType) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[297] + mi := &file_product_proto_msgTypes[317] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14138,7 +15039,7 @@ func (x *NullableFieldsType) ProtoReflect() protoreflect.Message { // Deprecated: Use NullableFieldsType.ProtoReflect.Descriptor instead. func (*NullableFieldsType) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{297} + return file_product_proto_rawDescGZIP(), []int{317} } func (x *NullableFieldsType) GetId() string { @@ -14208,7 +15109,7 @@ type NullableFieldsFilter struct { func (x *NullableFieldsFilter) Reset() { *x = NullableFieldsFilter{} - mi := &file_product_proto_msgTypes[298] + mi := &file_product_proto_msgTypes[318] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14220,7 +15121,7 @@ func (x *NullableFieldsFilter) String() string { func (*NullableFieldsFilter) ProtoMessage() {} func (x *NullableFieldsFilter) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[298] + mi := &file_product_proto_msgTypes[318] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14233,7 +15134,7 @@ func (x *NullableFieldsFilter) ProtoReflect() protoreflect.Message { // Deprecated: Use NullableFieldsFilter.ProtoReflect.Descriptor instead. func (*NullableFieldsFilter) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{298} + return file_product_proto_rawDescGZIP(), []int{318} } func (x *NullableFieldsFilter) GetName() *wrapperspb.StringValue { @@ -14285,7 +15186,7 @@ type BlogPost struct { func (x *BlogPost) Reset() { *x = BlogPost{} - mi := &file_product_proto_msgTypes[299] + mi := &file_product_proto_msgTypes[319] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14297,7 +15198,7 @@ func (x *BlogPost) String() string { func (*BlogPost) ProtoMessage() {} func (x *BlogPost) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[299] + mi := &file_product_proto_msgTypes[319] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14310,7 +15211,7 @@ func (x *BlogPost) ProtoReflect() protoreflect.Message { // Deprecated: Use BlogPost.ProtoReflect.Descriptor instead. func (*BlogPost) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{299} + return file_product_proto_rawDescGZIP(), []int{319} } func (x *BlogPost) GetId() string { @@ -14464,7 +15365,7 @@ type BlogPostFilter struct { func (x *BlogPostFilter) Reset() { *x = BlogPostFilter{} - mi := &file_product_proto_msgTypes[300] + mi := &file_product_proto_msgTypes[320] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14476,7 +15377,7 @@ func (x *BlogPostFilter) String() string { func (*BlogPostFilter) ProtoMessage() {} func (x *BlogPostFilter) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[300] + mi := &file_product_proto_msgTypes[320] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14489,7 +15390,7 @@ func (x *BlogPostFilter) ProtoReflect() protoreflect.Message { // Deprecated: Use BlogPostFilter.ProtoReflect.Descriptor instead. func (*BlogPostFilter) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{300} + return file_product_proto_rawDescGZIP(), []int{320} } func (x *BlogPostFilter) GetTitle() *wrapperspb.StringValue { @@ -14536,7 +15437,7 @@ type Author struct { func (x *Author) Reset() { *x = Author{} - mi := &file_product_proto_msgTypes[301] + mi := &file_product_proto_msgTypes[321] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14548,7 +15449,7 @@ func (x *Author) String() string { func (*Author) ProtoMessage() {} func (x *Author) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[301] + mi := &file_product_proto_msgTypes[321] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14561,7 +15462,7 @@ func (x *Author) ProtoReflect() protoreflect.Message { // Deprecated: Use Author.ProtoReflect.Descriptor instead. func (*Author) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{301} + return file_product_proto_rawDescGZIP(), []int{321} } func (x *Author) GetId() string { @@ -14680,7 +15581,7 @@ type AuthorFilter struct { func (x *AuthorFilter) Reset() { *x = AuthorFilter{} - mi := &file_product_proto_msgTypes[302] + mi := &file_product_proto_msgTypes[322] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14692,7 +15593,7 @@ func (x *AuthorFilter) String() string { func (*AuthorFilter) ProtoMessage() {} func (x *AuthorFilter) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[302] + mi := &file_product_proto_msgTypes[322] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14705,7 +15606,7 @@ func (x *AuthorFilter) ProtoReflect() protoreflect.Message { // Deprecated: Use AuthorFilter.ProtoReflect.Descriptor instead. func (*AuthorFilter) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{302} + return file_product_proto_rawDescGZIP(), []int{322} } func (x *AuthorFilter) GetName() *wrapperspb.StringValue { @@ -14740,7 +15641,7 @@ type TestContainer struct { func (x *TestContainer) Reset() { *x = TestContainer{} - mi := &file_product_proto_msgTypes[303] + mi := &file_product_proto_msgTypes[323] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14752,7 +15653,7 @@ func (x *TestContainer) String() string { func (*TestContainer) ProtoMessage() {} func (x *TestContainer) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[303] + mi := &file_product_proto_msgTypes[323] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14765,7 +15666,7 @@ func (x *TestContainer) ProtoReflect() protoreflect.Message { // Deprecated: Use TestContainer.ProtoReflect.Descriptor instead. func (*TestContainer) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{303} + return file_product_proto_rawDescGZIP(), []int{323} } func (x *TestContainer) GetId() string { @@ -14798,7 +15699,7 @@ type UserInput struct { func (x *UserInput) Reset() { *x = UserInput{} - mi := &file_product_proto_msgTypes[304] + mi := &file_product_proto_msgTypes[324] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14810,7 +15711,7 @@ func (x *UserInput) String() string { func (*UserInput) ProtoMessage() {} func (x *UserInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[304] + mi := &file_product_proto_msgTypes[324] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14823,7 +15724,7 @@ func (x *UserInput) ProtoReflect() protoreflect.Message { // Deprecated: Use UserInput.ProtoReflect.Descriptor instead. func (*UserInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{304} + return file_product_proto_rawDescGZIP(), []int{324} } func (x *UserInput) GetName() string { @@ -14843,7 +15744,7 @@ type ActionInput struct { func (x *ActionInput) Reset() { *x = ActionInput{} - mi := &file_product_proto_msgTypes[305] + mi := &file_product_proto_msgTypes[325] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14855,7 +15756,7 @@ func (x *ActionInput) String() string { func (*ActionInput) ProtoMessage() {} func (x *ActionInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[305] + mi := &file_product_proto_msgTypes[325] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14868,7 +15769,7 @@ func (x *ActionInput) ProtoReflect() protoreflect.Message { // Deprecated: Use ActionInput.ProtoReflect.Descriptor instead. func (*ActionInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{305} + return file_product_proto_rawDescGZIP(), []int{325} } func (x *ActionInput) GetType() string { @@ -14898,7 +15799,7 @@ type ActionResult struct { func (x *ActionResult) Reset() { *x = ActionResult{} - mi := &file_product_proto_msgTypes[306] + mi := &file_product_proto_msgTypes[326] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14910,7 +15811,7 @@ func (x *ActionResult) String() string { func (*ActionResult) ProtoMessage() {} func (x *ActionResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[306] + mi := &file_product_proto_msgTypes[326] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14923,7 +15824,7 @@ func (x *ActionResult) ProtoReflect() protoreflect.Message { // Deprecated: Use ActionResult.ProtoReflect.Descriptor instead. func (*ActionResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{306} + return file_product_proto_rawDescGZIP(), []int{326} } func (x *ActionResult) GetValue() isActionResult_Value { @@ -14982,7 +15883,7 @@ type NullableFieldsInput struct { func (x *NullableFieldsInput) Reset() { *x = NullableFieldsInput{} - mi := &file_product_proto_msgTypes[307] + mi := &file_product_proto_msgTypes[327] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14994,7 +15895,7 @@ func (x *NullableFieldsInput) String() string { func (*NullableFieldsInput) ProtoMessage() {} func (x *NullableFieldsInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[307] + mi := &file_product_proto_msgTypes[327] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15007,7 +15908,7 @@ func (x *NullableFieldsInput) ProtoReflect() protoreflect.Message { // Deprecated: Use NullableFieldsInput.ProtoReflect.Descriptor instead. func (*NullableFieldsInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{307} + return file_product_proto_rawDescGZIP(), []int{327} } func (x *NullableFieldsInput) GetName() string { @@ -15083,7 +15984,7 @@ type BlogPostInput struct { func (x *BlogPostInput) Reset() { *x = BlogPostInput{} - mi := &file_product_proto_msgTypes[308] + mi := &file_product_proto_msgTypes[328] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15095,7 +15996,7 @@ func (x *BlogPostInput) String() string { func (*BlogPostInput) ProtoMessage() {} func (x *BlogPostInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[308] + mi := &file_product_proto_msgTypes[328] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15108,7 +16009,7 @@ func (x *BlogPostInput) ProtoReflect() protoreflect.Message { // Deprecated: Use BlogPostInput.ProtoReflect.Descriptor instead. func (*BlogPostInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{308} + return file_product_proto_rawDescGZIP(), []int{328} } func (x *BlogPostInput) GetTitle() string { @@ -15241,7 +16142,7 @@ type AuthorInput struct { func (x *AuthorInput) Reset() { *x = AuthorInput{} - mi := &file_product_proto_msgTypes[309] + mi := &file_product_proto_msgTypes[329] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15253,7 +16154,7 @@ func (x *AuthorInput) String() string { func (*AuthorInput) ProtoMessage() {} func (x *AuthorInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[309] + mi := &file_product_proto_msgTypes[329] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15266,7 +16167,7 @@ func (x *AuthorInput) ProtoReflect() protoreflect.Message { // Deprecated: Use AuthorInput.ProtoReflect.Descriptor instead. func (*AuthorInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{309} + return file_product_proto_rawDescGZIP(), []int{329} } func (x *AuthorInput) GetName() string { @@ -15351,7 +16252,7 @@ type ProductDetails struct { func (x *ProductDetails) Reset() { *x = ProductDetails{} - mi := &file_product_proto_msgTypes[310] + mi := &file_product_proto_msgTypes[330] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15363,7 +16264,7 @@ func (x *ProductDetails) String() string { func (*ProductDetails) ProtoMessage() {} func (x *ProductDetails) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[310] + mi := &file_product_proto_msgTypes[330] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15376,7 +16277,7 @@ func (x *ProductDetails) ProtoReflect() protoreflect.Message { // Deprecated: Use ProductDetails.ProtoReflect.Descriptor instead. func (*ProductDetails) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{310} + return file_product_proto_rawDescGZIP(), []int{330} } func (x *ProductDetails) GetId() string { @@ -15416,7 +16317,7 @@ type RestockData struct { func (x *RestockData) Reset() { *x = RestockData{} - mi := &file_product_proto_msgTypes[311] + mi := &file_product_proto_msgTypes[331] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15428,7 +16329,7 @@ func (x *RestockData) String() string { func (*RestockData) ProtoMessage() {} func (x *RestockData) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[311] + mi := &file_product_proto_msgTypes[331] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15441,7 +16342,7 @@ func (x *RestockData) ProtoReflect() protoreflect.Message { // Deprecated: Use RestockData.ProtoReflect.Descriptor instead. func (*RestockData) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{311} + return file_product_proto_rawDescGZIP(), []int{331} } func (x *RestockData) GetLastRestockDate() string { @@ -15462,7 +16363,7 @@ type StorageMetadata struct { func (x *StorageMetadata) Reset() { *x = StorageMetadata{} - mi := &file_product_proto_msgTypes[312] + mi := &file_product_proto_msgTypes[332] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15474,7 +16375,7 @@ func (x *StorageMetadata) String() string { func (*StorageMetadata) ProtoMessage() {} func (x *StorageMetadata) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[312] + mi := &file_product_proto_msgTypes[332] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15487,7 +16388,7 @@ func (x *StorageMetadata) ProtoReflect() protoreflect.Message { // Deprecated: Use StorageMetadata.ProtoReflect.Descriptor instead. func (*StorageMetadata) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{312} + return file_product_proto_rawDescGZIP(), []int{332} } func (x *StorageMetadata) GetCapacity() int32 { @@ -15521,7 +16422,7 @@ type StorageCategoryInfo struct { func (x *StorageCategoryInfo) Reset() { *x = StorageCategoryInfo{} - mi := &file_product_proto_msgTypes[313] + mi := &file_product_proto_msgTypes[333] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15533,7 +16434,7 @@ func (x *StorageCategoryInfo) String() string { func (*StorageCategoryInfo) ProtoMessage() {} func (x *StorageCategoryInfo) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[313] + mi := &file_product_proto_msgTypes[333] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15546,7 +16447,7 @@ func (x *StorageCategoryInfo) ProtoReflect() protoreflect.Message { // Deprecated: Use StorageCategoryInfo.ProtoReflect.Descriptor instead. func (*StorageCategoryInfo) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{313} + return file_product_proto_rawDescGZIP(), []int{333} } func (x *StorageCategoryInfo) GetKind() CategoryKind { @@ -15574,7 +16475,7 @@ type NestedTypeB struct { func (x *NestedTypeB) Reset() { *x = NestedTypeB{} - mi := &file_product_proto_msgTypes[314] + mi := &file_product_proto_msgTypes[334] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15586,7 +16487,7 @@ func (x *NestedTypeB) String() string { func (*NestedTypeB) ProtoMessage() {} func (x *NestedTypeB) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[314] + mi := &file_product_proto_msgTypes[334] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15599,7 +16500,7 @@ func (x *NestedTypeB) ProtoReflect() protoreflect.Message { // Deprecated: Use NestedTypeB.ProtoReflect.Descriptor instead. func (*NestedTypeB) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{314} + return file_product_proto_rawDescGZIP(), []int{334} } func (x *NestedTypeB) GetId() string { @@ -15633,7 +16534,7 @@ type NestedTypeC struct { func (x *NestedTypeC) Reset() { *x = NestedTypeC{} - mi := &file_product_proto_msgTypes[315] + mi := &file_product_proto_msgTypes[335] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15645,7 +16546,7 @@ func (x *NestedTypeC) String() string { func (*NestedTypeC) ProtoMessage() {} func (x *NestedTypeC) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[315] + mi := &file_product_proto_msgTypes[335] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15658,7 +16559,7 @@ func (x *NestedTypeC) ProtoReflect() protoreflect.Message { // Deprecated: Use NestedTypeC.ProtoReflect.Descriptor instead. func (*NestedTypeC) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{315} + return file_product_proto_rawDescGZIP(), []int{335} } func (x *NestedTypeC) GetId() string { @@ -15687,7 +16588,7 @@ type FilterType struct { func (x *FilterType) Reset() { *x = FilterType{} - mi := &file_product_proto_msgTypes[316] + mi := &file_product_proto_msgTypes[336] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15699,7 +16600,7 @@ func (x *FilterType) String() string { func (*FilterType) ProtoMessage() {} func (x *FilterType) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[316] + mi := &file_product_proto_msgTypes[336] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15712,7 +16613,7 @@ func (x *FilterType) ProtoReflect() protoreflect.Message { // Deprecated: Use FilterType.ProtoReflect.Descriptor instead. func (*FilterType) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{316} + return file_product_proto_rawDescGZIP(), []int{336} } func (x *FilterType) GetName() string { @@ -15753,7 +16654,7 @@ type Pagination struct { func (x *Pagination) Reset() { *x = Pagination{} - mi := &file_product_proto_msgTypes[317] + mi := &file_product_proto_msgTypes[337] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15765,7 +16666,7 @@ func (x *Pagination) String() string { func (*Pagination) ProtoMessage() {} func (x *Pagination) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[317] + mi := &file_product_proto_msgTypes[337] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15778,7 +16679,7 @@ func (x *Pagination) ProtoReflect() protoreflect.Message { // Deprecated: Use Pagination.ProtoReflect.Descriptor instead. func (*Pagination) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{317} + return file_product_proto_rawDescGZIP(), []int{337} } func (x *Pagination) GetPage() int32 { @@ -15806,7 +16707,7 @@ type OrderLineInput struct { func (x *OrderLineInput) Reset() { *x = OrderLineInput{} - mi := &file_product_proto_msgTypes[318] + mi := &file_product_proto_msgTypes[338] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15818,7 +16719,7 @@ func (x *OrderLineInput) String() string { func (*OrderLineInput) ProtoMessage() {} func (x *OrderLineInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[318] + mi := &file_product_proto_msgTypes[338] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15831,7 +16732,7 @@ func (x *OrderLineInput) ProtoReflect() protoreflect.Message { // Deprecated: Use OrderLineInput.ProtoReflect.Descriptor instead. func (*OrderLineInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{318} + return file_product_proto_rawDescGZIP(), []int{338} } func (x *OrderLineInput) GetProductId() string { @@ -15866,7 +16767,7 @@ type OrderLine struct { func (x *OrderLine) Reset() { *x = OrderLine{} - mi := &file_product_proto_msgTypes[319] + mi := &file_product_proto_msgTypes[339] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15878,7 +16779,7 @@ func (x *OrderLine) String() string { func (*OrderLine) ProtoMessage() {} func (x *OrderLine) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[319] + mi := &file_product_proto_msgTypes[339] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15891,7 +16792,7 @@ func (x *OrderLine) ProtoReflect() protoreflect.Message { // Deprecated: Use OrderLine.ProtoReflect.Descriptor instead. func (*OrderLine) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{319} + return file_product_proto_rawDescGZIP(), []int{339} } func (x *OrderLine) GetProductId() string { @@ -15927,7 +16828,7 @@ type Subcategory struct { func (x *Subcategory) Reset() { *x = Subcategory{} - mi := &file_product_proto_msgTypes[320] + mi := &file_product_proto_msgTypes[340] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15939,7 +16840,7 @@ func (x *Subcategory) String() string { func (*Subcategory) ProtoMessage() {} func (x *Subcategory) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[320] + mi := &file_product_proto_msgTypes[340] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15952,7 +16853,7 @@ func (x *Subcategory) ProtoReflect() protoreflect.Message { // Deprecated: Use Subcategory.ProtoReflect.Descriptor instead. func (*Subcategory) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{320} + return file_product_proto_rawDescGZIP(), []int{340} } func (x *Subcategory) GetId() string { @@ -15996,7 +16897,7 @@ type CategoryMetrics struct { func (x *CategoryMetrics) Reset() { *x = CategoryMetrics{} - mi := &file_product_proto_msgTypes[321] + mi := &file_product_proto_msgTypes[341] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16008,7 +16909,7 @@ func (x *CategoryMetrics) String() string { func (*CategoryMetrics) ProtoMessage() {} func (x *CategoryMetrics) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[321] + mi := &file_product_proto_msgTypes[341] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16021,7 +16922,7 @@ func (x *CategoryMetrics) ProtoReflect() protoreflect.Message { // Deprecated: Use CategoryMetrics.ProtoReflect.Descriptor instead. func (*CategoryMetrics) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{321} + return file_product_proto_rawDescGZIP(), []int{341} } func (x *CategoryMetrics) GetId() string { @@ -16073,7 +16974,7 @@ type Cat struct { func (x *Cat) Reset() { *x = Cat{} - mi := &file_product_proto_msgTypes[322] + mi := &file_product_proto_msgTypes[342] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16085,7 +16986,7 @@ func (x *Cat) String() string { func (*Cat) ProtoMessage() {} func (x *Cat) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[322] + mi := &file_product_proto_msgTypes[342] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16098,7 +16999,7 @@ func (x *Cat) ProtoReflect() protoreflect.Message { // Deprecated: Use Cat.ProtoReflect.Descriptor instead. func (*Cat) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{322} + return file_product_proto_rawDescGZIP(), []int{342} } func (x *Cat) GetId() string { @@ -16157,7 +17058,7 @@ type Dog struct { func (x *Dog) Reset() { *x = Dog{} - mi := &file_product_proto_msgTypes[323] + mi := &file_product_proto_msgTypes[343] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16169,7 +17070,7 @@ func (x *Dog) String() string { func (*Dog) ProtoMessage() {} func (x *Dog) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[323] + mi := &file_product_proto_msgTypes[343] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16182,7 +17083,7 @@ func (x *Dog) ProtoReflect() protoreflect.Message { // Deprecated: Use Dog.ProtoReflect.Descriptor instead. func (*Dog) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{323} + return file_product_proto_rawDescGZIP(), []int{343} } func (x *Dog) GetId() string { @@ -16239,7 +17140,7 @@ type Owner struct { func (x *Owner) Reset() { *x = Owner{} - mi := &file_product_proto_msgTypes[324] + mi := &file_product_proto_msgTypes[344] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16251,7 +17152,7 @@ func (x *Owner) String() string { func (*Owner) ProtoMessage() {} func (x *Owner) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[324] + mi := &file_product_proto_msgTypes[344] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16264,7 +17165,7 @@ func (x *Owner) ProtoReflect() protoreflect.Message { // Deprecated: Use Owner.ProtoReflect.Descriptor instead. func (*Owner) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{324} + return file_product_proto_rawDescGZIP(), []int{344} } func (x *Owner) GetId() string { @@ -16306,7 +17207,7 @@ type ContactInfo struct { func (x *ContactInfo) Reset() { *x = ContactInfo{} - mi := &file_product_proto_msgTypes[325] + mi := &file_product_proto_msgTypes[345] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16318,7 +17219,7 @@ func (x *ContactInfo) String() string { func (*ContactInfo) ProtoMessage() {} func (x *ContactInfo) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[325] + mi := &file_product_proto_msgTypes[345] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16331,7 +17232,7 @@ func (x *ContactInfo) ProtoReflect() protoreflect.Message { // Deprecated: Use ContactInfo.ProtoReflect.Descriptor instead. func (*ContactInfo) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{325} + return file_product_proto_rawDescGZIP(), []int{345} } func (x *ContactInfo) GetEmail() string { @@ -16367,7 +17268,7 @@ type Address struct { func (x *Address) Reset() { *x = Address{} - mi := &file_product_proto_msgTypes[326] + mi := &file_product_proto_msgTypes[346] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16379,7 +17280,7 @@ func (x *Address) String() string { func (*Address) ProtoMessage() {} func (x *Address) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[326] + mi := &file_product_proto_msgTypes[346] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16392,7 +17293,7 @@ func (x *Address) ProtoReflect() protoreflect.Message { // Deprecated: Use Address.ProtoReflect.Descriptor instead. func (*Address) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{326} + return file_product_proto_rawDescGZIP(), []int{346} } func (x *Address) GetStreet() string { @@ -16435,7 +17336,7 @@ type CatBreed struct { func (x *CatBreed) Reset() { *x = CatBreed{} - mi := &file_product_proto_msgTypes[327] + mi := &file_product_proto_msgTypes[347] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16447,7 +17348,7 @@ func (x *CatBreed) String() string { func (*CatBreed) ProtoMessage() {} func (x *CatBreed) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[327] + mi := &file_product_proto_msgTypes[347] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16460,7 +17361,7 @@ func (x *CatBreed) ProtoReflect() protoreflect.Message { // Deprecated: Use CatBreed.ProtoReflect.Descriptor instead. func (*CatBreed) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{327} + return file_product_proto_rawDescGZIP(), []int{347} } func (x *CatBreed) GetId() string { @@ -16503,7 +17404,7 @@ type DogBreed struct { func (x *DogBreed) Reset() { *x = DogBreed{} - mi := &file_product_proto_msgTypes[328] + mi := &file_product_proto_msgTypes[348] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16515,7 +17416,7 @@ func (x *DogBreed) String() string { func (*DogBreed) ProtoMessage() {} func (x *DogBreed) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[328] + mi := &file_product_proto_msgTypes[348] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16528,7 +17429,7 @@ func (x *DogBreed) ProtoReflect() protoreflect.Message { // Deprecated: Use DogBreed.ProtoReflect.Descriptor instead. func (*DogBreed) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{328} + return file_product_proto_rawDescGZIP(), []int{348} } func (x *DogBreed) GetId() string { @@ -16570,7 +17471,7 @@ type BreedCharacteristics struct { func (x *BreedCharacteristics) Reset() { *x = BreedCharacteristics{} - mi := &file_product_proto_msgTypes[329] + mi := &file_product_proto_msgTypes[349] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16582,7 +17483,7 @@ func (x *BreedCharacteristics) String() string { func (*BreedCharacteristics) ProtoMessage() {} func (x *BreedCharacteristics) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[329] + mi := &file_product_proto_msgTypes[349] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16595,7 +17496,7 @@ func (x *BreedCharacteristics) ProtoReflect() protoreflect.Message { // Deprecated: Use BreedCharacteristics.ProtoReflect.Descriptor instead. func (*BreedCharacteristics) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{329} + return file_product_proto_rawDescGZIP(), []int{349} } func (x *BreedCharacteristics) GetSize() string { @@ -16629,7 +17530,7 @@ type ActionSuccess struct { func (x *ActionSuccess) Reset() { *x = ActionSuccess{} - mi := &file_product_proto_msgTypes[330] + mi := &file_product_proto_msgTypes[350] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16641,7 +17542,7 @@ func (x *ActionSuccess) String() string { func (*ActionSuccess) ProtoMessage() {} func (x *ActionSuccess) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[330] + mi := &file_product_proto_msgTypes[350] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16654,7 +17555,7 @@ func (x *ActionSuccess) ProtoReflect() protoreflect.Message { // Deprecated: Use ActionSuccess.ProtoReflect.Descriptor instead. func (*ActionSuccess) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{330} + return file_product_proto_rawDescGZIP(), []int{350} } func (x *ActionSuccess) GetMessage() string { @@ -16681,7 +17582,7 @@ type ActionError struct { func (x *ActionError) Reset() { *x = ActionError{} - mi := &file_product_proto_msgTypes[331] + mi := &file_product_proto_msgTypes[351] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16693,7 +17594,7 @@ func (x *ActionError) String() string { func (*ActionError) ProtoMessage() {} func (x *ActionError) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[331] + mi := &file_product_proto_msgTypes[351] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16706,7 +17607,7 @@ func (x *ActionError) ProtoReflect() protoreflect.Message { // Deprecated: Use ActionError.ProtoReflect.Descriptor instead. func (*ActionError) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{331} + return file_product_proto_rawDescGZIP(), []int{351} } func (x *ActionError) GetMessage() string { @@ -16735,7 +17636,7 @@ type TestDetails struct { func (x *TestDetails) Reset() { *x = TestDetails{} - mi := &file_product_proto_msgTypes[332] + mi := &file_product_proto_msgTypes[352] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16747,7 +17648,7 @@ func (x *TestDetails) String() string { func (*TestDetails) ProtoMessage() {} func (x *TestDetails) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[332] + mi := &file_product_proto_msgTypes[352] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16760,7 +17661,7 @@ func (x *TestDetails) ProtoReflect() protoreflect.Message { // Deprecated: Use TestDetails.ProtoReflect.Descriptor instead. func (*TestDetails) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{332} + return file_product_proto_rawDescGZIP(), []int{352} } func (x *TestDetails) GetId() string { @@ -16801,7 +17702,7 @@ type CategoryInput struct { func (x *CategoryInput) Reset() { *x = CategoryInput{} - mi := &file_product_proto_msgTypes[333] + mi := &file_product_proto_msgTypes[353] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16813,7 +17714,7 @@ func (x *CategoryInput) String() string { func (*CategoryInput) ProtoMessage() {} func (x *CategoryInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[333] + mi := &file_product_proto_msgTypes[353] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16826,7 +17727,7 @@ func (x *CategoryInput) ProtoReflect() protoreflect.Message { // Deprecated: Use CategoryInput.ProtoReflect.Descriptor instead. func (*CategoryInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{333} + return file_product_proto_rawDescGZIP(), []int{353} } func (x *CategoryInput) GetName() string { @@ -16855,7 +17756,7 @@ type ProductCountFilter struct { func (x *ProductCountFilter) Reset() { *x = ProductCountFilter{} - mi := &file_product_proto_msgTypes[334] + mi := &file_product_proto_msgTypes[354] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16867,7 +17768,7 @@ func (x *ProductCountFilter) String() string { func (*ProductCountFilter) ProtoMessage() {} func (x *ProductCountFilter) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[334] + mi := &file_product_proto_msgTypes[354] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16880,7 +17781,7 @@ func (x *ProductCountFilter) ProtoReflect() protoreflect.Message { // Deprecated: Use ProductCountFilter.ProtoReflect.Descriptor instead. func (*ProductCountFilter) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{334} + return file_product_proto_rawDescGZIP(), []int{354} } func (x *ProductCountFilter) GetMinPrice() *wrapperspb.DoubleValue { @@ -16924,7 +17825,7 @@ type SubcategoryItemFilter struct { func (x *SubcategoryItemFilter) Reset() { *x = SubcategoryItemFilter{} - mi := &file_product_proto_msgTypes[335] + mi := &file_product_proto_msgTypes[355] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16936,7 +17837,7 @@ func (x *SubcategoryItemFilter) String() string { func (*SubcategoryItemFilter) ProtoMessage() {} func (x *SubcategoryItemFilter) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[335] + mi := &file_product_proto_msgTypes[355] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16949,7 +17850,7 @@ func (x *SubcategoryItemFilter) ProtoReflect() protoreflect.Message { // Deprecated: Use SubcategoryItemFilter.ProtoReflect.Descriptor instead. func (*SubcategoryItemFilter) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{335} + return file_product_proto_rawDescGZIP(), []int{355} } func (x *SubcategoryItemFilter) GetMinPrice() *wrapperspb.DoubleValue { @@ -16998,7 +17899,7 @@ type ShippingEstimateInput struct { func (x *ShippingEstimateInput) Reset() { *x = ShippingEstimateInput{} - mi := &file_product_proto_msgTypes[336] + mi := &file_product_proto_msgTypes[356] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17010,7 +17911,7 @@ func (x *ShippingEstimateInput) String() string { func (*ShippingEstimateInput) ProtoMessage() {} func (x *ShippingEstimateInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[336] + mi := &file_product_proto_msgTypes[356] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17023,7 +17924,7 @@ func (x *ShippingEstimateInput) ProtoReflect() protoreflect.Message { // Deprecated: Use ShippingEstimateInput.ProtoReflect.Descriptor instead. func (*ShippingEstimateInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{336} + return file_product_proto_rawDescGZIP(), []int{356} } func (x *ShippingEstimateInput) GetDestination() ShippingDestination { @@ -17056,7 +17957,7 @@ type ListOfAuthorFilter_List struct { func (x *ListOfAuthorFilter_List) Reset() { *x = ListOfAuthorFilter_List{} - mi := &file_product_proto_msgTypes[337] + mi := &file_product_proto_msgTypes[357] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17068,7 +17969,7 @@ func (x *ListOfAuthorFilter_List) String() string { func (*ListOfAuthorFilter_List) ProtoMessage() {} func (x *ListOfAuthorFilter_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[337] + mi := &file_product_proto_msgTypes[357] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17100,7 +18001,7 @@ type ListOfAuthorInput_List struct { func (x *ListOfAuthorInput_List) Reset() { *x = ListOfAuthorInput_List{} - mi := &file_product_proto_msgTypes[338] + mi := &file_product_proto_msgTypes[358] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17112,7 +18013,7 @@ func (x *ListOfAuthorInput_List) String() string { func (*ListOfAuthorInput_List) ProtoMessage() {} func (x *ListOfAuthorInput_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[338] + mi := &file_product_proto_msgTypes[358] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17144,7 +18045,7 @@ type ListOfBlogPost_List struct { func (x *ListOfBlogPost_List) Reset() { *x = ListOfBlogPost_List{} - mi := &file_product_proto_msgTypes[339] + mi := &file_product_proto_msgTypes[359] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17156,7 +18057,7 @@ func (x *ListOfBlogPost_List) String() string { func (*ListOfBlogPost_List) ProtoMessage() {} func (x *ListOfBlogPost_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[339] + mi := &file_product_proto_msgTypes[359] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17188,7 +18089,7 @@ type ListOfBlogPostFilter_List struct { func (x *ListOfBlogPostFilter_List) Reset() { *x = ListOfBlogPostFilter_List{} - mi := &file_product_proto_msgTypes[340] + mi := &file_product_proto_msgTypes[360] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17200,7 +18101,7 @@ func (x *ListOfBlogPostFilter_List) String() string { func (*ListOfBlogPostFilter_List) ProtoMessage() {} func (x *ListOfBlogPostFilter_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[340] + mi := &file_product_proto_msgTypes[360] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17232,7 +18133,7 @@ type ListOfBlogPostInput_List struct { func (x *ListOfBlogPostInput_List) Reset() { *x = ListOfBlogPostInput_List{} - mi := &file_product_proto_msgTypes[341] + mi := &file_product_proto_msgTypes[361] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17244,7 +18145,7 @@ func (x *ListOfBlogPostInput_List) String() string { func (*ListOfBlogPostInput_List) ProtoMessage() {} func (x *ListOfBlogPostInput_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[341] + mi := &file_product_proto_msgTypes[361] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17276,7 +18177,7 @@ type ListOfBoolean_List struct { func (x *ListOfBoolean_List) Reset() { *x = ListOfBoolean_List{} - mi := &file_product_proto_msgTypes[342] + mi := &file_product_proto_msgTypes[362] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17288,7 +18189,7 @@ func (x *ListOfBoolean_List) String() string { func (*ListOfBoolean_List) ProtoMessage() {} func (x *ListOfBoolean_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[342] + mi := &file_product_proto_msgTypes[362] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17320,7 +18221,7 @@ type ListOfCategory_List struct { func (x *ListOfCategory_List) Reset() { *x = ListOfCategory_List{} - mi := &file_product_proto_msgTypes[343] + mi := &file_product_proto_msgTypes[363] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17332,7 +18233,7 @@ func (x *ListOfCategory_List) String() string { func (*ListOfCategory_List) ProtoMessage() {} func (x *ListOfCategory_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[343] + mi := &file_product_proto_msgTypes[363] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17364,7 +18265,7 @@ type ListOfCategoryInput_List struct { func (x *ListOfCategoryInput_List) Reset() { *x = ListOfCategoryInput_List{} - mi := &file_product_proto_msgTypes[344] + mi := &file_product_proto_msgTypes[364] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17376,7 +18277,7 @@ func (x *ListOfCategoryInput_List) String() string { func (*ListOfCategoryInput_List) ProtoMessage() {} func (x *ListOfCategoryInput_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[344] + mi := &file_product_proto_msgTypes[364] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17408,7 +18309,7 @@ type ListOfFloat_List struct { func (x *ListOfFloat_List) Reset() { *x = ListOfFloat_List{} - mi := &file_product_proto_msgTypes[345] + mi := &file_product_proto_msgTypes[365] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17420,7 +18321,7 @@ func (x *ListOfFloat_List) String() string { func (*ListOfFloat_List) ProtoMessage() {} func (x *ListOfFloat_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[345] + mi := &file_product_proto_msgTypes[365] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17452,7 +18353,7 @@ type ListOfListOfCategory_List struct { func (x *ListOfListOfCategory_List) Reset() { *x = ListOfListOfCategory_List{} - mi := &file_product_proto_msgTypes[346] + mi := &file_product_proto_msgTypes[366] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17464,7 +18365,7 @@ func (x *ListOfListOfCategory_List) String() string { func (*ListOfListOfCategory_List) ProtoMessage() {} func (x *ListOfListOfCategory_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[346] + mi := &file_product_proto_msgTypes[366] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17496,7 +18397,7 @@ type ListOfListOfCategoryInput_List struct { func (x *ListOfListOfCategoryInput_List) Reset() { *x = ListOfListOfCategoryInput_List{} - mi := &file_product_proto_msgTypes[347] + mi := &file_product_proto_msgTypes[367] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17508,7 +18409,7 @@ func (x *ListOfListOfCategoryInput_List) String() string { func (*ListOfListOfCategoryInput_List) ProtoMessage() {} func (x *ListOfListOfCategoryInput_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[347] + mi := &file_product_proto_msgTypes[367] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17540,7 +18441,7 @@ type ListOfListOfString_List struct { func (x *ListOfListOfString_List) Reset() { *x = ListOfListOfString_List{} - mi := &file_product_proto_msgTypes[348] + mi := &file_product_proto_msgTypes[368] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17552,7 +18453,7 @@ func (x *ListOfListOfString_List) String() string { func (*ListOfListOfString_List) ProtoMessage() {} func (x *ListOfListOfString_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[348] + mi := &file_product_proto_msgTypes[368] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17584,7 +18485,7 @@ type ListOfListOfUser_List struct { func (x *ListOfListOfUser_List) Reset() { *x = ListOfListOfUser_List{} - mi := &file_product_proto_msgTypes[349] + mi := &file_product_proto_msgTypes[369] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17596,7 +18497,7 @@ func (x *ListOfListOfUser_List) String() string { func (*ListOfListOfUser_List) ProtoMessage() {} func (x *ListOfListOfUser_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[349] + mi := &file_product_proto_msgTypes[369] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17628,7 +18529,7 @@ type ListOfListOfUserInput_List struct { func (x *ListOfListOfUserInput_List) Reset() { *x = ListOfListOfUserInput_List{} - mi := &file_product_proto_msgTypes[350] + mi := &file_product_proto_msgTypes[370] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17640,7 +18541,7 @@ func (x *ListOfListOfUserInput_List) String() string { func (*ListOfListOfUserInput_List) ProtoMessage() {} func (x *ListOfListOfUserInput_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[350] + mi := &file_product_proto_msgTypes[370] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17672,7 +18573,7 @@ type ListOfOrderLine_List struct { func (x *ListOfOrderLine_List) Reset() { *x = ListOfOrderLine_List{} - mi := &file_product_proto_msgTypes[351] + mi := &file_product_proto_msgTypes[371] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17684,7 +18585,7 @@ func (x *ListOfOrderLine_List) String() string { func (*ListOfOrderLine_List) ProtoMessage() {} func (x *ListOfOrderLine_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[351] + mi := &file_product_proto_msgTypes[371] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17716,7 +18617,7 @@ type ListOfProduct_List struct { func (x *ListOfProduct_List) Reset() { *x = ListOfProduct_List{} - mi := &file_product_proto_msgTypes[352] + mi := &file_product_proto_msgTypes[372] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17728,7 +18629,7 @@ func (x *ListOfProduct_List) String() string { func (*ListOfProduct_List) ProtoMessage() {} func (x *ListOfProduct_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[352] + mi := &file_product_proto_msgTypes[372] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17760,7 +18661,7 @@ type ListOfStorage_List struct { func (x *ListOfStorage_List) Reset() { *x = ListOfStorage_List{} - mi := &file_product_proto_msgTypes[353] + mi := &file_product_proto_msgTypes[373] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17772,7 +18673,7 @@ func (x *ListOfStorage_List) String() string { func (*ListOfStorage_List) ProtoMessage() {} func (x *ListOfStorage_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[353] + mi := &file_product_proto_msgTypes[373] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17804,7 +18705,7 @@ type ListOfString_List struct { func (x *ListOfString_List) Reset() { *x = ListOfString_List{} - mi := &file_product_proto_msgTypes[354] + mi := &file_product_proto_msgTypes[374] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17816,7 +18717,7 @@ func (x *ListOfString_List) String() string { func (*ListOfString_List) ProtoMessage() {} func (x *ListOfString_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[354] + mi := &file_product_proto_msgTypes[374] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17848,7 +18749,7 @@ type ListOfSubcategory_List struct { func (x *ListOfSubcategory_List) Reset() { *x = ListOfSubcategory_List{} - mi := &file_product_proto_msgTypes[355] + mi := &file_product_proto_msgTypes[375] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17860,7 +18761,7 @@ func (x *ListOfSubcategory_List) String() string { func (*ListOfSubcategory_List) ProtoMessage() {} func (x *ListOfSubcategory_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[355] + mi := &file_product_proto_msgTypes[375] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17892,7 +18793,7 @@ type ListOfUser_List struct { func (x *ListOfUser_List) Reset() { *x = ListOfUser_List{} - mi := &file_product_proto_msgTypes[356] + mi := &file_product_proto_msgTypes[376] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17904,7 +18805,7 @@ func (x *ListOfUser_List) String() string { func (*ListOfUser_List) ProtoMessage() {} func (x *ListOfUser_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[356] + mi := &file_product_proto_msgTypes[376] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17936,7 +18837,7 @@ type ListOfUserInput_List struct { func (x *ListOfUserInput_List) Reset() { *x = ListOfUserInput_List{} - mi := &file_product_proto_msgTypes[357] + mi := &file_product_proto_msgTypes[377] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17948,7 +18849,7 @@ func (x *ListOfUserInput_List) String() string { func (*ListOfUserInput_List) ProtoMessage() {} func (x *ListOfUserInput_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[357] + mi := &file_product_proto_msgTypes[377] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17980,7 +18881,7 @@ type RequireStorageStockHealthScoreByIdFields_RestockData struct { func (x *RequireStorageStockHealthScoreByIdFields_RestockData) Reset() { *x = RequireStorageStockHealthScoreByIdFields_RestockData{} - mi := &file_product_proto_msgTypes[358] + mi := &file_product_proto_msgTypes[378] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17992,7 +18893,7 @@ func (x *RequireStorageStockHealthScoreByIdFields_RestockData) String() string { func (*RequireStorageStockHealthScoreByIdFields_RestockData) ProtoMessage() {} func (x *RequireStorageStockHealthScoreByIdFields_RestockData) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[358] + mi := &file_product_proto_msgTypes[378] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18005,7 +18906,7 @@ func (x *RequireStorageStockHealthScoreByIdFields_RestockData) ProtoReflect() pr // Deprecated: Use RequireStorageStockHealthScoreByIdFields_RestockData.ProtoReflect.Descriptor instead. func (*RequireStorageStockHealthScoreByIdFields_RestockData) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{224, 0} + return file_product_proto_rawDescGZIP(), []int{244, 0} } func (x *RequireStorageStockHealthScoreByIdFields_RestockData) GetLastRestockDate() string { @@ -18025,7 +18926,7 @@ type RequireStorageMetadataScoreByIdFields_StorageMetadata struct { func (x *RequireStorageMetadataScoreByIdFields_StorageMetadata) Reset() { *x = RequireStorageMetadataScoreByIdFields_StorageMetadata{} - mi := &file_product_proto_msgTypes[359] + mi := &file_product_proto_msgTypes[379] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -18037,7 +18938,7 @@ func (x *RequireStorageMetadataScoreByIdFields_StorageMetadata) String() string func (*RequireStorageMetadataScoreByIdFields_StorageMetadata) ProtoMessage() {} func (x *RequireStorageMetadataScoreByIdFields_StorageMetadata) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[359] + mi := &file_product_proto_msgTypes[379] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18050,7 +18951,7 @@ func (x *RequireStorageMetadataScoreByIdFields_StorageMetadata) ProtoReflect() p // Deprecated: Use RequireStorageMetadataScoreByIdFields_StorageMetadata.ProtoReflect.Descriptor instead. func (*RequireStorageMetadataScoreByIdFields_StorageMetadata) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{239, 0} + return file_product_proto_rawDescGZIP(), []int{259, 0} } func (x *RequireStorageMetadataScoreByIdFields_StorageMetadata) GetCapacity() int32 { @@ -18078,7 +18979,7 @@ type RequireStorageProcessedMetadataByIdFields_StorageMetadata struct { func (x *RequireStorageProcessedMetadataByIdFields_StorageMetadata) Reset() { *x = RequireStorageProcessedMetadataByIdFields_StorageMetadata{} - mi := &file_product_proto_msgTypes[360] + mi := &file_product_proto_msgTypes[380] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -18090,7 +18991,7 @@ func (x *RequireStorageProcessedMetadataByIdFields_StorageMetadata) String() str func (*RequireStorageProcessedMetadataByIdFields_StorageMetadata) ProtoMessage() {} func (x *RequireStorageProcessedMetadataByIdFields_StorageMetadata) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[360] + mi := &file_product_proto_msgTypes[380] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18103,7 +19004,7 @@ func (x *RequireStorageProcessedMetadataByIdFields_StorageMetadata) ProtoReflect // Deprecated: Use RequireStorageProcessedMetadataByIdFields_StorageMetadata.ProtoReflect.Descriptor instead. func (*RequireStorageProcessedMetadataByIdFields_StorageMetadata) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{244, 0} + return file_product_proto_rawDescGZIP(), []int{264, 0} } func (x *RequireStorageProcessedMetadataByIdFields_StorageMetadata) GetCapacity() int32 { @@ -18137,7 +19038,7 @@ type RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata struct { func (x *RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata) Reset() { *x = RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata{} - mi := &file_product_proto_msgTypes[361] + mi := &file_product_proto_msgTypes[381] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -18149,7 +19050,7 @@ func (x *RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata) Stri func (*RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata) ProtoMessage() {} func (x *RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[361] + mi := &file_product_proto_msgTypes[381] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18162,7 +19063,7 @@ func (x *RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata) Prot // Deprecated: Use RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata.ProtoReflect.Descriptor instead. func (*RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{249, 0} + return file_product_proto_rawDescGZIP(), []int{269, 0} } func (x *RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata) GetCapacity() int32 { @@ -18189,7 +19090,7 @@ type RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata struct { func (x *RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata) Reset() { *x = RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata{} - mi := &file_product_proto_msgTypes[362] + mi := &file_product_proto_msgTypes[382] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -18201,7 +19102,7 @@ func (x *RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata) Strin func (*RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata) ProtoMessage() {} func (x *RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[362] + mi := &file_product_proto_msgTypes[382] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18214,7 +19115,7 @@ func (x *RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata) Proto // Deprecated: Use RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata.ProtoReflect.Descriptor instead. func (*RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{264, 0} + return file_product_proto_rawDescGZIP(), []int{284, 0} } func (x *RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata) GetCapacity() int32 { @@ -18241,7 +19142,7 @@ type RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo struct { func (x *RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo) Reset() { *x = RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo{} - mi := &file_product_proto_msgTypes[363] + mi := &file_product_proto_msgTypes[383] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -18253,7 +19154,7 @@ func (x *RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo) String func (*RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo) ProtoMessage() {} func (x *RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[363] + mi := &file_product_proto_msgTypes[383] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18266,7 +19167,7 @@ func (x *RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo) ProtoR // Deprecated: Use RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo.ProtoReflect.Descriptor instead. func (*RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{274, 0} + return file_product_proto_rawDescGZIP(), []int{294, 0} } func (x *RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo) GetKind() CategoryKind { @@ -18292,7 +19193,7 @@ type RequireWarehouseStockHealthScoreByIdFields_RestockData struct { func (x *RequireWarehouseStockHealthScoreByIdFields_RestockData) Reset() { *x = RequireWarehouseStockHealthScoreByIdFields_RestockData{} - mi := &file_product_proto_msgTypes[364] + mi := &file_product_proto_msgTypes[384] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -18304,7 +19205,7 @@ func (x *RequireWarehouseStockHealthScoreByIdFields_RestockData) String() string func (*RequireWarehouseStockHealthScoreByIdFields_RestockData) ProtoMessage() {} func (x *RequireWarehouseStockHealthScoreByIdFields_RestockData) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[364] + mi := &file_product_proto_msgTypes[384] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18317,7 +19218,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{279, 0} + return file_product_proto_rawDescGZIP(), []int{299, 0} } func (x *RequireWarehouseStockHealthScoreByIdFields_RestockData) GetLastRestockDate() string { @@ -18812,7 +19713,32 @@ const file_product_proto_rawDesc = "" + "'ResolveCategoryOptionalCategoriesResult\x12J\n" + "\x13optional_categories\x18\x01 \x01(\v2\x19.productv1.ListOfCategoryR\x12optionalCategories\"w\n" + ")ResolveCategoryOptionalCategoriesResponse\x12J\n" + - "\x06result\x18\x01 \x03(\v22.productv1.ResolveCategoryOptionalCategoriesResultR\x06result\"]\n" + + "\x06result\x18\x01 \x03(\v22.productv1.ResolveCategoryOptionalCategoriesResultR\x06result\"5\n" + + "#ResolveCategoryTotalProductsContext\x12\x0e\n" + + "\x02id\x18\x01 \x01(\tR\x02id\"o\n" + + "#ResolveCategoryTotalProductsRequest\x12H\n" + + "\acontext\x18\x01 \x03(\v2..productv1.ResolveCategoryTotalProductsContextR\acontext\"K\n" + + "\"ResolveCategoryTotalProductsResult\x12%\n" + + "\x0etotal_products\x18\x01 \x01(\x05R\rtotalProducts\"m\n" + + "$ResolveCategoryTotalProductsResponse\x12E\n" + + "\x06result\x18\x01 \x03(\v2-.productv1.ResolveCategoryTotalProductsResultR\x06result\"J\n" + + "$ResolveCategoryTopSubcategoryContext\x12\x0e\n" + + "\x02id\x18\x01 \x01(\tR\x02id\x12\x12\n" + + "\x04name\x18\x02 \x01(\tR\x04name\"q\n" + + "$ResolveCategoryTopSubcategoryRequest\x12I\n" + + "\acontext\x18\x01 \x03(\v2/.productv1.ResolveCategoryTopSubcategoryContextR\acontext\"f\n" + + "#ResolveCategoryTopSubcategoryResult\x12?\n" + + "\x0ftop_subcategory\x18\x01 \x01(\v2\x16.productv1.SubcategoryR\x0etopSubcategory\"o\n" + + "%ResolveCategoryTopSubcategoryResponse\x12F\n" + + "\x06result\x18\x01 \x03(\v2..productv1.ResolveCategoryTopSubcategoryResultR\x06result\";\n" + + ")ResolveCategoryActiveSubcategoriesContext\x12\x0e\n" + + "\x02id\x18\x01 \x01(\tR\x02id\"{\n" + + ")ResolveCategoryActiveSubcategoriesRequest\x12N\n" + + "\acontext\x18\x01 \x03(\v24.productv1.ResolveCategoryActiveSubcategoriesContextR\acontext\"u\n" + + "(ResolveCategoryActiveSubcategoriesResult\x12I\n" + + "\x14active_subcategories\x18\x01 \x03(\v2\x16.productv1.SubcategoryR\x13activeSubcategories\"y\n" + + "*ResolveCategoryActiveSubcategoriesResponse\x12K\n" + + "\x06result\x18\x01 \x03(\v23.productv1.ResolveCategoryActiveSubcategoriesResultR\x06result\"]\n" + "\x1fResolveSubcategoryItemCountArgs\x12:\n" + "\afilters\x18\x01 \x01(\v2 .productv1.SubcategoryItemFilterR\afilters\"4\n" + "\"ResolveSubcategoryItemCountContext\x12\x0e\n" + @@ -18837,7 +19763,15 @@ const file_product_proto_rawDesc = "" + "(ResolveSubcategoryFeaturedCategoryResult\x12@\n" + "\x11featured_category\x18\x01 \x01(\v2\x13.productv1.CategoryR\x10featuredCategory\"y\n" + "*ResolveSubcategoryFeaturedCategoryResponse\x12K\n" + - "\x06result\x18\x01 \x03(\v23.productv1.ResolveSubcategoryFeaturedCategoryResultR\x06result\"G\n" + + "\x06result\x18\x01 \x03(\v23.productv1.ResolveSubcategoryFeaturedCategoryResultR\x06result\"9\n" + + "'ResolveSubcategoryParentCategoryContext\x12\x0e\n" + + "\x02id\x18\x01 \x01(\tR\x02id\"w\n" + + "'ResolveSubcategoryParentCategoryRequest\x12L\n" + + "\acontext\x18\x01 \x03(\v22.productv1.ResolveSubcategoryParentCategoryContextR\acontext\"f\n" + + "&ResolveSubcategoryParentCategoryResult\x12<\n" + + "\x0fparent_category\x18\x01 \x01(\v2\x13.productv1.CategoryR\x0eparentCategory\"u\n" + + "(ResolveSubcategoryParentCategoryResponse\x12I\n" + + "\x06result\x18\x01 \x03(\v21.productv1.ResolveSubcategoryParentCategoryResultR\x06result\"G\n" + ")ResolveCategoryMetricsNormalizedScoreArgs\x12\x1a\n" + "\bbaseline\x18\x01 \x01(\x01R\bbaseline\"u\n" + ",ResolveCategoryMetricsNormalizedScoreContext\x12\x0e\n" + @@ -18865,7 +19799,17 @@ const file_product_proto_rawDesc = "" + "+ResolveCategoryMetricsRelatedCategoryResult\x12>\n" + "\x10related_category\x18\x01 \x01(\v2\x13.productv1.CategoryR\x0frelatedCategory\"\x7f\n" + "-ResolveCategoryMetricsRelatedCategoryResponse\x12N\n" + - "\x06result\x18\x01 \x03(\v26.productv1.ResolveCategoryMetricsRelatedCategoryResultR\x06result\"L\n" + + "\x06result\x18\x01 \x03(\v26.productv1.ResolveCategoryMetricsRelatedCategoryResultR\x06result\"\\\n" + + ")ResolveCategoryMetricsAverageScoreContext\x12\x0e\n" + + "\x02id\x18\x01 \x01(\tR\x02id\x12\x1f\n" + + "\vmetric_type\x18\x02 \x01(\tR\n" + + "metricType\"{\n" + + ")ResolveCategoryMetricsAverageScoreRequest\x12N\n" + + "\acontext\x18\x01 \x03(\v24.productv1.ResolveCategoryMetricsAverageScoreContextR\acontext\"O\n" + + "(ResolveCategoryMetricsAverageScoreResult\x12#\n" + + "\raverage_score\x18\x01 \x01(\x01R\faverageScore\"y\n" + + "*ResolveCategoryMetricsAverageScoreResponse\x12K\n" + + "\x06result\x18\x01 \x03(\v23.productv1.ResolveCategoryMetricsAverageScoreResultR\x06result\"L\n" + "\x1fResolveTestContainerDetailsArgs\x12)\n" + "\x10include_extended\x18\x01 \x01(\bR\x0fincludeExtended\"H\n" + "\"ResolveTestContainerDetailsContext\x12\x0e\n" + @@ -19368,7 +20312,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\xbdL\n" + + "\"SHIPPING_DESTINATION_INTERNATIONAL\x10\x032\x84R\n" + "\x0eProductService\x12`\n" + "\x11LookupProductById\x12#.productv1.LookupProductByIdRequest\x1a$.productv1.LookupProductByIdResponse\"\x00\x12`\n" + "\x11LookupStorageById\x12#.productv1.LookupStorageByIdRequest\x1a$.productv1.LookupStorageByIdResponse\"\x00\x12f\n" + @@ -19430,16 +20374,20 @@ const file_product_proto_rawDesc = "" + "\x1fRequireStorageProcessedTagsById\x121.productv1.RequireStorageProcessedTagsByIdRequest\x1a2.productv1.RequireStorageProcessedTagsByIdResponse\"\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\x87\x01\n" + + "$RequireWarehouseStockHealthScoreById\x126.productv1.RequireWarehouseStockHealthScoreByIdRequest\x1a7.productv1.RequireWarehouseStockHealthScoreByIdResponse\"\x00\x12\x93\x01\n" + + "\"ResolveCategoryActiveSubcategories\x124.productv1.ResolveCategoryActiveSubcategoriesRequest\x1a5.productv1.ResolveCategoryActiveSubcategoriesResponse\"\x00\x12\x87\x01\n" + "\x1eResolveCategoryCategoryMetrics\x120.productv1.ResolveCategoryCategoryMetricsRequest\x1a1.productv1.ResolveCategoryCategoryMetricsResponse\"\x00\x12\x84\x01\n" + "\x1dResolveCategoryCategoryStatus\x12/.productv1.ResolveCategoryCategoryStatusRequest\x1a0.productv1.ResolveCategoryCategoryStatusResponse\"\x00\x12\x87\x01\n" + "\x1eResolveCategoryChildCategories\x120.productv1.ResolveCategoryChildCategoriesRequest\x1a1.productv1.ResolveCategoryChildCategoriesResponse\"\x00\x12l\n" + - "\x15ResolveCategoryMascot\x12'.productv1.ResolveCategoryMascotRequest\x1a(.productv1.ResolveCategoryMascotResponse\"\x00\x12\x9c\x01\n" + + "\x15ResolveCategoryMascot\x12'.productv1.ResolveCategoryMascotRequest\x1a(.productv1.ResolveCategoryMascotResponse\"\x00\x12\x93\x01\n" + + "\"ResolveCategoryMetricsAverageScore\x124.productv1.ResolveCategoryMetricsAverageScoreRequest\x1a5.productv1.ResolveCategoryMetricsAverageScoreResponse\"\x00\x12\x9c\x01\n" + "%ResolveCategoryMetricsNormalizedScore\x127.productv1.ResolveCategoryMetricsNormalizedScoreRequest\x1a8.productv1.ResolveCategoryMetricsNormalizedScoreResponse\"\x00\x12\x9c\x01\n" + "%ResolveCategoryMetricsRelatedCategory\x127.productv1.ResolveCategoryMetricsRelatedCategoryRequest\x1a8.productv1.ResolveCategoryMetricsRelatedCategoryResponse\"\x00\x12\x90\x01\n" + "!ResolveCategoryOptionalCategories\x123.productv1.ResolveCategoryOptionalCategoriesRequest\x1a4.productv1.ResolveCategoryOptionalCategoriesResponse\"\x00\x12\x87\x01\n" + "\x1eResolveCategoryPopularityScore\x120.productv1.ResolveCategoryPopularityScoreRequest\x1a1.productv1.ResolveCategoryPopularityScoreResponse\"\x00\x12~\n" + - "\x1bResolveCategoryProductCount\x12-.productv1.ResolveCategoryProductCountRequest\x1a..productv1.ResolveCategoryProductCountResponse\"\x00\x12\x93\x01\n" + + "\x1bResolveCategoryProductCount\x12-.productv1.ResolveCategoryProductCountRequest\x1a..productv1.ResolveCategoryProductCountResponse\"\x00\x12\x84\x01\n" + + "\x1dResolveCategoryTopSubcategory\x12/.productv1.ResolveCategoryTopSubcategoryRequest\x1a0.productv1.ResolveCategoryTopSubcategoryResponse\"\x00\x12\x81\x01\n" + + "\x1cResolveCategoryTotalProducts\x12..productv1.ResolveCategoryTotalProductsRequest\x1a/.productv1.ResolveCategoryTotalProductsResponse\"\x00\x12\x93\x01\n" + "\"ResolveProductMascotRecommendation\x124.productv1.ResolveProductMascotRecommendationRequest\x1a5.productv1.ResolveProductMascotRecommendationResponse\"\x00\x12\x81\x01\n" + "\x1cResolveProductProductDetails\x12..productv1.ResolveProductProductDetailsRequest\x1a/.productv1.ResolveProductProductDetailsResponse\"\x00\x12\x90\x01\n" + "!ResolveProductRecommendedCategory\x123.productv1.ResolveProductRecommendedCategoryRequest\x1a4.productv1.ResolveProductRecommendedCategoryResponse\"\x00\x12\x87\x01\n" + @@ -19449,7 +20397,8 @@ const file_product_proto_rawDesc = "" + "\x1cResolveStorageNearbyStorages\x12..productv1.ResolveStorageNearbyStoragesRequest\x1a/.productv1.ResolveStorageNearbyStoragesResponse\"\x00\x12~\n" + "\x1bResolveStorageStorageStatus\x12-.productv1.ResolveStorageStorageStatusRequest\x1a..productv1.ResolveStorageStorageStatusResponse\"\x00\x12\x93\x01\n" + "\"ResolveSubcategoryFeaturedCategory\x124.productv1.ResolveSubcategoryFeaturedCategoryRequest\x1a5.productv1.ResolveSubcategoryFeaturedCategoryResponse\"\x00\x12~\n" + - "\x1bResolveSubcategoryItemCount\x12-.productv1.ResolveSubcategoryItemCountRequest\x1a..productv1.ResolveSubcategoryItemCountResponse\"\x00\x12~\n" + + "\x1bResolveSubcategoryItemCount\x12-.productv1.ResolveSubcategoryItemCountRequest\x1a..productv1.ResolveSubcategoryItemCountResponse\"\x00\x12\x8d\x01\n" + + " ResolveSubcategoryParentCategory\x122.productv1.ResolveSubcategoryParentCategoryRequest\x1a3.productv1.ResolveSubcategoryParentCategoryResponse\"\x00\x12~\n" + "\x1bResolveTestContainerDetails\x12-.productv1.ResolveTestContainerDetailsRequest\x1a..productv1.ResolveTestContainerDetailsResponse\"\x00B%Z#cosmo/pkg/proto/productv1;productv1b\x06proto3" var ( @@ -19465,7 +20414,7 @@ func file_product_proto_rawDescGZIP() []byte { } var file_product_proto_enumTypes = make([]protoimpl.EnumInfo, 2) -var file_product_proto_msgTypes = make([]protoimpl.MessageInfo, 365) +var file_product_proto_msgTypes = make([]protoimpl.MessageInfo, 385) var file_product_proto_goTypes = []any{ (CategoryKind)(0), // 0: productv1.CategoryKind (ShippingDestination)(0), // 1: productv1.ShippingDestination @@ -19664,720 +20613,763 @@ var file_product_proto_goTypes = []any{ (*ResolveCategoryOptionalCategoriesRequest)(nil), // 194: productv1.ResolveCategoryOptionalCategoriesRequest (*ResolveCategoryOptionalCategoriesResult)(nil), // 195: productv1.ResolveCategoryOptionalCategoriesResult (*ResolveCategoryOptionalCategoriesResponse)(nil), // 196: productv1.ResolveCategoryOptionalCategoriesResponse - (*ResolveSubcategoryItemCountArgs)(nil), // 197: productv1.ResolveSubcategoryItemCountArgs - (*ResolveSubcategoryItemCountContext)(nil), // 198: productv1.ResolveSubcategoryItemCountContext - (*ResolveSubcategoryItemCountRequest)(nil), // 199: productv1.ResolveSubcategoryItemCountRequest - (*ResolveSubcategoryItemCountResult)(nil), // 200: productv1.ResolveSubcategoryItemCountResult - (*ResolveSubcategoryItemCountResponse)(nil), // 201: productv1.ResolveSubcategoryItemCountResponse - (*ResolveSubcategoryFeaturedCategoryArgs)(nil), // 202: productv1.ResolveSubcategoryFeaturedCategoryArgs - (*ResolveSubcategoryFeaturedCategoryContext)(nil), // 203: productv1.ResolveSubcategoryFeaturedCategoryContext - (*ResolveSubcategoryFeaturedCategoryRequest)(nil), // 204: productv1.ResolveSubcategoryFeaturedCategoryRequest - (*ResolveSubcategoryFeaturedCategoryResult)(nil), // 205: productv1.ResolveSubcategoryFeaturedCategoryResult - (*ResolveSubcategoryFeaturedCategoryResponse)(nil), // 206: productv1.ResolveSubcategoryFeaturedCategoryResponse - (*ResolveCategoryMetricsNormalizedScoreArgs)(nil), // 207: productv1.ResolveCategoryMetricsNormalizedScoreArgs - (*ResolveCategoryMetricsNormalizedScoreContext)(nil), // 208: productv1.ResolveCategoryMetricsNormalizedScoreContext - (*ResolveCategoryMetricsNormalizedScoreRequest)(nil), // 209: productv1.ResolveCategoryMetricsNormalizedScoreRequest - (*ResolveCategoryMetricsNormalizedScoreResult)(nil), // 210: productv1.ResolveCategoryMetricsNormalizedScoreResult - (*ResolveCategoryMetricsNormalizedScoreResponse)(nil), // 211: productv1.ResolveCategoryMetricsNormalizedScoreResponse - (*ResolveCategoryMetricsRelatedCategoryArgs)(nil), // 212: productv1.ResolveCategoryMetricsRelatedCategoryArgs - (*ResolveCategoryMetricsRelatedCategoryContext)(nil), // 213: productv1.ResolveCategoryMetricsRelatedCategoryContext - (*ResolveCategoryMetricsRelatedCategoryRequest)(nil), // 214: productv1.ResolveCategoryMetricsRelatedCategoryRequest - (*ResolveCategoryMetricsRelatedCategoryResult)(nil), // 215: productv1.ResolveCategoryMetricsRelatedCategoryResult - (*ResolveCategoryMetricsRelatedCategoryResponse)(nil), // 216: productv1.ResolveCategoryMetricsRelatedCategoryResponse - (*ResolveTestContainerDetailsArgs)(nil), // 217: productv1.ResolveTestContainerDetailsArgs - (*ResolveTestContainerDetailsContext)(nil), // 218: productv1.ResolveTestContainerDetailsContext - (*ResolveTestContainerDetailsRequest)(nil), // 219: productv1.ResolveTestContainerDetailsRequest - (*ResolveTestContainerDetailsResult)(nil), // 220: productv1.ResolveTestContainerDetailsResult - (*ResolveTestContainerDetailsResponse)(nil), // 221: productv1.ResolveTestContainerDetailsResponse - (*RequireStorageStockHealthScoreByIdRequest)(nil), // 222: productv1.RequireStorageStockHealthScoreByIdRequest - (*RequireStorageStockHealthScoreByIdContext)(nil), // 223: productv1.RequireStorageStockHealthScoreByIdContext - (*RequireStorageStockHealthScoreByIdResponse)(nil), // 224: productv1.RequireStorageStockHealthScoreByIdResponse - (*RequireStorageStockHealthScoreByIdResult)(nil), // 225: productv1.RequireStorageStockHealthScoreByIdResult - (*RequireStorageStockHealthScoreByIdFields)(nil), // 226: productv1.RequireStorageStockHealthScoreByIdFields - (*RequireStorageTagSummaryByIdRequest)(nil), // 227: productv1.RequireStorageTagSummaryByIdRequest - (*RequireStorageTagSummaryByIdContext)(nil), // 228: productv1.RequireStorageTagSummaryByIdContext - (*RequireStorageTagSummaryByIdResponse)(nil), // 229: productv1.RequireStorageTagSummaryByIdResponse - (*RequireStorageTagSummaryByIdResult)(nil), // 230: productv1.RequireStorageTagSummaryByIdResult - (*RequireStorageTagSummaryByIdFields)(nil), // 231: productv1.RequireStorageTagSummaryByIdFields - (*RequireStorageOptionalTagSummaryByIdRequest)(nil), // 232: productv1.RequireStorageOptionalTagSummaryByIdRequest - (*RequireStorageOptionalTagSummaryByIdContext)(nil), // 233: productv1.RequireStorageOptionalTagSummaryByIdContext - (*RequireStorageOptionalTagSummaryByIdResponse)(nil), // 234: productv1.RequireStorageOptionalTagSummaryByIdResponse - (*RequireStorageOptionalTagSummaryByIdResult)(nil), // 235: productv1.RequireStorageOptionalTagSummaryByIdResult - (*RequireStorageOptionalTagSummaryByIdFields)(nil), // 236: productv1.RequireStorageOptionalTagSummaryByIdFields - (*RequireStorageMetadataScoreByIdRequest)(nil), // 237: productv1.RequireStorageMetadataScoreByIdRequest - (*RequireStorageMetadataScoreByIdContext)(nil), // 238: productv1.RequireStorageMetadataScoreByIdContext - (*RequireStorageMetadataScoreByIdResponse)(nil), // 239: productv1.RequireStorageMetadataScoreByIdResponse - (*RequireStorageMetadataScoreByIdResult)(nil), // 240: productv1.RequireStorageMetadataScoreByIdResult - (*RequireStorageMetadataScoreByIdFields)(nil), // 241: productv1.RequireStorageMetadataScoreByIdFields - (*RequireStorageProcessedMetadataByIdRequest)(nil), // 242: productv1.RequireStorageProcessedMetadataByIdRequest - (*RequireStorageProcessedMetadataByIdContext)(nil), // 243: productv1.RequireStorageProcessedMetadataByIdContext - (*RequireStorageProcessedMetadataByIdResponse)(nil), // 244: productv1.RequireStorageProcessedMetadataByIdResponse - (*RequireStorageProcessedMetadataByIdResult)(nil), // 245: productv1.RequireStorageProcessedMetadataByIdResult - (*RequireStorageProcessedMetadataByIdFields)(nil), // 246: productv1.RequireStorageProcessedMetadataByIdFields - (*RequireStorageOptionalProcessedMetadataByIdRequest)(nil), // 247: productv1.RequireStorageOptionalProcessedMetadataByIdRequest - (*RequireStorageOptionalProcessedMetadataByIdContext)(nil), // 248: productv1.RequireStorageOptionalProcessedMetadataByIdContext - (*RequireStorageOptionalProcessedMetadataByIdResponse)(nil), // 249: productv1.RequireStorageOptionalProcessedMetadataByIdResponse - (*RequireStorageOptionalProcessedMetadataByIdResult)(nil), // 250: productv1.RequireStorageOptionalProcessedMetadataByIdResult - (*RequireStorageOptionalProcessedMetadataByIdFields)(nil), // 251: productv1.RequireStorageOptionalProcessedMetadataByIdFields - (*RequireStorageProcessedTagsByIdRequest)(nil), // 252: productv1.RequireStorageProcessedTagsByIdRequest - (*RequireStorageProcessedTagsByIdContext)(nil), // 253: productv1.RequireStorageProcessedTagsByIdContext - (*RequireStorageProcessedTagsByIdResponse)(nil), // 254: productv1.RequireStorageProcessedTagsByIdResponse - (*RequireStorageProcessedTagsByIdResult)(nil), // 255: productv1.RequireStorageProcessedTagsByIdResult - (*RequireStorageProcessedTagsByIdFields)(nil), // 256: productv1.RequireStorageProcessedTagsByIdFields - (*RequireStorageOptionalProcessedTagsByIdRequest)(nil), // 257: productv1.RequireStorageOptionalProcessedTagsByIdRequest - (*RequireStorageOptionalProcessedTagsByIdContext)(nil), // 258: productv1.RequireStorageOptionalProcessedTagsByIdContext - (*RequireStorageOptionalProcessedTagsByIdResponse)(nil), // 259: productv1.RequireStorageOptionalProcessedTagsByIdResponse - (*RequireStorageOptionalProcessedTagsByIdResult)(nil), // 260: productv1.RequireStorageOptionalProcessedTagsByIdResult - (*RequireStorageOptionalProcessedTagsByIdFields)(nil), // 261: productv1.RequireStorageOptionalProcessedTagsByIdFields - (*RequireStorageProcessedMetadataHistoryByIdRequest)(nil), // 262: productv1.RequireStorageProcessedMetadataHistoryByIdRequest - (*RequireStorageProcessedMetadataHistoryByIdContext)(nil), // 263: productv1.RequireStorageProcessedMetadataHistoryByIdContext - (*RequireStorageProcessedMetadataHistoryByIdResponse)(nil), // 264: productv1.RequireStorageProcessedMetadataHistoryByIdResponse - (*RequireStorageProcessedMetadataHistoryByIdResult)(nil), // 265: productv1.RequireStorageProcessedMetadataHistoryByIdResult - (*RequireStorageProcessedMetadataHistoryByIdFields)(nil), // 266: productv1.RequireStorageProcessedMetadataHistoryByIdFields - (*RequireStorageKindSummaryByIdRequest)(nil), // 267: productv1.RequireStorageKindSummaryByIdRequest - (*RequireStorageKindSummaryByIdContext)(nil), // 268: productv1.RequireStorageKindSummaryByIdContext - (*RequireStorageKindSummaryByIdResponse)(nil), // 269: productv1.RequireStorageKindSummaryByIdResponse - (*RequireStorageKindSummaryByIdResult)(nil), // 270: productv1.RequireStorageKindSummaryByIdResult - (*RequireStorageKindSummaryByIdFields)(nil), // 271: productv1.RequireStorageKindSummaryByIdFields - (*RequireStorageCategoryInfoSummaryByIdRequest)(nil), // 272: productv1.RequireStorageCategoryInfoSummaryByIdRequest - (*RequireStorageCategoryInfoSummaryByIdContext)(nil), // 273: productv1.RequireStorageCategoryInfoSummaryByIdContext - (*RequireStorageCategoryInfoSummaryByIdResponse)(nil), // 274: productv1.RequireStorageCategoryInfoSummaryByIdResponse - (*RequireStorageCategoryInfoSummaryByIdResult)(nil), // 275: productv1.RequireStorageCategoryInfoSummaryByIdResult - (*RequireStorageCategoryInfoSummaryByIdFields)(nil), // 276: productv1.RequireStorageCategoryInfoSummaryByIdFields - (*RequireWarehouseStockHealthScoreByIdRequest)(nil), // 277: productv1.RequireWarehouseStockHealthScoreByIdRequest - (*RequireWarehouseStockHealthScoreByIdContext)(nil), // 278: productv1.RequireWarehouseStockHealthScoreByIdContext - (*RequireWarehouseStockHealthScoreByIdResponse)(nil), // 279: productv1.RequireWarehouseStockHealthScoreByIdResponse - (*RequireWarehouseStockHealthScoreByIdResult)(nil), // 280: productv1.RequireWarehouseStockHealthScoreByIdResult - (*RequireWarehouseStockHealthScoreByIdFields)(nil), // 281: productv1.RequireWarehouseStockHealthScoreByIdFields - (*Product)(nil), // 282: productv1.Product - (*Storage)(nil), // 283: productv1.Storage - (*Warehouse)(nil), // 284: productv1.Warehouse - (*User)(nil), // 285: productv1.User - (*NestedTypeA)(nil), // 286: productv1.NestedTypeA - (*RecursiveType)(nil), // 287: productv1.RecursiveType - (*TypeWithMultipleFilterFields)(nil), // 288: productv1.TypeWithMultipleFilterFields - (*FilterTypeInput)(nil), // 289: productv1.FilterTypeInput - (*ComplexFilterTypeInput)(nil), // 290: productv1.ComplexFilterTypeInput - (*TypeWithComplexFilterInput)(nil), // 291: productv1.TypeWithComplexFilterInput - (*OrderInput)(nil), // 292: productv1.OrderInput - (*Order)(nil), // 293: productv1.Order - (*Category)(nil), // 294: productv1.Category - (*CategoryFilter)(nil), // 295: productv1.CategoryFilter - (*Animal)(nil), // 296: productv1.Animal - (*SearchInput)(nil), // 297: productv1.SearchInput - (*SearchResult)(nil), // 298: productv1.SearchResult - (*NullableFieldsType)(nil), // 299: productv1.NullableFieldsType - (*NullableFieldsFilter)(nil), // 300: productv1.NullableFieldsFilter - (*BlogPost)(nil), // 301: productv1.BlogPost - (*BlogPostFilter)(nil), // 302: productv1.BlogPostFilter - (*Author)(nil), // 303: productv1.Author - (*AuthorFilter)(nil), // 304: productv1.AuthorFilter - (*TestContainer)(nil), // 305: productv1.TestContainer - (*UserInput)(nil), // 306: productv1.UserInput - (*ActionInput)(nil), // 307: productv1.ActionInput - (*ActionResult)(nil), // 308: productv1.ActionResult - (*NullableFieldsInput)(nil), // 309: productv1.NullableFieldsInput - (*BlogPostInput)(nil), // 310: productv1.BlogPostInput - (*AuthorInput)(nil), // 311: productv1.AuthorInput - (*ProductDetails)(nil), // 312: productv1.ProductDetails - (*RestockData)(nil), // 313: productv1.RestockData - (*StorageMetadata)(nil), // 314: productv1.StorageMetadata - (*StorageCategoryInfo)(nil), // 315: productv1.StorageCategoryInfo - (*NestedTypeB)(nil), // 316: productv1.NestedTypeB - (*NestedTypeC)(nil), // 317: productv1.NestedTypeC - (*FilterType)(nil), // 318: productv1.FilterType - (*Pagination)(nil), // 319: productv1.Pagination - (*OrderLineInput)(nil), // 320: productv1.OrderLineInput - (*OrderLine)(nil), // 321: productv1.OrderLine - (*Subcategory)(nil), // 322: productv1.Subcategory - (*CategoryMetrics)(nil), // 323: productv1.CategoryMetrics - (*Cat)(nil), // 324: productv1.Cat - (*Dog)(nil), // 325: productv1.Dog - (*Owner)(nil), // 326: productv1.Owner - (*ContactInfo)(nil), // 327: productv1.ContactInfo - (*Address)(nil), // 328: productv1.Address - (*CatBreed)(nil), // 329: productv1.CatBreed - (*DogBreed)(nil), // 330: productv1.DogBreed - (*BreedCharacteristics)(nil), // 331: productv1.BreedCharacteristics - (*ActionSuccess)(nil), // 332: productv1.ActionSuccess - (*ActionError)(nil), // 333: productv1.ActionError - (*TestDetails)(nil), // 334: productv1.TestDetails - (*CategoryInput)(nil), // 335: productv1.CategoryInput - (*ProductCountFilter)(nil), // 336: productv1.ProductCountFilter - (*SubcategoryItemFilter)(nil), // 337: productv1.SubcategoryItemFilter - (*ShippingEstimateInput)(nil), // 338: productv1.ShippingEstimateInput - (*ListOfAuthorFilter_List)(nil), // 339: productv1.ListOfAuthorFilter.List - (*ListOfAuthorInput_List)(nil), // 340: productv1.ListOfAuthorInput.List - (*ListOfBlogPost_List)(nil), // 341: productv1.ListOfBlogPost.List - (*ListOfBlogPostFilter_List)(nil), // 342: productv1.ListOfBlogPostFilter.List - (*ListOfBlogPostInput_List)(nil), // 343: productv1.ListOfBlogPostInput.List - (*ListOfBoolean_List)(nil), // 344: productv1.ListOfBoolean.List - (*ListOfCategory_List)(nil), // 345: productv1.ListOfCategory.List - (*ListOfCategoryInput_List)(nil), // 346: productv1.ListOfCategoryInput.List - (*ListOfFloat_List)(nil), // 347: productv1.ListOfFloat.List - (*ListOfListOfCategory_List)(nil), // 348: productv1.ListOfListOfCategory.List - (*ListOfListOfCategoryInput_List)(nil), // 349: productv1.ListOfListOfCategoryInput.List - (*ListOfListOfString_List)(nil), // 350: productv1.ListOfListOfString.List - (*ListOfListOfUser_List)(nil), // 351: productv1.ListOfListOfUser.List - (*ListOfListOfUserInput_List)(nil), // 352: productv1.ListOfListOfUserInput.List - (*ListOfOrderLine_List)(nil), // 353: productv1.ListOfOrderLine.List - (*ListOfProduct_List)(nil), // 354: productv1.ListOfProduct.List - (*ListOfStorage_List)(nil), // 355: productv1.ListOfStorage.List - (*ListOfString_List)(nil), // 356: productv1.ListOfString.List - (*ListOfSubcategory_List)(nil), // 357: productv1.ListOfSubcategory.List - (*ListOfUser_List)(nil), // 358: productv1.ListOfUser.List - (*ListOfUserInput_List)(nil), // 359: productv1.ListOfUserInput.List - (*RequireStorageStockHealthScoreByIdFields_RestockData)(nil), // 360: productv1.RequireStorageStockHealthScoreByIdFields.RestockData - (*RequireStorageMetadataScoreByIdFields_StorageMetadata)(nil), // 361: productv1.RequireStorageMetadataScoreByIdFields.StorageMetadata - (*RequireStorageProcessedMetadataByIdFields_StorageMetadata)(nil), // 362: productv1.RequireStorageProcessedMetadataByIdFields.StorageMetadata - (*RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata)(nil), // 363: productv1.RequireStorageOptionalProcessedMetadataByIdFields.StorageMetadata - (*RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata)(nil), // 364: productv1.RequireStorageProcessedMetadataHistoryByIdFields.StorageMetadata - (*RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo)(nil), // 365: productv1.RequireStorageCategoryInfoSummaryByIdFields.StorageCategoryInfo - (*RequireWarehouseStockHealthScoreByIdFields_RestockData)(nil), // 366: productv1.RequireWarehouseStockHealthScoreByIdFields.RestockData - (*wrapperspb.Int32Value)(nil), // 367: google.protobuf.Int32Value - (*wrapperspb.BoolValue)(nil), // 368: google.protobuf.BoolValue - (*wrapperspb.StringValue)(nil), // 369: google.protobuf.StringValue - (*wrapperspb.DoubleValue)(nil), // 370: google.protobuf.DoubleValue + (*ResolveCategoryTotalProductsContext)(nil), // 197: productv1.ResolveCategoryTotalProductsContext + (*ResolveCategoryTotalProductsRequest)(nil), // 198: productv1.ResolveCategoryTotalProductsRequest + (*ResolveCategoryTotalProductsResult)(nil), // 199: productv1.ResolveCategoryTotalProductsResult + (*ResolveCategoryTotalProductsResponse)(nil), // 200: productv1.ResolveCategoryTotalProductsResponse + (*ResolveCategoryTopSubcategoryContext)(nil), // 201: productv1.ResolveCategoryTopSubcategoryContext + (*ResolveCategoryTopSubcategoryRequest)(nil), // 202: productv1.ResolveCategoryTopSubcategoryRequest + (*ResolveCategoryTopSubcategoryResult)(nil), // 203: productv1.ResolveCategoryTopSubcategoryResult + (*ResolveCategoryTopSubcategoryResponse)(nil), // 204: productv1.ResolveCategoryTopSubcategoryResponse + (*ResolveCategoryActiveSubcategoriesContext)(nil), // 205: productv1.ResolveCategoryActiveSubcategoriesContext + (*ResolveCategoryActiveSubcategoriesRequest)(nil), // 206: productv1.ResolveCategoryActiveSubcategoriesRequest + (*ResolveCategoryActiveSubcategoriesResult)(nil), // 207: productv1.ResolveCategoryActiveSubcategoriesResult + (*ResolveCategoryActiveSubcategoriesResponse)(nil), // 208: productv1.ResolveCategoryActiveSubcategoriesResponse + (*ResolveSubcategoryItemCountArgs)(nil), // 209: productv1.ResolveSubcategoryItemCountArgs + (*ResolveSubcategoryItemCountContext)(nil), // 210: productv1.ResolveSubcategoryItemCountContext + (*ResolveSubcategoryItemCountRequest)(nil), // 211: productv1.ResolveSubcategoryItemCountRequest + (*ResolveSubcategoryItemCountResult)(nil), // 212: productv1.ResolveSubcategoryItemCountResult + (*ResolveSubcategoryItemCountResponse)(nil), // 213: productv1.ResolveSubcategoryItemCountResponse + (*ResolveSubcategoryFeaturedCategoryArgs)(nil), // 214: productv1.ResolveSubcategoryFeaturedCategoryArgs + (*ResolveSubcategoryFeaturedCategoryContext)(nil), // 215: productv1.ResolveSubcategoryFeaturedCategoryContext + (*ResolveSubcategoryFeaturedCategoryRequest)(nil), // 216: productv1.ResolveSubcategoryFeaturedCategoryRequest + (*ResolveSubcategoryFeaturedCategoryResult)(nil), // 217: productv1.ResolveSubcategoryFeaturedCategoryResult + (*ResolveSubcategoryFeaturedCategoryResponse)(nil), // 218: productv1.ResolveSubcategoryFeaturedCategoryResponse + (*ResolveSubcategoryParentCategoryContext)(nil), // 219: productv1.ResolveSubcategoryParentCategoryContext + (*ResolveSubcategoryParentCategoryRequest)(nil), // 220: productv1.ResolveSubcategoryParentCategoryRequest + (*ResolveSubcategoryParentCategoryResult)(nil), // 221: productv1.ResolveSubcategoryParentCategoryResult + (*ResolveSubcategoryParentCategoryResponse)(nil), // 222: productv1.ResolveSubcategoryParentCategoryResponse + (*ResolveCategoryMetricsNormalizedScoreArgs)(nil), // 223: productv1.ResolveCategoryMetricsNormalizedScoreArgs + (*ResolveCategoryMetricsNormalizedScoreContext)(nil), // 224: productv1.ResolveCategoryMetricsNormalizedScoreContext + (*ResolveCategoryMetricsNormalizedScoreRequest)(nil), // 225: productv1.ResolveCategoryMetricsNormalizedScoreRequest + (*ResolveCategoryMetricsNormalizedScoreResult)(nil), // 226: productv1.ResolveCategoryMetricsNormalizedScoreResult + (*ResolveCategoryMetricsNormalizedScoreResponse)(nil), // 227: productv1.ResolveCategoryMetricsNormalizedScoreResponse + (*ResolveCategoryMetricsRelatedCategoryArgs)(nil), // 228: productv1.ResolveCategoryMetricsRelatedCategoryArgs + (*ResolveCategoryMetricsRelatedCategoryContext)(nil), // 229: productv1.ResolveCategoryMetricsRelatedCategoryContext + (*ResolveCategoryMetricsRelatedCategoryRequest)(nil), // 230: productv1.ResolveCategoryMetricsRelatedCategoryRequest + (*ResolveCategoryMetricsRelatedCategoryResult)(nil), // 231: productv1.ResolveCategoryMetricsRelatedCategoryResult + (*ResolveCategoryMetricsRelatedCategoryResponse)(nil), // 232: productv1.ResolveCategoryMetricsRelatedCategoryResponse + (*ResolveCategoryMetricsAverageScoreContext)(nil), // 233: productv1.ResolveCategoryMetricsAverageScoreContext + (*ResolveCategoryMetricsAverageScoreRequest)(nil), // 234: productv1.ResolveCategoryMetricsAverageScoreRequest + (*ResolveCategoryMetricsAverageScoreResult)(nil), // 235: productv1.ResolveCategoryMetricsAverageScoreResult + (*ResolveCategoryMetricsAverageScoreResponse)(nil), // 236: productv1.ResolveCategoryMetricsAverageScoreResponse + (*ResolveTestContainerDetailsArgs)(nil), // 237: productv1.ResolveTestContainerDetailsArgs + (*ResolveTestContainerDetailsContext)(nil), // 238: productv1.ResolveTestContainerDetailsContext + (*ResolveTestContainerDetailsRequest)(nil), // 239: productv1.ResolveTestContainerDetailsRequest + (*ResolveTestContainerDetailsResult)(nil), // 240: productv1.ResolveTestContainerDetailsResult + (*ResolveTestContainerDetailsResponse)(nil), // 241: productv1.ResolveTestContainerDetailsResponse + (*RequireStorageStockHealthScoreByIdRequest)(nil), // 242: productv1.RequireStorageStockHealthScoreByIdRequest + (*RequireStorageStockHealthScoreByIdContext)(nil), // 243: productv1.RequireStorageStockHealthScoreByIdContext + (*RequireStorageStockHealthScoreByIdResponse)(nil), // 244: productv1.RequireStorageStockHealthScoreByIdResponse + (*RequireStorageStockHealthScoreByIdResult)(nil), // 245: productv1.RequireStorageStockHealthScoreByIdResult + (*RequireStorageStockHealthScoreByIdFields)(nil), // 246: productv1.RequireStorageStockHealthScoreByIdFields + (*RequireStorageTagSummaryByIdRequest)(nil), // 247: productv1.RequireStorageTagSummaryByIdRequest + (*RequireStorageTagSummaryByIdContext)(nil), // 248: productv1.RequireStorageTagSummaryByIdContext + (*RequireStorageTagSummaryByIdResponse)(nil), // 249: productv1.RequireStorageTagSummaryByIdResponse + (*RequireStorageTagSummaryByIdResult)(nil), // 250: productv1.RequireStorageTagSummaryByIdResult + (*RequireStorageTagSummaryByIdFields)(nil), // 251: productv1.RequireStorageTagSummaryByIdFields + (*RequireStorageOptionalTagSummaryByIdRequest)(nil), // 252: productv1.RequireStorageOptionalTagSummaryByIdRequest + (*RequireStorageOptionalTagSummaryByIdContext)(nil), // 253: productv1.RequireStorageOptionalTagSummaryByIdContext + (*RequireStorageOptionalTagSummaryByIdResponse)(nil), // 254: productv1.RequireStorageOptionalTagSummaryByIdResponse + (*RequireStorageOptionalTagSummaryByIdResult)(nil), // 255: productv1.RequireStorageOptionalTagSummaryByIdResult + (*RequireStorageOptionalTagSummaryByIdFields)(nil), // 256: productv1.RequireStorageOptionalTagSummaryByIdFields + (*RequireStorageMetadataScoreByIdRequest)(nil), // 257: productv1.RequireStorageMetadataScoreByIdRequest + (*RequireStorageMetadataScoreByIdContext)(nil), // 258: productv1.RequireStorageMetadataScoreByIdContext + (*RequireStorageMetadataScoreByIdResponse)(nil), // 259: productv1.RequireStorageMetadataScoreByIdResponse + (*RequireStorageMetadataScoreByIdResult)(nil), // 260: productv1.RequireStorageMetadataScoreByIdResult + (*RequireStorageMetadataScoreByIdFields)(nil), // 261: productv1.RequireStorageMetadataScoreByIdFields + (*RequireStorageProcessedMetadataByIdRequest)(nil), // 262: productv1.RequireStorageProcessedMetadataByIdRequest + (*RequireStorageProcessedMetadataByIdContext)(nil), // 263: productv1.RequireStorageProcessedMetadataByIdContext + (*RequireStorageProcessedMetadataByIdResponse)(nil), // 264: productv1.RequireStorageProcessedMetadataByIdResponse + (*RequireStorageProcessedMetadataByIdResult)(nil), // 265: productv1.RequireStorageProcessedMetadataByIdResult + (*RequireStorageProcessedMetadataByIdFields)(nil), // 266: productv1.RequireStorageProcessedMetadataByIdFields + (*RequireStorageOptionalProcessedMetadataByIdRequest)(nil), // 267: productv1.RequireStorageOptionalProcessedMetadataByIdRequest + (*RequireStorageOptionalProcessedMetadataByIdContext)(nil), // 268: productv1.RequireStorageOptionalProcessedMetadataByIdContext + (*RequireStorageOptionalProcessedMetadataByIdResponse)(nil), // 269: productv1.RequireStorageOptionalProcessedMetadataByIdResponse + (*RequireStorageOptionalProcessedMetadataByIdResult)(nil), // 270: productv1.RequireStorageOptionalProcessedMetadataByIdResult + (*RequireStorageOptionalProcessedMetadataByIdFields)(nil), // 271: productv1.RequireStorageOptionalProcessedMetadataByIdFields + (*RequireStorageProcessedTagsByIdRequest)(nil), // 272: productv1.RequireStorageProcessedTagsByIdRequest + (*RequireStorageProcessedTagsByIdContext)(nil), // 273: productv1.RequireStorageProcessedTagsByIdContext + (*RequireStorageProcessedTagsByIdResponse)(nil), // 274: productv1.RequireStorageProcessedTagsByIdResponse + (*RequireStorageProcessedTagsByIdResult)(nil), // 275: productv1.RequireStorageProcessedTagsByIdResult + (*RequireStorageProcessedTagsByIdFields)(nil), // 276: productv1.RequireStorageProcessedTagsByIdFields + (*RequireStorageOptionalProcessedTagsByIdRequest)(nil), // 277: productv1.RequireStorageOptionalProcessedTagsByIdRequest + (*RequireStorageOptionalProcessedTagsByIdContext)(nil), // 278: productv1.RequireStorageOptionalProcessedTagsByIdContext + (*RequireStorageOptionalProcessedTagsByIdResponse)(nil), // 279: productv1.RequireStorageOptionalProcessedTagsByIdResponse + (*RequireStorageOptionalProcessedTagsByIdResult)(nil), // 280: productv1.RequireStorageOptionalProcessedTagsByIdResult + (*RequireStorageOptionalProcessedTagsByIdFields)(nil), // 281: productv1.RequireStorageOptionalProcessedTagsByIdFields + (*RequireStorageProcessedMetadataHistoryByIdRequest)(nil), // 282: productv1.RequireStorageProcessedMetadataHistoryByIdRequest + (*RequireStorageProcessedMetadataHistoryByIdContext)(nil), // 283: productv1.RequireStorageProcessedMetadataHistoryByIdContext + (*RequireStorageProcessedMetadataHistoryByIdResponse)(nil), // 284: productv1.RequireStorageProcessedMetadataHistoryByIdResponse + (*RequireStorageProcessedMetadataHistoryByIdResult)(nil), // 285: productv1.RequireStorageProcessedMetadataHistoryByIdResult + (*RequireStorageProcessedMetadataHistoryByIdFields)(nil), // 286: productv1.RequireStorageProcessedMetadataHistoryByIdFields + (*RequireStorageKindSummaryByIdRequest)(nil), // 287: productv1.RequireStorageKindSummaryByIdRequest + (*RequireStorageKindSummaryByIdContext)(nil), // 288: productv1.RequireStorageKindSummaryByIdContext + (*RequireStorageKindSummaryByIdResponse)(nil), // 289: productv1.RequireStorageKindSummaryByIdResponse + (*RequireStorageKindSummaryByIdResult)(nil), // 290: productv1.RequireStorageKindSummaryByIdResult + (*RequireStorageKindSummaryByIdFields)(nil), // 291: productv1.RequireStorageKindSummaryByIdFields + (*RequireStorageCategoryInfoSummaryByIdRequest)(nil), // 292: productv1.RequireStorageCategoryInfoSummaryByIdRequest + (*RequireStorageCategoryInfoSummaryByIdContext)(nil), // 293: productv1.RequireStorageCategoryInfoSummaryByIdContext + (*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 } var file_product_proto_depIdxs = []int32{ - 339, // 0: productv1.ListOfAuthorFilter.list:type_name -> productv1.ListOfAuthorFilter.List - 340, // 1: productv1.ListOfAuthorInput.list:type_name -> productv1.ListOfAuthorInput.List - 341, // 2: productv1.ListOfBlogPost.list:type_name -> productv1.ListOfBlogPost.List - 342, // 3: productv1.ListOfBlogPostFilter.list:type_name -> productv1.ListOfBlogPostFilter.List - 343, // 4: productv1.ListOfBlogPostInput.list:type_name -> productv1.ListOfBlogPostInput.List - 344, // 5: productv1.ListOfBoolean.list:type_name -> productv1.ListOfBoolean.List - 345, // 6: productv1.ListOfCategory.list:type_name -> productv1.ListOfCategory.List - 346, // 7: productv1.ListOfCategoryInput.list:type_name -> productv1.ListOfCategoryInput.List - 347, // 8: productv1.ListOfFloat.list:type_name -> productv1.ListOfFloat.List - 348, // 9: productv1.ListOfListOfCategory.list:type_name -> productv1.ListOfListOfCategory.List - 349, // 10: productv1.ListOfListOfCategoryInput.list:type_name -> productv1.ListOfListOfCategoryInput.List - 350, // 11: productv1.ListOfListOfString.list:type_name -> productv1.ListOfListOfString.List - 351, // 12: productv1.ListOfListOfUser.list:type_name -> productv1.ListOfListOfUser.List - 352, // 13: productv1.ListOfListOfUserInput.list:type_name -> productv1.ListOfListOfUserInput.List - 353, // 14: productv1.ListOfOrderLine.list:type_name -> productv1.ListOfOrderLine.List - 354, // 15: productv1.ListOfProduct.list:type_name -> productv1.ListOfProduct.List - 355, // 16: productv1.ListOfStorage.list:type_name -> productv1.ListOfStorage.List - 356, // 17: productv1.ListOfString.list:type_name -> productv1.ListOfString.List - 357, // 18: productv1.ListOfSubcategory.list:type_name -> productv1.ListOfSubcategory.List - 358, // 19: productv1.ListOfUser.list:type_name -> productv1.ListOfUser.List - 359, // 20: productv1.ListOfUserInput.list:type_name -> productv1.ListOfUserInput.List + 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 23, // 21: productv1.LookupProductByIdRequest.keys:type_name -> productv1.LookupProductByIdRequestKey - 282, // 22: productv1.LookupProductByIdResponse.result:type_name -> productv1.Product + 302, // 22: productv1.LookupProductByIdResponse.result:type_name -> productv1.Product 26, // 23: productv1.LookupStorageByIdRequest.keys:type_name -> productv1.LookupStorageByIdRequestKey - 283, // 24: productv1.LookupStorageByIdResponse.result:type_name -> productv1.Storage + 303, // 24: productv1.LookupStorageByIdResponse.result:type_name -> productv1.Storage 29, // 25: productv1.LookupWarehouseByIdRequest.keys:type_name -> productv1.LookupWarehouseByIdRequestKey - 284, // 26: productv1.LookupWarehouseByIdResponse.result:type_name -> productv1.Warehouse - 285, // 27: productv1.QueryUsersResponse.users:type_name -> productv1.User - 285, // 28: productv1.QueryUserResponse.user:type_name -> productv1.User - 286, // 29: productv1.QueryNestedTypeResponse.nested_type:type_name -> productv1.NestedTypeA - 287, // 30: productv1.QueryRecursiveTypeResponse.recursive_type:type_name -> productv1.RecursiveType - 288, // 31: productv1.QueryTypeFilterWithArgumentsResponse.type_filter_with_arguments:type_name -> productv1.TypeWithMultipleFilterFields - 289, // 32: productv1.QueryTypeWithMultipleFilterFieldsRequest.filter:type_name -> productv1.FilterTypeInput - 288, // 33: productv1.QueryTypeWithMultipleFilterFieldsResponse.type_with_multiple_filter_fields:type_name -> productv1.TypeWithMultipleFilterFields - 290, // 34: productv1.QueryComplexFilterTypeRequest.filter:type_name -> productv1.ComplexFilterTypeInput - 291, // 35: productv1.QueryComplexFilterTypeResponse.complex_filter_type:type_name -> productv1.TypeWithComplexFilterInput - 292, // 36: productv1.QueryCalculateTotalsRequest.orders:type_name -> productv1.OrderInput - 293, // 37: productv1.QueryCalculateTotalsResponse.calculate_totals:type_name -> productv1.Order - 294, // 38: productv1.QueryCategoriesResponse.categories:type_name -> productv1.Category - 294, // 39: productv1.QueryCategoryResponse.category:type_name -> productv1.Category + 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 0, // 40: productv1.QueryCategoriesByKindRequest.kind:type_name -> productv1.CategoryKind - 294, // 41: productv1.QueryCategoriesByKindResponse.categories_by_kind:type_name -> productv1.Category + 314, // 41: productv1.QueryCategoriesByKindResponse.categories_by_kind:type_name -> productv1.Category 0, // 42: productv1.QueryCategoriesByKindsRequest.kinds:type_name -> productv1.CategoryKind - 294, // 43: productv1.QueryCategoriesByKindsResponse.categories_by_kinds:type_name -> productv1.Category - 295, // 44: productv1.QueryFilterCategoriesRequest.filter:type_name -> productv1.CategoryFilter - 294, // 45: productv1.QueryFilterCategoriesResponse.filter_categories:type_name -> productv1.Category - 296, // 46: productv1.QueryRandomPetResponse.random_pet:type_name -> productv1.Animal - 296, // 47: productv1.QueryAllPetsResponse.all_pets:type_name -> productv1.Animal - 297, // 48: productv1.QuerySearchRequest.input:type_name -> productv1.SearchInput - 298, // 49: productv1.QuerySearchResponse.search:type_name -> productv1.SearchResult - 298, // 50: productv1.QueryRandomSearchResultResponse.random_search_result:type_name -> productv1.SearchResult - 299, // 51: productv1.QueryNullableFieldsTypeResponse.nullable_fields_type:type_name -> productv1.NullableFieldsType - 299, // 52: productv1.QueryNullableFieldsTypeByIdResponse.nullable_fields_type_by_id:type_name -> productv1.NullableFieldsType - 300, // 53: productv1.QueryNullableFieldsTypeWithFilterRequest.filter:type_name -> productv1.NullableFieldsFilter - 299, // 54: productv1.QueryNullableFieldsTypeWithFilterResponse.nullable_fields_type_with_filter:type_name -> productv1.NullableFieldsType - 299, // 55: productv1.QueryAllNullableFieldsTypesResponse.all_nullable_fields_types:type_name -> productv1.NullableFieldsType - 301, // 56: productv1.QueryBlogPostResponse.blog_post:type_name -> productv1.BlogPost - 301, // 57: productv1.QueryBlogPostByIdResponse.blog_post_by_id:type_name -> productv1.BlogPost - 302, // 58: productv1.QueryBlogPostsWithFilterRequest.filter:type_name -> productv1.BlogPostFilter - 301, // 59: productv1.QueryBlogPostsWithFilterResponse.blog_posts_with_filter:type_name -> productv1.BlogPost - 301, // 60: productv1.QueryAllBlogPostsResponse.all_blog_posts:type_name -> productv1.BlogPost - 303, // 61: productv1.QueryAuthorResponse.author:type_name -> productv1.Author - 303, // 62: productv1.QueryAuthorByIdResponse.author_by_id:type_name -> productv1.Author - 304, // 63: productv1.QueryAuthorsWithFilterRequest.filter:type_name -> productv1.AuthorFilter - 303, // 64: productv1.QueryAuthorsWithFilterResponse.authors_with_filter:type_name -> productv1.Author - 303, // 65: productv1.QueryAllAuthorsResponse.all_authors:type_name -> productv1.Author + 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 2, // 66: productv1.QueryBulkSearchAuthorsRequest.filters:type_name -> productv1.ListOfAuthorFilter - 303, // 67: productv1.QueryBulkSearchAuthorsResponse.bulk_search_authors:type_name -> productv1.Author + 323, // 67: productv1.QueryBulkSearchAuthorsResponse.bulk_search_authors:type_name -> productv1.Author 5, // 68: productv1.QueryBulkSearchBlogPostsRequest.filters:type_name -> productv1.ListOfBlogPostFilter - 301, // 69: productv1.QueryBulkSearchBlogPostsResponse.bulk_search_blog_posts:type_name -> productv1.BlogPost - 305, // 70: productv1.QueryTestContainerResponse.test_container:type_name -> productv1.TestContainer - 305, // 71: productv1.QueryTestContainersResponse.test_containers:type_name -> productv1.TestContainer - 306, // 72: productv1.MutationCreateUserRequest.input:type_name -> productv1.UserInput - 285, // 73: productv1.MutationCreateUserResponse.create_user:type_name -> productv1.User - 307, // 74: productv1.MutationPerformActionRequest.input:type_name -> productv1.ActionInput - 308, // 75: productv1.MutationPerformActionResponse.perform_action:type_name -> productv1.ActionResult - 309, // 76: productv1.MutationCreateNullableFieldsTypeRequest.input:type_name -> productv1.NullableFieldsInput - 299, // 77: productv1.MutationCreateNullableFieldsTypeResponse.create_nullable_fields_type:type_name -> productv1.NullableFieldsType - 309, // 78: productv1.MutationUpdateNullableFieldsTypeRequest.input:type_name -> productv1.NullableFieldsInput - 299, // 79: productv1.MutationUpdateNullableFieldsTypeResponse.update_nullable_fields_type:type_name -> productv1.NullableFieldsType - 310, // 80: productv1.MutationCreateBlogPostRequest.input:type_name -> productv1.BlogPostInput - 301, // 81: productv1.MutationCreateBlogPostResponse.create_blog_post:type_name -> productv1.BlogPost - 310, // 82: productv1.MutationUpdateBlogPostRequest.input:type_name -> productv1.BlogPostInput - 301, // 83: productv1.MutationUpdateBlogPostResponse.update_blog_post:type_name -> productv1.BlogPost - 311, // 84: productv1.MutationCreateAuthorRequest.input:type_name -> productv1.AuthorInput - 303, // 85: productv1.MutationCreateAuthorResponse.create_author:type_name -> productv1.Author - 311, // 86: productv1.MutationUpdateAuthorRequest.input:type_name -> productv1.AuthorInput - 303, // 87: productv1.MutationUpdateAuthorResponse.update_author:type_name -> productv1.Author + 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 3, // 88: productv1.MutationBulkCreateAuthorsRequest.authors:type_name -> productv1.ListOfAuthorInput - 303, // 89: productv1.MutationBulkCreateAuthorsResponse.bulk_create_authors:type_name -> productv1.Author + 323, // 89: productv1.MutationBulkCreateAuthorsResponse.bulk_create_authors:type_name -> productv1.Author 3, // 90: productv1.MutationBulkUpdateAuthorsRequest.authors:type_name -> productv1.ListOfAuthorInput - 303, // 91: productv1.MutationBulkUpdateAuthorsResponse.bulk_update_authors:type_name -> productv1.Author + 323, // 91: productv1.MutationBulkUpdateAuthorsResponse.bulk_update_authors:type_name -> productv1.Author 6, // 92: productv1.MutationBulkCreateBlogPostsRequest.blog_posts:type_name -> productv1.ListOfBlogPostInput - 301, // 93: productv1.MutationBulkCreateBlogPostsResponse.bulk_create_blog_posts:type_name -> productv1.BlogPost + 321, // 93: productv1.MutationBulkCreateBlogPostsResponse.bulk_create_blog_posts:type_name -> productv1.BlogPost 6, // 94: productv1.MutationBulkUpdateBlogPostsRequest.blog_posts:type_name -> productv1.ListOfBlogPostInput - 301, // 95: productv1.MutationBulkUpdateBlogPostsResponse.bulk_update_blog_posts:type_name -> productv1.BlogPost - 338, // 96: productv1.ResolveProductShippingEstimateArgs.input:type_name -> productv1.ShippingEstimateInput + 321, // 95: productv1.MutationBulkUpdateBlogPostsResponse.bulk_update_blog_posts:type_name -> productv1.BlogPost + 358, // 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 - 294, // 102: productv1.ResolveProductRecommendedCategoryResult.recommended_category:type_name -> productv1.Category + 314, // 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 - 296, // 106: productv1.ResolveProductMascotRecommendationResult.mascot_recommendation:type_name -> productv1.Animal + 316, // 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 - 308, // 110: productv1.ResolveProductStockStatusResult.stock_status:type_name -> productv1.ActionResult + 328, // 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 - 312, // 114: productv1.ResolveProductProductDetailsResult.product_details:type_name -> productv1.ProductDetails + 332, // 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 - 308, // 118: productv1.ResolveStorageStorageStatusResult.storage_status:type_name -> productv1.ActionResult + 328, // 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 - 283, // 122: productv1.ResolveStorageLinkedStoragesResult.linked_storages:type_name -> productv1.Storage + 303, // 122: productv1.ResolveStorageLinkedStoragesResult.linked_storages:type_name -> productv1.Storage 155, // 123: productv1.ResolveStorageLinkedStoragesResponse.result:type_name -> productv1.ResolveStorageLinkedStoragesResult - 367, // 124: productv1.ResolveStorageNearbyStoragesArgs.radius:type_name -> google.protobuf.Int32Value + 387, // 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 - 336, // 129: productv1.ResolveCategoryProductCountArgs.filters:type_name -> productv1.ProductCountFilter + 356, // 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 - 367, // 133: productv1.ResolveCategoryPopularityScoreArgs.threshold:type_name -> google.protobuf.Int32Value + 387, // 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 - 367, // 136: productv1.ResolveCategoryPopularityScoreResult.popularity_score:type_name -> google.protobuf.Int32Value + 387, // 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 - 323, // 140: productv1.ResolveCategoryCategoryMetricsResult.category_metrics:type_name -> productv1.CategoryMetrics + 343, // 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 - 296, // 145: productv1.ResolveCategoryMascotResult.mascot:type_name -> productv1.Animal + 316, // 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 - 308, // 149: productv1.ResolveCategoryCategoryStatusResult.category_status:type_name -> productv1.ActionResult + 328, // 149: productv1.ResolveCategoryCategoryStatusResult.category_status:type_name -> productv1.ActionResult 185, // 150: productv1.ResolveCategoryCategoryStatusResponse.result:type_name -> productv1.ResolveCategoryCategoryStatusResult - 368, // 151: productv1.ResolveCategoryChildCategoriesArgs.include:type_name -> google.protobuf.BoolValue + 388, // 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 - 294, // 154: productv1.ResolveCategoryChildCategoriesResult.child_categories:type_name -> productv1.Category + 314, // 154: productv1.ResolveCategoryChildCategoriesResult.child_categories:type_name -> productv1.Category 190, // 155: productv1.ResolveCategoryChildCategoriesResponse.result:type_name -> productv1.ResolveCategoryChildCategoriesResult - 368, // 156: productv1.ResolveCategoryOptionalCategoriesArgs.include:type_name -> google.protobuf.BoolValue + 388, // 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 195, // 160: productv1.ResolveCategoryOptionalCategoriesResponse.result:type_name -> productv1.ResolveCategoryOptionalCategoriesResult - 337, // 161: productv1.ResolveSubcategoryItemCountArgs.filters:type_name -> productv1.SubcategoryItemFilter - 198, // 162: productv1.ResolveSubcategoryItemCountRequest.context:type_name -> productv1.ResolveSubcategoryItemCountContext - 197, // 163: productv1.ResolveSubcategoryItemCountRequest.field_args:type_name -> productv1.ResolveSubcategoryItemCountArgs - 200, // 164: productv1.ResolveSubcategoryItemCountResponse.result:type_name -> productv1.ResolveSubcategoryItemCountResult - 203, // 165: productv1.ResolveSubcategoryFeaturedCategoryRequest.context:type_name -> productv1.ResolveSubcategoryFeaturedCategoryContext - 202, // 166: productv1.ResolveSubcategoryFeaturedCategoryRequest.field_args:type_name -> productv1.ResolveSubcategoryFeaturedCategoryArgs - 294, // 167: productv1.ResolveSubcategoryFeaturedCategoryResult.featured_category:type_name -> productv1.Category - 205, // 168: productv1.ResolveSubcategoryFeaturedCategoryResponse.result:type_name -> productv1.ResolveSubcategoryFeaturedCategoryResult - 208, // 169: productv1.ResolveCategoryMetricsNormalizedScoreRequest.context:type_name -> productv1.ResolveCategoryMetricsNormalizedScoreContext - 207, // 170: productv1.ResolveCategoryMetricsNormalizedScoreRequest.field_args:type_name -> productv1.ResolveCategoryMetricsNormalizedScoreArgs - 210, // 171: productv1.ResolveCategoryMetricsNormalizedScoreResponse.result:type_name -> productv1.ResolveCategoryMetricsNormalizedScoreResult - 368, // 172: productv1.ResolveCategoryMetricsRelatedCategoryArgs.include:type_name -> google.protobuf.BoolValue - 213, // 173: productv1.ResolveCategoryMetricsRelatedCategoryRequest.context:type_name -> productv1.ResolveCategoryMetricsRelatedCategoryContext - 212, // 174: productv1.ResolveCategoryMetricsRelatedCategoryRequest.field_args:type_name -> productv1.ResolveCategoryMetricsRelatedCategoryArgs - 294, // 175: productv1.ResolveCategoryMetricsRelatedCategoryResult.related_category:type_name -> productv1.Category - 215, // 176: productv1.ResolveCategoryMetricsRelatedCategoryResponse.result:type_name -> productv1.ResolveCategoryMetricsRelatedCategoryResult - 218, // 177: productv1.ResolveTestContainerDetailsRequest.context:type_name -> productv1.ResolveTestContainerDetailsContext - 217, // 178: productv1.ResolveTestContainerDetailsRequest.field_args:type_name -> productv1.ResolveTestContainerDetailsArgs - 334, // 179: productv1.ResolveTestContainerDetailsResult.details:type_name -> productv1.TestDetails - 220, // 180: productv1.ResolveTestContainerDetailsResponse.result:type_name -> productv1.ResolveTestContainerDetailsResult - 223, // 181: productv1.RequireStorageStockHealthScoreByIdRequest.context:type_name -> productv1.RequireStorageStockHealthScoreByIdContext - 26, // 182: productv1.RequireStorageStockHealthScoreByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey - 226, // 183: productv1.RequireStorageStockHealthScoreByIdContext.fields:type_name -> productv1.RequireStorageStockHealthScoreByIdFields - 225, // 184: productv1.RequireStorageStockHealthScoreByIdResponse.result:type_name -> productv1.RequireStorageStockHealthScoreByIdResult - 360, // 185: productv1.RequireStorageStockHealthScoreByIdFields.restock_data:type_name -> productv1.RequireStorageStockHealthScoreByIdFields.RestockData - 228, // 186: productv1.RequireStorageTagSummaryByIdRequest.context:type_name -> productv1.RequireStorageTagSummaryByIdContext - 26, // 187: productv1.RequireStorageTagSummaryByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey - 231, // 188: productv1.RequireStorageTagSummaryByIdContext.fields:type_name -> productv1.RequireStorageTagSummaryByIdFields - 230, // 189: productv1.RequireStorageTagSummaryByIdResponse.result:type_name -> productv1.RequireStorageTagSummaryByIdResult - 233, // 190: productv1.RequireStorageOptionalTagSummaryByIdRequest.context:type_name -> productv1.RequireStorageOptionalTagSummaryByIdContext - 26, // 191: productv1.RequireStorageOptionalTagSummaryByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey - 236, // 192: productv1.RequireStorageOptionalTagSummaryByIdContext.fields:type_name -> productv1.RequireStorageOptionalTagSummaryByIdFields - 235, // 193: productv1.RequireStorageOptionalTagSummaryByIdResponse.result:type_name -> productv1.RequireStorageOptionalTagSummaryByIdResult - 369, // 194: productv1.RequireStorageOptionalTagSummaryByIdResult.optional_tag_summary:type_name -> google.protobuf.StringValue - 19, // 195: productv1.RequireStorageOptionalTagSummaryByIdFields.optional_tags:type_name -> productv1.ListOfString - 238, // 196: productv1.RequireStorageMetadataScoreByIdRequest.context:type_name -> productv1.RequireStorageMetadataScoreByIdContext - 26, // 197: productv1.RequireStorageMetadataScoreByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey - 241, // 198: productv1.RequireStorageMetadataScoreByIdContext.fields:type_name -> productv1.RequireStorageMetadataScoreByIdFields - 240, // 199: productv1.RequireStorageMetadataScoreByIdResponse.result:type_name -> productv1.RequireStorageMetadataScoreByIdResult - 361, // 200: productv1.RequireStorageMetadataScoreByIdFields.metadata:type_name -> productv1.RequireStorageMetadataScoreByIdFields.StorageMetadata - 243, // 201: productv1.RequireStorageProcessedMetadataByIdRequest.context:type_name -> productv1.RequireStorageProcessedMetadataByIdContext - 26, // 202: productv1.RequireStorageProcessedMetadataByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey - 246, // 203: productv1.RequireStorageProcessedMetadataByIdContext.fields:type_name -> productv1.RequireStorageProcessedMetadataByIdFields - 245, // 204: productv1.RequireStorageProcessedMetadataByIdResponse.result:type_name -> productv1.RequireStorageProcessedMetadataByIdResult - 314, // 205: productv1.RequireStorageProcessedMetadataByIdResult.processed_metadata:type_name -> productv1.StorageMetadata - 362, // 206: productv1.RequireStorageProcessedMetadataByIdFields.metadata:type_name -> productv1.RequireStorageProcessedMetadataByIdFields.StorageMetadata - 248, // 207: productv1.RequireStorageOptionalProcessedMetadataByIdRequest.context:type_name -> productv1.RequireStorageOptionalProcessedMetadataByIdContext - 26, // 208: productv1.RequireStorageOptionalProcessedMetadataByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey - 251, // 209: productv1.RequireStorageOptionalProcessedMetadataByIdContext.fields:type_name -> productv1.RequireStorageOptionalProcessedMetadataByIdFields - 250, // 210: productv1.RequireStorageOptionalProcessedMetadataByIdResponse.result:type_name -> productv1.RequireStorageOptionalProcessedMetadataByIdResult - 314, // 211: productv1.RequireStorageOptionalProcessedMetadataByIdResult.optional_processed_metadata:type_name -> productv1.StorageMetadata - 363, // 212: productv1.RequireStorageOptionalProcessedMetadataByIdFields.metadata:type_name -> productv1.RequireStorageOptionalProcessedMetadataByIdFields.StorageMetadata - 253, // 213: productv1.RequireStorageProcessedTagsByIdRequest.context:type_name -> productv1.RequireStorageProcessedTagsByIdContext - 26, // 214: productv1.RequireStorageProcessedTagsByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey - 256, // 215: productv1.RequireStorageProcessedTagsByIdContext.fields:type_name -> productv1.RequireStorageProcessedTagsByIdFields - 255, // 216: productv1.RequireStorageProcessedTagsByIdResponse.result:type_name -> productv1.RequireStorageProcessedTagsByIdResult - 258, // 217: productv1.RequireStorageOptionalProcessedTagsByIdRequest.context:type_name -> productv1.RequireStorageOptionalProcessedTagsByIdContext - 26, // 218: productv1.RequireStorageOptionalProcessedTagsByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey - 261, // 219: productv1.RequireStorageOptionalProcessedTagsByIdContext.fields:type_name -> productv1.RequireStorageOptionalProcessedTagsByIdFields - 260, // 220: productv1.RequireStorageOptionalProcessedTagsByIdResponse.result:type_name -> productv1.RequireStorageOptionalProcessedTagsByIdResult - 19, // 221: productv1.RequireStorageOptionalProcessedTagsByIdResult.optional_processed_tags:type_name -> productv1.ListOfString - 19, // 222: productv1.RequireStorageOptionalProcessedTagsByIdFields.optional_tags:type_name -> productv1.ListOfString - 263, // 223: productv1.RequireStorageProcessedMetadataHistoryByIdRequest.context:type_name -> productv1.RequireStorageProcessedMetadataHistoryByIdContext - 26, // 224: productv1.RequireStorageProcessedMetadataHistoryByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey - 266, // 225: productv1.RequireStorageProcessedMetadataHistoryByIdContext.fields:type_name -> productv1.RequireStorageProcessedMetadataHistoryByIdFields - 265, // 226: productv1.RequireStorageProcessedMetadataHistoryByIdResponse.result:type_name -> productv1.RequireStorageProcessedMetadataHistoryByIdResult - 314, // 227: productv1.RequireStorageProcessedMetadataHistoryByIdResult.processed_metadata_history:type_name -> productv1.StorageMetadata - 364, // 228: productv1.RequireStorageProcessedMetadataHistoryByIdFields.metadata_history:type_name -> productv1.RequireStorageProcessedMetadataHistoryByIdFields.StorageMetadata - 268, // 229: productv1.RequireStorageKindSummaryByIdRequest.context:type_name -> productv1.RequireStorageKindSummaryByIdContext - 26, // 230: productv1.RequireStorageKindSummaryByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey - 271, // 231: productv1.RequireStorageKindSummaryByIdContext.fields:type_name -> productv1.RequireStorageKindSummaryByIdFields - 270, // 232: productv1.RequireStorageKindSummaryByIdResponse.result:type_name -> productv1.RequireStorageKindSummaryByIdResult - 0, // 233: productv1.RequireStorageKindSummaryByIdFields.storage_kind:type_name -> productv1.CategoryKind - 273, // 234: productv1.RequireStorageCategoryInfoSummaryByIdRequest.context:type_name -> productv1.RequireStorageCategoryInfoSummaryByIdContext - 26, // 235: productv1.RequireStorageCategoryInfoSummaryByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey - 276, // 236: productv1.RequireStorageCategoryInfoSummaryByIdContext.fields:type_name -> productv1.RequireStorageCategoryInfoSummaryByIdFields - 275, // 237: productv1.RequireStorageCategoryInfoSummaryByIdResponse.result:type_name -> productv1.RequireStorageCategoryInfoSummaryByIdResult - 365, // 238: productv1.RequireStorageCategoryInfoSummaryByIdFields.category_info:type_name -> productv1.RequireStorageCategoryInfoSummaryByIdFields.StorageCategoryInfo - 278, // 239: productv1.RequireWarehouseStockHealthScoreByIdRequest.context:type_name -> productv1.RequireWarehouseStockHealthScoreByIdContext - 29, // 240: productv1.RequireWarehouseStockHealthScoreByIdContext.key:type_name -> productv1.LookupWarehouseByIdRequestKey - 281, // 241: productv1.RequireWarehouseStockHealthScoreByIdContext.fields:type_name -> productv1.RequireWarehouseStockHealthScoreByIdFields - 280, // 242: productv1.RequireWarehouseStockHealthScoreByIdResponse.result:type_name -> productv1.RequireWarehouseStockHealthScoreByIdResult - 366, // 243: productv1.RequireWarehouseStockHealthScoreByIdFields.restock_data:type_name -> productv1.RequireWarehouseStockHealthScoreByIdFields.RestockData - 316, // 244: productv1.NestedTypeA.b:type_name -> productv1.NestedTypeB - 287, // 245: productv1.RecursiveType.recursive_type:type_name -> productv1.RecursiveType - 318, // 246: productv1.ComplexFilterTypeInput.filter:type_name -> productv1.FilterType - 320, // 247: productv1.OrderInput.lines:type_name -> productv1.OrderLineInput - 16, // 248: productv1.Order.order_lines:type_name -> productv1.ListOfOrderLine - 0, // 249: productv1.Category.kind:type_name -> productv1.CategoryKind - 20, // 250: productv1.Category.subcategories:type_name -> productv1.ListOfSubcategory - 323, // 251: productv1.Category.null_metrics:type_name -> productv1.CategoryMetrics - 0, // 252: productv1.CategoryFilter.category:type_name -> productv1.CategoryKind - 319, // 253: productv1.CategoryFilter.pagination:type_name -> productv1.Pagination - 324, // 254: productv1.Animal.cat:type_name -> productv1.Cat - 325, // 255: productv1.Animal.dog:type_name -> productv1.Dog - 367, // 256: productv1.SearchInput.limit:type_name -> google.protobuf.Int32Value - 282, // 257: productv1.SearchResult.product:type_name -> productv1.Product - 285, // 258: productv1.SearchResult.user:type_name -> productv1.User - 294, // 259: productv1.SearchResult.category:type_name -> productv1.Category - 369, // 260: productv1.NullableFieldsType.optional_string:type_name -> google.protobuf.StringValue - 367, // 261: productv1.NullableFieldsType.optional_int:type_name -> google.protobuf.Int32Value - 370, // 262: productv1.NullableFieldsType.optional_float:type_name -> google.protobuf.DoubleValue - 368, // 263: productv1.NullableFieldsType.optional_boolean:type_name -> google.protobuf.BoolValue - 369, // 264: productv1.NullableFieldsFilter.name:type_name -> google.protobuf.StringValue - 369, // 265: productv1.NullableFieldsFilter.optional_string:type_name -> google.protobuf.StringValue - 368, // 266: productv1.NullableFieldsFilter.include_nulls:type_name -> google.protobuf.BoolValue - 19, // 267: productv1.BlogPost.optional_tags:type_name -> productv1.ListOfString - 19, // 268: productv1.BlogPost.keywords:type_name -> productv1.ListOfString - 10, // 269: productv1.BlogPost.ratings:type_name -> productv1.ListOfFloat - 7, // 270: productv1.BlogPost.is_published:type_name -> productv1.ListOfBoolean - 13, // 271: productv1.BlogPost.tag_groups:type_name -> productv1.ListOfListOfString - 13, // 272: productv1.BlogPost.related_topics:type_name -> productv1.ListOfListOfString - 13, // 273: productv1.BlogPost.comment_threads:type_name -> productv1.ListOfListOfString - 13, // 274: productv1.BlogPost.suggestions:type_name -> productv1.ListOfListOfString - 294, // 275: productv1.BlogPost.related_categories:type_name -> productv1.Category - 285, // 276: productv1.BlogPost.contributors:type_name -> productv1.User - 17, // 277: productv1.BlogPost.mentioned_products:type_name -> productv1.ListOfProduct - 21, // 278: productv1.BlogPost.mentioned_users:type_name -> productv1.ListOfUser - 11, // 279: productv1.BlogPost.category_groups:type_name -> productv1.ListOfListOfCategory - 14, // 280: productv1.BlogPost.contributor_teams:type_name -> productv1.ListOfListOfUser - 369, // 281: productv1.BlogPostFilter.title:type_name -> google.protobuf.StringValue - 368, // 282: productv1.BlogPostFilter.has_categories:type_name -> google.protobuf.BoolValue - 367, // 283: productv1.BlogPostFilter.min_tags:type_name -> google.protobuf.Int32Value - 369, // 284: productv1.Author.email:type_name -> google.protobuf.StringValue - 19, // 285: productv1.Author.social_links:type_name -> productv1.ListOfString - 13, // 286: productv1.Author.teams_by_project:type_name -> productv1.ListOfListOfString - 13, // 287: productv1.Author.collaborations:type_name -> productv1.ListOfListOfString - 4, // 288: productv1.Author.written_posts:type_name -> productv1.ListOfBlogPost - 294, // 289: productv1.Author.favorite_categories:type_name -> productv1.Category - 21, // 290: productv1.Author.related_authors:type_name -> productv1.ListOfUser - 17, // 291: productv1.Author.product_reviews:type_name -> productv1.ListOfProduct - 14, // 292: productv1.Author.author_groups:type_name -> productv1.ListOfListOfUser - 11, // 293: productv1.Author.category_preferences:type_name -> productv1.ListOfListOfCategory - 14, // 294: productv1.Author.project_teams:type_name -> productv1.ListOfListOfUser - 369, // 295: productv1.AuthorFilter.name:type_name -> google.protobuf.StringValue - 368, // 296: productv1.AuthorFilter.has_teams:type_name -> google.protobuf.BoolValue - 367, // 297: productv1.AuthorFilter.skill_count:type_name -> google.protobuf.Int32Value - 369, // 298: productv1.TestContainer.description:type_name -> google.protobuf.StringValue - 332, // 299: productv1.ActionResult.action_success:type_name -> productv1.ActionSuccess - 333, // 300: productv1.ActionResult.action_error:type_name -> productv1.ActionError - 369, // 301: productv1.NullableFieldsInput.optional_string:type_name -> google.protobuf.StringValue - 367, // 302: productv1.NullableFieldsInput.optional_int:type_name -> google.protobuf.Int32Value - 370, // 303: productv1.NullableFieldsInput.optional_float:type_name -> google.protobuf.DoubleValue - 368, // 304: productv1.NullableFieldsInput.optional_boolean:type_name -> google.protobuf.BoolValue - 19, // 305: productv1.BlogPostInput.optional_tags:type_name -> productv1.ListOfString - 19, // 306: productv1.BlogPostInput.keywords:type_name -> productv1.ListOfString - 10, // 307: productv1.BlogPostInput.ratings:type_name -> productv1.ListOfFloat - 7, // 308: productv1.BlogPostInput.is_published:type_name -> productv1.ListOfBoolean - 13, // 309: productv1.BlogPostInput.tag_groups:type_name -> productv1.ListOfListOfString - 13, // 310: productv1.BlogPostInput.related_topics:type_name -> productv1.ListOfListOfString - 13, // 311: productv1.BlogPostInput.comment_threads:type_name -> productv1.ListOfListOfString - 13, // 312: productv1.BlogPostInput.suggestions:type_name -> productv1.ListOfListOfString - 9, // 313: productv1.BlogPostInput.related_categories:type_name -> productv1.ListOfCategoryInput - 22, // 314: productv1.BlogPostInput.contributors:type_name -> productv1.ListOfUserInput - 12, // 315: productv1.BlogPostInput.category_groups:type_name -> productv1.ListOfListOfCategoryInput - 369, // 316: productv1.AuthorInput.email:type_name -> google.protobuf.StringValue - 19, // 317: productv1.AuthorInput.social_links:type_name -> productv1.ListOfString - 13, // 318: productv1.AuthorInput.teams_by_project:type_name -> productv1.ListOfListOfString - 13, // 319: productv1.AuthorInput.collaborations:type_name -> productv1.ListOfListOfString - 335, // 320: productv1.AuthorInput.favorite_categories:type_name -> productv1.CategoryInput - 15, // 321: productv1.AuthorInput.author_groups:type_name -> productv1.ListOfListOfUserInput - 15, // 322: productv1.AuthorInput.project_teams:type_name -> productv1.ListOfListOfUserInput - 308, // 323: productv1.ProductDetails.review_summary:type_name -> productv1.ActionResult - 296, // 324: productv1.ProductDetails.recommended_pet:type_name -> productv1.Animal - 0, // 325: productv1.StorageCategoryInfo.kind:type_name -> productv1.CategoryKind - 317, // 326: productv1.NestedTypeB.c:type_name -> productv1.NestedTypeC - 319, // 327: productv1.FilterType.pagination:type_name -> productv1.Pagination - 19, // 328: productv1.OrderLineInput.modifiers:type_name -> productv1.ListOfString - 19, // 329: productv1.OrderLine.modifiers:type_name -> productv1.ListOfString - 369, // 330: productv1.Subcategory.description:type_name -> google.protobuf.StringValue - 326, // 331: productv1.Cat.owner:type_name -> productv1.Owner - 329, // 332: productv1.Cat.breed:type_name -> productv1.CatBreed - 326, // 333: productv1.Dog.owner:type_name -> productv1.Owner - 330, // 334: productv1.Dog.breed:type_name -> productv1.DogBreed - 327, // 335: productv1.Owner.contact:type_name -> productv1.ContactInfo - 296, // 336: productv1.Owner.pet:type_name -> productv1.Animal - 328, // 337: productv1.ContactInfo.address:type_name -> productv1.Address - 331, // 338: productv1.CatBreed.characteristics:type_name -> productv1.BreedCharacteristics - 331, // 339: productv1.DogBreed.characteristics:type_name -> productv1.BreedCharacteristics - 296, // 340: productv1.TestDetails.pet:type_name -> productv1.Animal - 308, // 341: productv1.TestDetails.status:type_name -> productv1.ActionResult - 0, // 342: productv1.CategoryInput.kind:type_name -> productv1.CategoryKind - 370, // 343: productv1.ProductCountFilter.min_price:type_name -> google.protobuf.DoubleValue - 370, // 344: productv1.ProductCountFilter.max_price:type_name -> google.protobuf.DoubleValue - 368, // 345: productv1.ProductCountFilter.in_stock:type_name -> google.protobuf.BoolValue - 369, // 346: productv1.ProductCountFilter.search_term:type_name -> google.protobuf.StringValue - 370, // 347: productv1.SubcategoryItemFilter.min_price:type_name -> google.protobuf.DoubleValue - 370, // 348: productv1.SubcategoryItemFilter.max_price:type_name -> google.protobuf.DoubleValue - 368, // 349: productv1.SubcategoryItemFilter.in_stock:type_name -> google.protobuf.BoolValue - 368, // 350: productv1.SubcategoryItemFilter.is_active:type_name -> google.protobuf.BoolValue - 369, // 351: productv1.SubcategoryItemFilter.search_term:type_name -> google.protobuf.StringValue - 1, // 352: productv1.ShippingEstimateInput.destination:type_name -> productv1.ShippingDestination - 368, // 353: productv1.ShippingEstimateInput.expedited:type_name -> google.protobuf.BoolValue - 304, // 354: productv1.ListOfAuthorFilter.List.items:type_name -> productv1.AuthorFilter - 311, // 355: productv1.ListOfAuthorInput.List.items:type_name -> productv1.AuthorInput - 301, // 356: productv1.ListOfBlogPost.List.items:type_name -> productv1.BlogPost - 302, // 357: productv1.ListOfBlogPostFilter.List.items:type_name -> productv1.BlogPostFilter - 310, // 358: productv1.ListOfBlogPostInput.List.items:type_name -> productv1.BlogPostInput - 294, // 359: productv1.ListOfCategory.List.items:type_name -> productv1.Category - 335, // 360: productv1.ListOfCategoryInput.List.items:type_name -> productv1.CategoryInput - 8, // 361: productv1.ListOfListOfCategory.List.items:type_name -> productv1.ListOfCategory - 9, // 362: productv1.ListOfListOfCategoryInput.List.items:type_name -> productv1.ListOfCategoryInput - 19, // 363: productv1.ListOfListOfString.List.items:type_name -> productv1.ListOfString - 21, // 364: productv1.ListOfListOfUser.List.items:type_name -> productv1.ListOfUser - 22, // 365: productv1.ListOfListOfUserInput.List.items:type_name -> productv1.ListOfUserInput - 321, // 366: productv1.ListOfOrderLine.List.items:type_name -> productv1.OrderLine - 282, // 367: productv1.ListOfProduct.List.items:type_name -> productv1.Product - 283, // 368: productv1.ListOfStorage.List.items:type_name -> productv1.Storage - 322, // 369: productv1.ListOfSubcategory.List.items:type_name -> productv1.Subcategory - 285, // 370: productv1.ListOfUser.List.items:type_name -> productv1.User - 306, // 371: productv1.ListOfUserInput.List.items:type_name -> productv1.UserInput - 0, // 372: productv1.RequireStorageCategoryInfoSummaryByIdFields.StorageCategoryInfo.kind:type_name -> productv1.CategoryKind - 24, // 373: productv1.ProductService.LookupProductById:input_type -> productv1.LookupProductByIdRequest - 27, // 374: productv1.ProductService.LookupStorageById:input_type -> productv1.LookupStorageByIdRequest - 30, // 375: productv1.ProductService.LookupWarehouseById:input_type -> productv1.LookupWarehouseByIdRequest - 114, // 376: productv1.ProductService.MutationBulkCreateAuthors:input_type -> productv1.MutationBulkCreateAuthorsRequest - 118, // 377: productv1.ProductService.MutationBulkCreateBlogPosts:input_type -> productv1.MutationBulkCreateBlogPostsRequest - 116, // 378: productv1.ProductService.MutationBulkUpdateAuthors:input_type -> productv1.MutationBulkUpdateAuthorsRequest - 120, // 379: productv1.ProductService.MutationBulkUpdateBlogPosts:input_type -> productv1.MutationBulkUpdateBlogPostsRequest - 110, // 380: productv1.ProductService.MutationCreateAuthor:input_type -> productv1.MutationCreateAuthorRequest - 106, // 381: productv1.ProductService.MutationCreateBlogPost:input_type -> productv1.MutationCreateBlogPostRequest - 102, // 382: productv1.ProductService.MutationCreateNullableFieldsType:input_type -> productv1.MutationCreateNullableFieldsTypeRequest - 98, // 383: productv1.ProductService.MutationCreateUser:input_type -> productv1.MutationCreateUserRequest - 100, // 384: productv1.ProductService.MutationPerformAction:input_type -> productv1.MutationPerformActionRequest - 112, // 385: productv1.ProductService.MutationUpdateAuthor:input_type -> productv1.MutationUpdateAuthorRequest - 108, // 386: productv1.ProductService.MutationUpdateBlogPost:input_type -> productv1.MutationUpdateBlogPostRequest - 104, // 387: productv1.ProductService.MutationUpdateNullableFieldsType:input_type -> productv1.MutationUpdateNullableFieldsTypeRequest - 88, // 388: productv1.ProductService.QueryAllAuthors:input_type -> productv1.QueryAllAuthorsRequest - 80, // 389: productv1.ProductService.QueryAllBlogPosts:input_type -> productv1.QueryAllBlogPostsRequest - 72, // 390: productv1.ProductService.QueryAllNullableFieldsTypes:input_type -> productv1.QueryAllNullableFieldsTypesRequest - 60, // 391: productv1.ProductService.QueryAllPets:input_type -> productv1.QueryAllPetsRequest - 82, // 392: productv1.ProductService.QueryAuthor:input_type -> productv1.QueryAuthorRequest - 84, // 393: productv1.ProductService.QueryAuthorById:input_type -> productv1.QueryAuthorByIdRequest - 86, // 394: productv1.ProductService.QueryAuthorsWithFilter:input_type -> productv1.QueryAuthorsWithFilterRequest - 74, // 395: productv1.ProductService.QueryBlogPost:input_type -> productv1.QueryBlogPostRequest - 76, // 396: productv1.ProductService.QueryBlogPostById:input_type -> productv1.QueryBlogPostByIdRequest - 78, // 397: productv1.ProductService.QueryBlogPostsWithFilter:input_type -> productv1.QueryBlogPostsWithFilterRequest - 90, // 398: productv1.ProductService.QueryBulkSearchAuthors:input_type -> productv1.QueryBulkSearchAuthorsRequest - 92, // 399: productv1.ProductService.QueryBulkSearchBlogPosts:input_type -> productv1.QueryBulkSearchBlogPostsRequest - 46, // 400: productv1.ProductService.QueryCalculateTotals:input_type -> productv1.QueryCalculateTotalsRequest - 48, // 401: productv1.ProductService.QueryCategories:input_type -> productv1.QueryCategoriesRequest - 52, // 402: productv1.ProductService.QueryCategoriesByKind:input_type -> productv1.QueryCategoriesByKindRequest - 54, // 403: productv1.ProductService.QueryCategoriesByKinds:input_type -> productv1.QueryCategoriesByKindsRequest - 50, // 404: productv1.ProductService.QueryCategory:input_type -> productv1.QueryCategoryRequest - 44, // 405: productv1.ProductService.QueryComplexFilterType:input_type -> productv1.QueryComplexFilterTypeRequest - 56, // 406: productv1.ProductService.QueryFilterCategories:input_type -> productv1.QueryFilterCategoriesRequest - 36, // 407: productv1.ProductService.QueryNestedType:input_type -> productv1.QueryNestedTypeRequest - 66, // 408: productv1.ProductService.QueryNullableFieldsType:input_type -> productv1.QueryNullableFieldsTypeRequest - 68, // 409: productv1.ProductService.QueryNullableFieldsTypeById:input_type -> productv1.QueryNullableFieldsTypeByIdRequest - 70, // 410: productv1.ProductService.QueryNullableFieldsTypeWithFilter:input_type -> productv1.QueryNullableFieldsTypeWithFilterRequest - 58, // 411: productv1.ProductService.QueryRandomPet:input_type -> productv1.QueryRandomPetRequest - 64, // 412: productv1.ProductService.QueryRandomSearchResult:input_type -> productv1.QueryRandomSearchResultRequest - 38, // 413: productv1.ProductService.QueryRecursiveType:input_type -> productv1.QueryRecursiveTypeRequest - 62, // 414: productv1.ProductService.QuerySearch:input_type -> productv1.QuerySearchRequest - 94, // 415: productv1.ProductService.QueryTestContainer:input_type -> productv1.QueryTestContainerRequest - 96, // 416: productv1.ProductService.QueryTestContainers:input_type -> productv1.QueryTestContainersRequest - 40, // 417: productv1.ProductService.QueryTypeFilterWithArguments:input_type -> productv1.QueryTypeFilterWithArgumentsRequest - 42, // 418: productv1.ProductService.QueryTypeWithMultipleFilterFields:input_type -> productv1.QueryTypeWithMultipleFilterFieldsRequest - 34, // 419: productv1.ProductService.QueryUser:input_type -> productv1.QueryUserRequest - 32, // 420: productv1.ProductService.QueryUsers:input_type -> productv1.QueryUsersRequest - 272, // 421: productv1.ProductService.RequireStorageCategoryInfoSummaryById:input_type -> productv1.RequireStorageCategoryInfoSummaryByIdRequest - 267, // 422: productv1.ProductService.RequireStorageKindSummaryById:input_type -> productv1.RequireStorageKindSummaryByIdRequest - 237, // 423: productv1.ProductService.RequireStorageMetadataScoreById:input_type -> productv1.RequireStorageMetadataScoreByIdRequest - 247, // 424: productv1.ProductService.RequireStorageOptionalProcessedMetadataById:input_type -> productv1.RequireStorageOptionalProcessedMetadataByIdRequest - 257, // 425: productv1.ProductService.RequireStorageOptionalProcessedTagsById:input_type -> productv1.RequireStorageOptionalProcessedTagsByIdRequest - 232, // 426: productv1.ProductService.RequireStorageOptionalTagSummaryById:input_type -> productv1.RequireStorageOptionalTagSummaryByIdRequest - 242, // 427: productv1.ProductService.RequireStorageProcessedMetadataById:input_type -> productv1.RequireStorageProcessedMetadataByIdRequest - 262, // 428: productv1.ProductService.RequireStorageProcessedMetadataHistoryById:input_type -> productv1.RequireStorageProcessedMetadataHistoryByIdRequest - 252, // 429: productv1.ProductService.RequireStorageProcessedTagsById:input_type -> productv1.RequireStorageProcessedTagsByIdRequest - 222, // 430: productv1.ProductService.RequireStorageStockHealthScoreById:input_type -> productv1.RequireStorageStockHealthScoreByIdRequest - 227, // 431: productv1.ProductService.RequireStorageTagSummaryById:input_type -> productv1.RequireStorageTagSummaryByIdRequest - 277, // 432: productv1.ProductService.RequireWarehouseStockHealthScoreById:input_type -> productv1.RequireWarehouseStockHealthScoreByIdRequest - 174, // 433: productv1.ProductService.ResolveCategoryCategoryMetrics:input_type -> productv1.ResolveCategoryCategoryMetricsRequest - 184, // 434: productv1.ProductService.ResolveCategoryCategoryStatus:input_type -> productv1.ResolveCategoryCategoryStatusRequest - 189, // 435: productv1.ProductService.ResolveCategoryChildCategories:input_type -> productv1.ResolveCategoryChildCategoriesRequest - 179, // 436: productv1.ProductService.ResolveCategoryMascot:input_type -> productv1.ResolveCategoryMascotRequest - 209, // 437: productv1.ProductService.ResolveCategoryMetricsNormalizedScore:input_type -> productv1.ResolveCategoryMetricsNormalizedScoreRequest - 214, // 438: productv1.ProductService.ResolveCategoryMetricsRelatedCategory:input_type -> productv1.ResolveCategoryMetricsRelatedCategoryRequest - 194, // 439: productv1.ProductService.ResolveCategoryOptionalCategories:input_type -> productv1.ResolveCategoryOptionalCategoriesRequest - 169, // 440: productv1.ProductService.ResolveCategoryPopularityScore:input_type -> productv1.ResolveCategoryPopularityScoreRequest - 164, // 441: productv1.ProductService.ResolveCategoryProductCount:input_type -> productv1.ResolveCategoryProductCountRequest - 134, // 442: productv1.ProductService.ResolveProductMascotRecommendation:input_type -> productv1.ResolveProductMascotRecommendationRequest - 144, // 443: productv1.ProductService.ResolveProductProductDetails:input_type -> productv1.ResolveProductProductDetailsRequest - 129, // 444: productv1.ProductService.ResolveProductRecommendedCategory:input_type -> productv1.ResolveProductRecommendedCategoryRequest - 124, // 445: productv1.ProductService.ResolveProductShippingEstimate:input_type -> productv1.ResolveProductShippingEstimateRequest - 139, // 446: productv1.ProductService.ResolveProductStockStatus:input_type -> productv1.ResolveProductStockStatusRequest - 154, // 447: productv1.ProductService.ResolveStorageLinkedStorages:input_type -> productv1.ResolveStorageLinkedStoragesRequest - 159, // 448: productv1.ProductService.ResolveStorageNearbyStorages:input_type -> productv1.ResolveStorageNearbyStoragesRequest - 149, // 449: productv1.ProductService.ResolveStorageStorageStatus:input_type -> productv1.ResolveStorageStorageStatusRequest - 204, // 450: productv1.ProductService.ResolveSubcategoryFeaturedCategory:input_type -> productv1.ResolveSubcategoryFeaturedCategoryRequest - 199, // 451: productv1.ProductService.ResolveSubcategoryItemCount:input_type -> productv1.ResolveSubcategoryItemCountRequest - 219, // 452: productv1.ProductService.ResolveTestContainerDetails:input_type -> productv1.ResolveTestContainerDetailsRequest - 25, // 453: productv1.ProductService.LookupProductById:output_type -> productv1.LookupProductByIdResponse - 28, // 454: productv1.ProductService.LookupStorageById:output_type -> productv1.LookupStorageByIdResponse - 31, // 455: productv1.ProductService.LookupWarehouseById:output_type -> productv1.LookupWarehouseByIdResponse - 115, // 456: productv1.ProductService.MutationBulkCreateAuthors:output_type -> productv1.MutationBulkCreateAuthorsResponse - 119, // 457: productv1.ProductService.MutationBulkCreateBlogPosts:output_type -> productv1.MutationBulkCreateBlogPostsResponse - 117, // 458: productv1.ProductService.MutationBulkUpdateAuthors:output_type -> productv1.MutationBulkUpdateAuthorsResponse - 121, // 459: productv1.ProductService.MutationBulkUpdateBlogPosts:output_type -> productv1.MutationBulkUpdateBlogPostsResponse - 111, // 460: productv1.ProductService.MutationCreateAuthor:output_type -> productv1.MutationCreateAuthorResponse - 107, // 461: productv1.ProductService.MutationCreateBlogPost:output_type -> productv1.MutationCreateBlogPostResponse - 103, // 462: productv1.ProductService.MutationCreateNullableFieldsType:output_type -> productv1.MutationCreateNullableFieldsTypeResponse - 99, // 463: productv1.ProductService.MutationCreateUser:output_type -> productv1.MutationCreateUserResponse - 101, // 464: productv1.ProductService.MutationPerformAction:output_type -> productv1.MutationPerformActionResponse - 113, // 465: productv1.ProductService.MutationUpdateAuthor:output_type -> productv1.MutationUpdateAuthorResponse - 109, // 466: productv1.ProductService.MutationUpdateBlogPost:output_type -> productv1.MutationUpdateBlogPostResponse - 105, // 467: productv1.ProductService.MutationUpdateNullableFieldsType:output_type -> productv1.MutationUpdateNullableFieldsTypeResponse - 89, // 468: productv1.ProductService.QueryAllAuthors:output_type -> productv1.QueryAllAuthorsResponse - 81, // 469: productv1.ProductService.QueryAllBlogPosts:output_type -> productv1.QueryAllBlogPostsResponse - 73, // 470: productv1.ProductService.QueryAllNullableFieldsTypes:output_type -> productv1.QueryAllNullableFieldsTypesResponse - 61, // 471: productv1.ProductService.QueryAllPets:output_type -> productv1.QueryAllPetsResponse - 83, // 472: productv1.ProductService.QueryAuthor:output_type -> productv1.QueryAuthorResponse - 85, // 473: productv1.ProductService.QueryAuthorById:output_type -> productv1.QueryAuthorByIdResponse - 87, // 474: productv1.ProductService.QueryAuthorsWithFilter:output_type -> productv1.QueryAuthorsWithFilterResponse - 75, // 475: productv1.ProductService.QueryBlogPost:output_type -> productv1.QueryBlogPostResponse - 77, // 476: productv1.ProductService.QueryBlogPostById:output_type -> productv1.QueryBlogPostByIdResponse - 79, // 477: productv1.ProductService.QueryBlogPostsWithFilter:output_type -> productv1.QueryBlogPostsWithFilterResponse - 91, // 478: productv1.ProductService.QueryBulkSearchAuthors:output_type -> productv1.QueryBulkSearchAuthorsResponse - 93, // 479: productv1.ProductService.QueryBulkSearchBlogPosts:output_type -> productv1.QueryBulkSearchBlogPostsResponse - 47, // 480: productv1.ProductService.QueryCalculateTotals:output_type -> productv1.QueryCalculateTotalsResponse - 49, // 481: productv1.ProductService.QueryCategories:output_type -> productv1.QueryCategoriesResponse - 53, // 482: productv1.ProductService.QueryCategoriesByKind:output_type -> productv1.QueryCategoriesByKindResponse - 55, // 483: productv1.ProductService.QueryCategoriesByKinds:output_type -> productv1.QueryCategoriesByKindsResponse - 51, // 484: productv1.ProductService.QueryCategory:output_type -> productv1.QueryCategoryResponse - 45, // 485: productv1.ProductService.QueryComplexFilterType:output_type -> productv1.QueryComplexFilterTypeResponse - 57, // 486: productv1.ProductService.QueryFilterCategories:output_type -> productv1.QueryFilterCategoriesResponse - 37, // 487: productv1.ProductService.QueryNestedType:output_type -> productv1.QueryNestedTypeResponse - 67, // 488: productv1.ProductService.QueryNullableFieldsType:output_type -> productv1.QueryNullableFieldsTypeResponse - 69, // 489: productv1.ProductService.QueryNullableFieldsTypeById:output_type -> productv1.QueryNullableFieldsTypeByIdResponse - 71, // 490: productv1.ProductService.QueryNullableFieldsTypeWithFilter:output_type -> productv1.QueryNullableFieldsTypeWithFilterResponse - 59, // 491: productv1.ProductService.QueryRandomPet:output_type -> productv1.QueryRandomPetResponse - 65, // 492: productv1.ProductService.QueryRandomSearchResult:output_type -> productv1.QueryRandomSearchResultResponse - 39, // 493: productv1.ProductService.QueryRecursiveType:output_type -> productv1.QueryRecursiveTypeResponse - 63, // 494: productv1.ProductService.QuerySearch:output_type -> productv1.QuerySearchResponse - 95, // 495: productv1.ProductService.QueryTestContainer:output_type -> productv1.QueryTestContainerResponse - 97, // 496: productv1.ProductService.QueryTestContainers:output_type -> productv1.QueryTestContainersResponse - 41, // 497: productv1.ProductService.QueryTypeFilterWithArguments:output_type -> productv1.QueryTypeFilterWithArgumentsResponse - 43, // 498: productv1.ProductService.QueryTypeWithMultipleFilterFields:output_type -> productv1.QueryTypeWithMultipleFilterFieldsResponse - 35, // 499: productv1.ProductService.QueryUser:output_type -> productv1.QueryUserResponse - 33, // 500: productv1.ProductService.QueryUsers:output_type -> productv1.QueryUsersResponse - 274, // 501: productv1.ProductService.RequireStorageCategoryInfoSummaryById:output_type -> productv1.RequireStorageCategoryInfoSummaryByIdResponse - 269, // 502: productv1.ProductService.RequireStorageKindSummaryById:output_type -> productv1.RequireStorageKindSummaryByIdResponse - 239, // 503: productv1.ProductService.RequireStorageMetadataScoreById:output_type -> productv1.RequireStorageMetadataScoreByIdResponse - 249, // 504: productv1.ProductService.RequireStorageOptionalProcessedMetadataById:output_type -> productv1.RequireStorageOptionalProcessedMetadataByIdResponse - 259, // 505: productv1.ProductService.RequireStorageOptionalProcessedTagsById:output_type -> productv1.RequireStorageOptionalProcessedTagsByIdResponse - 234, // 506: productv1.ProductService.RequireStorageOptionalTagSummaryById:output_type -> productv1.RequireStorageOptionalTagSummaryByIdResponse - 244, // 507: productv1.ProductService.RequireStorageProcessedMetadataById:output_type -> productv1.RequireStorageProcessedMetadataByIdResponse - 264, // 508: productv1.ProductService.RequireStorageProcessedMetadataHistoryById:output_type -> productv1.RequireStorageProcessedMetadataHistoryByIdResponse - 254, // 509: productv1.ProductService.RequireStorageProcessedTagsById:output_type -> productv1.RequireStorageProcessedTagsByIdResponse - 224, // 510: productv1.ProductService.RequireStorageStockHealthScoreById:output_type -> productv1.RequireStorageStockHealthScoreByIdResponse - 229, // 511: productv1.ProductService.RequireStorageTagSummaryById:output_type -> productv1.RequireStorageTagSummaryByIdResponse - 279, // 512: productv1.ProductService.RequireWarehouseStockHealthScoreById:output_type -> productv1.RequireWarehouseStockHealthScoreByIdResponse - 176, // 513: productv1.ProductService.ResolveCategoryCategoryMetrics:output_type -> productv1.ResolveCategoryCategoryMetricsResponse - 186, // 514: productv1.ProductService.ResolveCategoryCategoryStatus:output_type -> productv1.ResolveCategoryCategoryStatusResponse - 191, // 515: productv1.ProductService.ResolveCategoryChildCategories:output_type -> productv1.ResolveCategoryChildCategoriesResponse - 181, // 516: productv1.ProductService.ResolveCategoryMascot:output_type -> productv1.ResolveCategoryMascotResponse - 211, // 517: productv1.ProductService.ResolveCategoryMetricsNormalizedScore:output_type -> productv1.ResolveCategoryMetricsNormalizedScoreResponse - 216, // 518: productv1.ProductService.ResolveCategoryMetricsRelatedCategory:output_type -> productv1.ResolveCategoryMetricsRelatedCategoryResponse - 196, // 519: productv1.ProductService.ResolveCategoryOptionalCategories:output_type -> productv1.ResolveCategoryOptionalCategoriesResponse - 171, // 520: productv1.ProductService.ResolveCategoryPopularityScore:output_type -> productv1.ResolveCategoryPopularityScoreResponse - 166, // 521: productv1.ProductService.ResolveCategoryProductCount:output_type -> productv1.ResolveCategoryProductCountResponse - 136, // 522: productv1.ProductService.ResolveProductMascotRecommendation:output_type -> productv1.ResolveProductMascotRecommendationResponse - 146, // 523: productv1.ProductService.ResolveProductProductDetails:output_type -> productv1.ResolveProductProductDetailsResponse - 131, // 524: productv1.ProductService.ResolveProductRecommendedCategory:output_type -> productv1.ResolveProductRecommendedCategoryResponse - 126, // 525: productv1.ProductService.ResolveProductShippingEstimate:output_type -> productv1.ResolveProductShippingEstimateResponse - 141, // 526: productv1.ProductService.ResolveProductStockStatus:output_type -> productv1.ResolveProductStockStatusResponse - 156, // 527: productv1.ProductService.ResolveStorageLinkedStorages:output_type -> productv1.ResolveStorageLinkedStoragesResponse - 161, // 528: productv1.ProductService.ResolveStorageNearbyStorages:output_type -> productv1.ResolveStorageNearbyStoragesResponse - 151, // 529: productv1.ProductService.ResolveStorageStorageStatus:output_type -> productv1.ResolveStorageStorageStatusResponse - 206, // 530: productv1.ProductService.ResolveSubcategoryFeaturedCategory:output_type -> productv1.ResolveSubcategoryFeaturedCategoryResponse - 201, // 531: productv1.ProductService.ResolveSubcategoryItemCount:output_type -> productv1.ResolveSubcategoryItemCountResponse - 221, // 532: productv1.ProductService.ResolveTestContainerDetails:output_type -> productv1.ResolveTestContainerDetailsResponse - 453, // [453:533] is the sub-list for method output_type - 373, // [373:453] is the sub-list for method input_type - 373, // [373:373] is the sub-list for extension type_name - 373, // [373:373] is the sub-list for extension extendee - 0, // [0:373] is the sub-list for field type_name + 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 + 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 + 207, // 168: productv1.ResolveCategoryActiveSubcategoriesResponse.result:type_name -> productv1.ResolveCategoryActiveSubcategoriesResult + 357, // 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 + 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 + 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 + 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 + 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 + 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 + 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 + 250, // 202: productv1.RequireStorageTagSummaryByIdResponse.result:type_name -> productv1.RequireStorageTagSummaryByIdResult + 253, // 203: productv1.RequireStorageOptionalTagSummaryByIdRequest.context:type_name -> productv1.RequireStorageOptionalTagSummaryByIdContext + 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 + 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 + 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 + 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 + 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 + 275, // 229: productv1.RequireStorageProcessedTagsByIdResponse.result:type_name -> productv1.RequireStorageProcessedTagsByIdResult + 278, // 230: productv1.RequireStorageOptionalProcessedTagsByIdRequest.context:type_name -> productv1.RequireStorageOptionalProcessedTagsByIdContext + 26, // 231: productv1.RequireStorageOptionalProcessedTagsByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey + 281, // 232: productv1.RequireStorageOptionalProcessedTagsByIdContext.fields:type_name -> productv1.RequireStorageOptionalProcessedTagsByIdFields + 280, // 233: productv1.RequireStorageOptionalProcessedTagsByIdResponse.result:type_name -> productv1.RequireStorageOptionalProcessedTagsByIdResult + 19, // 234: productv1.RequireStorageOptionalProcessedTagsByIdResult.optional_processed_tags:type_name -> productv1.ListOfString + 19, // 235: productv1.RequireStorageOptionalProcessedTagsByIdFields.optional_tags:type_name -> productv1.ListOfString + 283, // 236: productv1.RequireStorageProcessedMetadataHistoryByIdRequest.context:type_name -> productv1.RequireStorageProcessedMetadataHistoryByIdContext + 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 + 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 + 290, // 245: productv1.RequireStorageKindSummaryByIdResponse.result:type_name -> productv1.RequireStorageKindSummaryByIdResult + 0, // 246: productv1.RequireStorageKindSummaryByIdFields.storage_kind:type_name -> productv1.CategoryKind + 293, // 247: productv1.RequireStorageCategoryInfoSummaryByIdRequest.context:type_name -> productv1.RequireStorageCategoryInfoSummaryByIdContext + 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 } func init() { file_product_proto_init() } @@ -20385,16 +21377,16 @@ func file_product_proto_init() { if File_product_proto != nil { return } - file_product_proto_msgTypes[294].OneofWrappers = []any{ + file_product_proto_msgTypes[314].OneofWrappers = []any{ (*Animal_Cat)(nil), (*Animal_Dog)(nil), } - file_product_proto_msgTypes[296].OneofWrappers = []any{ + file_product_proto_msgTypes[316].OneofWrappers = []any{ (*SearchResult_Product)(nil), (*SearchResult_User)(nil), (*SearchResult_Category)(nil), } - file_product_proto_msgTypes[306].OneofWrappers = []any{ + file_product_proto_msgTypes[326].OneofWrappers = []any{ (*ActionResult_ActionSuccess)(nil), (*ActionResult_ActionError)(nil), } @@ -20404,7 +21396,7 @@ func file_product_proto_init() { GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: unsafe.Slice(unsafe.StringData(file_product_proto_rawDesc), len(file_product_proto_rawDesc)), NumEnums: 2, - NumMessages: 365, + NumMessages: 385, 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 9abd1c2864..2d827aae86 100644 --- a/v2/pkg/grpctest/productv1/product_grpc.pb.go +++ b/v2/pkg/grpctest/productv1/product_grpc.pb.go @@ -79,15 +79,19 @@ const ( ProductService_RequireStorageStockHealthScoreById_FullMethodName = "/productv1.ProductService/RequireStorageStockHealthScoreById" ProductService_RequireStorageTagSummaryById_FullMethodName = "/productv1.ProductService/RequireStorageTagSummaryById" ProductService_RequireWarehouseStockHealthScoreById_FullMethodName = "/productv1.ProductService/RequireWarehouseStockHealthScoreById" + ProductService_ResolveCategoryActiveSubcategories_FullMethodName = "/productv1.ProductService/ResolveCategoryActiveSubcategories" ProductService_ResolveCategoryCategoryMetrics_FullMethodName = "/productv1.ProductService/ResolveCategoryCategoryMetrics" ProductService_ResolveCategoryCategoryStatus_FullMethodName = "/productv1.ProductService/ResolveCategoryCategoryStatus" ProductService_ResolveCategoryChildCategories_FullMethodName = "/productv1.ProductService/ResolveCategoryChildCategories" ProductService_ResolveCategoryMascot_FullMethodName = "/productv1.ProductService/ResolveCategoryMascot" + ProductService_ResolveCategoryMetricsAverageScore_FullMethodName = "/productv1.ProductService/ResolveCategoryMetricsAverageScore" ProductService_ResolveCategoryMetricsNormalizedScore_FullMethodName = "/productv1.ProductService/ResolveCategoryMetricsNormalizedScore" ProductService_ResolveCategoryMetricsRelatedCategory_FullMethodName = "/productv1.ProductService/ResolveCategoryMetricsRelatedCategory" ProductService_ResolveCategoryOptionalCategories_FullMethodName = "/productv1.ProductService/ResolveCategoryOptionalCategories" ProductService_ResolveCategoryPopularityScore_FullMethodName = "/productv1.ProductService/ResolveCategoryPopularityScore" ProductService_ResolveCategoryProductCount_FullMethodName = "/productv1.ProductService/ResolveCategoryProductCount" + ProductService_ResolveCategoryTopSubcategory_FullMethodName = "/productv1.ProductService/ResolveCategoryTopSubcategory" + ProductService_ResolveCategoryTotalProducts_FullMethodName = "/productv1.ProductService/ResolveCategoryTotalProducts" ProductService_ResolveProductMascotRecommendation_FullMethodName = "/productv1.ProductService/ResolveProductMascotRecommendation" ProductService_ResolveProductProductDetails_FullMethodName = "/productv1.ProductService/ResolveProductProductDetails" ProductService_ResolveProductRecommendedCategory_FullMethodName = "/productv1.ProductService/ResolveProductRecommendedCategory" @@ -98,6 +102,7 @@ const ( ProductService_ResolveStorageStorageStatus_FullMethodName = "/productv1.ProductService/ResolveStorageStorageStatus" ProductService_ResolveSubcategoryFeaturedCategory_FullMethodName = "/productv1.ProductService/ResolveSubcategoryFeaturedCategory" ProductService_ResolveSubcategoryItemCount_FullMethodName = "/productv1.ProductService/ResolveSubcategoryItemCount" + ProductService_ResolveSubcategoryParentCategory_FullMethodName = "/productv1.ProductService/ResolveSubcategoryParentCategory" ProductService_ResolveTestContainerDetails_FullMethodName = "/productv1.ProductService/ResolveTestContainerDetails" ) @@ -170,15 +175,19 @@ type ProductServiceClient interface { 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) + ResolveCategoryActiveSubcategories(ctx context.Context, in *ResolveCategoryActiveSubcategoriesRequest, opts ...grpc.CallOption) (*ResolveCategoryActiveSubcategoriesResponse, error) ResolveCategoryCategoryMetrics(ctx context.Context, in *ResolveCategoryCategoryMetricsRequest, opts ...grpc.CallOption) (*ResolveCategoryCategoryMetricsResponse, error) ResolveCategoryCategoryStatus(ctx context.Context, in *ResolveCategoryCategoryStatusRequest, opts ...grpc.CallOption) (*ResolveCategoryCategoryStatusResponse, error) ResolveCategoryChildCategories(ctx context.Context, in *ResolveCategoryChildCategoriesRequest, opts ...grpc.CallOption) (*ResolveCategoryChildCategoriesResponse, error) ResolveCategoryMascot(ctx context.Context, in *ResolveCategoryMascotRequest, opts ...grpc.CallOption) (*ResolveCategoryMascotResponse, error) + ResolveCategoryMetricsAverageScore(ctx context.Context, in *ResolveCategoryMetricsAverageScoreRequest, opts ...grpc.CallOption) (*ResolveCategoryMetricsAverageScoreResponse, error) ResolveCategoryMetricsNormalizedScore(ctx context.Context, in *ResolveCategoryMetricsNormalizedScoreRequest, opts ...grpc.CallOption) (*ResolveCategoryMetricsNormalizedScoreResponse, error) ResolveCategoryMetricsRelatedCategory(ctx context.Context, in *ResolveCategoryMetricsRelatedCategoryRequest, opts ...grpc.CallOption) (*ResolveCategoryMetricsRelatedCategoryResponse, error) ResolveCategoryOptionalCategories(ctx context.Context, in *ResolveCategoryOptionalCategoriesRequest, opts ...grpc.CallOption) (*ResolveCategoryOptionalCategoriesResponse, error) ResolveCategoryPopularityScore(ctx context.Context, in *ResolveCategoryPopularityScoreRequest, opts ...grpc.CallOption) (*ResolveCategoryPopularityScoreResponse, error) ResolveCategoryProductCount(ctx context.Context, in *ResolveCategoryProductCountRequest, opts ...grpc.CallOption) (*ResolveCategoryProductCountResponse, error) + ResolveCategoryTopSubcategory(ctx context.Context, in *ResolveCategoryTopSubcategoryRequest, opts ...grpc.CallOption) (*ResolveCategoryTopSubcategoryResponse, error) + ResolveCategoryTotalProducts(ctx context.Context, in *ResolveCategoryTotalProductsRequest, opts ...grpc.CallOption) (*ResolveCategoryTotalProductsResponse, error) ResolveProductMascotRecommendation(ctx context.Context, in *ResolveProductMascotRecommendationRequest, opts ...grpc.CallOption) (*ResolveProductMascotRecommendationResponse, error) ResolveProductProductDetails(ctx context.Context, in *ResolveProductProductDetailsRequest, opts ...grpc.CallOption) (*ResolveProductProductDetailsResponse, error) ResolveProductRecommendedCategory(ctx context.Context, in *ResolveProductRecommendedCategoryRequest, opts ...grpc.CallOption) (*ResolveProductRecommendedCategoryResponse, error) @@ -189,6 +198,7 @@ type ProductServiceClient interface { ResolveStorageStorageStatus(ctx context.Context, in *ResolveStorageStorageStatusRequest, opts ...grpc.CallOption) (*ResolveStorageStorageStatusResponse, error) ResolveSubcategoryFeaturedCategory(ctx context.Context, in *ResolveSubcategoryFeaturedCategoryRequest, opts ...grpc.CallOption) (*ResolveSubcategoryFeaturedCategoryResponse, error) ResolveSubcategoryItemCount(ctx context.Context, in *ResolveSubcategoryItemCountRequest, opts ...grpc.CallOption) (*ResolveSubcategoryItemCountResponse, error) + ResolveSubcategoryParentCategory(ctx context.Context, in *ResolveSubcategoryParentCategoryRequest, opts ...grpc.CallOption) (*ResolveSubcategoryParentCategoryResponse, error) ResolveTestContainerDetails(ctx context.Context, in *ResolveTestContainerDetailsRequest, opts ...grpc.CallOption) (*ResolveTestContainerDetailsResponse, error) } @@ -800,6 +810,16 @@ func (c *productServiceClient) RequireWarehouseStockHealthScoreById(ctx context. return out, nil } +func (c *productServiceClient) ResolveCategoryActiveSubcategories(ctx context.Context, in *ResolveCategoryActiveSubcategoriesRequest, opts ...grpc.CallOption) (*ResolveCategoryActiveSubcategoriesResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(ResolveCategoryActiveSubcategoriesResponse) + err := c.cc.Invoke(ctx, ProductService_ResolveCategoryActiveSubcategories_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *productServiceClient) ResolveCategoryCategoryMetrics(ctx context.Context, in *ResolveCategoryCategoryMetricsRequest, opts ...grpc.CallOption) (*ResolveCategoryCategoryMetricsResponse, error) { cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(ResolveCategoryCategoryMetricsResponse) @@ -840,6 +860,16 @@ func (c *productServiceClient) ResolveCategoryMascot(ctx context.Context, in *Re return out, nil } +func (c *productServiceClient) ResolveCategoryMetricsAverageScore(ctx context.Context, in *ResolveCategoryMetricsAverageScoreRequest, opts ...grpc.CallOption) (*ResolveCategoryMetricsAverageScoreResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(ResolveCategoryMetricsAverageScoreResponse) + err := c.cc.Invoke(ctx, ProductService_ResolveCategoryMetricsAverageScore_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *productServiceClient) ResolveCategoryMetricsNormalizedScore(ctx context.Context, in *ResolveCategoryMetricsNormalizedScoreRequest, opts ...grpc.CallOption) (*ResolveCategoryMetricsNormalizedScoreResponse, error) { cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(ResolveCategoryMetricsNormalizedScoreResponse) @@ -890,6 +920,26 @@ func (c *productServiceClient) ResolveCategoryProductCount(ctx context.Context, return out, nil } +func (c *productServiceClient) ResolveCategoryTopSubcategory(ctx context.Context, in *ResolveCategoryTopSubcategoryRequest, opts ...grpc.CallOption) (*ResolveCategoryTopSubcategoryResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(ResolveCategoryTopSubcategoryResponse) + err := c.cc.Invoke(ctx, ProductService_ResolveCategoryTopSubcategory_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *productServiceClient) ResolveCategoryTotalProducts(ctx context.Context, in *ResolveCategoryTotalProductsRequest, opts ...grpc.CallOption) (*ResolveCategoryTotalProductsResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(ResolveCategoryTotalProductsResponse) + err := c.cc.Invoke(ctx, ProductService_ResolveCategoryTotalProducts_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *productServiceClient) ResolveProductMascotRecommendation(ctx context.Context, in *ResolveProductMascotRecommendationRequest, opts ...grpc.CallOption) (*ResolveProductMascotRecommendationResponse, error) { cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(ResolveProductMascotRecommendationResponse) @@ -990,6 +1040,16 @@ func (c *productServiceClient) ResolveSubcategoryItemCount(ctx context.Context, return out, nil } +func (c *productServiceClient) ResolveSubcategoryParentCategory(ctx context.Context, in *ResolveSubcategoryParentCategoryRequest, opts ...grpc.CallOption) (*ResolveSubcategoryParentCategoryResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(ResolveSubcategoryParentCategoryResponse) + err := c.cc.Invoke(ctx, ProductService_ResolveSubcategoryParentCategory_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *productServiceClient) ResolveTestContainerDetails(ctx context.Context, in *ResolveTestContainerDetailsRequest, opts ...grpc.CallOption) (*ResolveTestContainerDetailsResponse, error) { cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(ResolveTestContainerDetailsResponse) @@ -1069,15 +1129,19 @@ type ProductServiceServer interface { RequireStorageStockHealthScoreById(context.Context, *RequireStorageStockHealthScoreByIdRequest) (*RequireStorageStockHealthScoreByIdResponse, error) RequireStorageTagSummaryById(context.Context, *RequireStorageTagSummaryByIdRequest) (*RequireStorageTagSummaryByIdResponse, error) RequireWarehouseStockHealthScoreById(context.Context, *RequireWarehouseStockHealthScoreByIdRequest) (*RequireWarehouseStockHealthScoreByIdResponse, error) + ResolveCategoryActiveSubcategories(context.Context, *ResolveCategoryActiveSubcategoriesRequest) (*ResolveCategoryActiveSubcategoriesResponse, error) ResolveCategoryCategoryMetrics(context.Context, *ResolveCategoryCategoryMetricsRequest) (*ResolveCategoryCategoryMetricsResponse, error) ResolveCategoryCategoryStatus(context.Context, *ResolveCategoryCategoryStatusRequest) (*ResolveCategoryCategoryStatusResponse, error) ResolveCategoryChildCategories(context.Context, *ResolveCategoryChildCategoriesRequest) (*ResolveCategoryChildCategoriesResponse, error) ResolveCategoryMascot(context.Context, *ResolveCategoryMascotRequest) (*ResolveCategoryMascotResponse, error) + ResolveCategoryMetricsAverageScore(context.Context, *ResolveCategoryMetricsAverageScoreRequest) (*ResolveCategoryMetricsAverageScoreResponse, error) ResolveCategoryMetricsNormalizedScore(context.Context, *ResolveCategoryMetricsNormalizedScoreRequest) (*ResolveCategoryMetricsNormalizedScoreResponse, error) ResolveCategoryMetricsRelatedCategory(context.Context, *ResolveCategoryMetricsRelatedCategoryRequest) (*ResolveCategoryMetricsRelatedCategoryResponse, error) ResolveCategoryOptionalCategories(context.Context, *ResolveCategoryOptionalCategoriesRequest) (*ResolveCategoryOptionalCategoriesResponse, error) ResolveCategoryPopularityScore(context.Context, *ResolveCategoryPopularityScoreRequest) (*ResolveCategoryPopularityScoreResponse, error) ResolveCategoryProductCount(context.Context, *ResolveCategoryProductCountRequest) (*ResolveCategoryProductCountResponse, error) + ResolveCategoryTopSubcategory(context.Context, *ResolveCategoryTopSubcategoryRequest) (*ResolveCategoryTopSubcategoryResponse, error) + ResolveCategoryTotalProducts(context.Context, *ResolveCategoryTotalProductsRequest) (*ResolveCategoryTotalProductsResponse, error) ResolveProductMascotRecommendation(context.Context, *ResolveProductMascotRecommendationRequest) (*ResolveProductMascotRecommendationResponse, error) ResolveProductProductDetails(context.Context, *ResolveProductProductDetailsRequest) (*ResolveProductProductDetailsResponse, error) ResolveProductRecommendedCategory(context.Context, *ResolveProductRecommendedCategoryRequest) (*ResolveProductRecommendedCategoryResponse, error) @@ -1088,6 +1152,7 @@ type ProductServiceServer interface { ResolveStorageStorageStatus(context.Context, *ResolveStorageStorageStatusRequest) (*ResolveStorageStorageStatusResponse, error) ResolveSubcategoryFeaturedCategory(context.Context, *ResolveSubcategoryFeaturedCategoryRequest) (*ResolveSubcategoryFeaturedCategoryResponse, error) ResolveSubcategoryItemCount(context.Context, *ResolveSubcategoryItemCountRequest) (*ResolveSubcategoryItemCountResponse, error) + ResolveSubcategoryParentCategory(context.Context, *ResolveSubcategoryParentCategoryRequest) (*ResolveSubcategoryParentCategoryResponse, error) ResolveTestContainerDetails(context.Context, *ResolveTestContainerDetailsRequest) (*ResolveTestContainerDetailsResponse, error) mustEmbedUnimplementedProductServiceServer() } @@ -1279,6 +1344,9 @@ func (UnimplementedProductServiceServer) RequireStorageTagSummaryById(context.Co func (UnimplementedProductServiceServer) RequireWarehouseStockHealthScoreById(context.Context, *RequireWarehouseStockHealthScoreByIdRequest) (*RequireWarehouseStockHealthScoreByIdResponse, error) { return nil, status.Error(codes.Unimplemented, "method RequireWarehouseStockHealthScoreById not implemented") } +func (UnimplementedProductServiceServer) ResolveCategoryActiveSubcategories(context.Context, *ResolveCategoryActiveSubcategoriesRequest) (*ResolveCategoryActiveSubcategoriesResponse, error) { + return nil, status.Error(codes.Unimplemented, "method ResolveCategoryActiveSubcategories not implemented") +} func (UnimplementedProductServiceServer) ResolveCategoryCategoryMetrics(context.Context, *ResolveCategoryCategoryMetricsRequest) (*ResolveCategoryCategoryMetricsResponse, error) { return nil, status.Error(codes.Unimplemented, "method ResolveCategoryCategoryMetrics not implemented") } @@ -1291,6 +1359,9 @@ func (UnimplementedProductServiceServer) ResolveCategoryChildCategories(context. func (UnimplementedProductServiceServer) ResolveCategoryMascot(context.Context, *ResolveCategoryMascotRequest) (*ResolveCategoryMascotResponse, error) { return nil, status.Error(codes.Unimplemented, "method ResolveCategoryMascot not implemented") } +func (UnimplementedProductServiceServer) ResolveCategoryMetricsAverageScore(context.Context, *ResolveCategoryMetricsAverageScoreRequest) (*ResolveCategoryMetricsAverageScoreResponse, error) { + return nil, status.Error(codes.Unimplemented, "method ResolveCategoryMetricsAverageScore not implemented") +} func (UnimplementedProductServiceServer) ResolveCategoryMetricsNormalizedScore(context.Context, *ResolveCategoryMetricsNormalizedScoreRequest) (*ResolveCategoryMetricsNormalizedScoreResponse, error) { return nil, status.Error(codes.Unimplemented, "method ResolveCategoryMetricsNormalizedScore not implemented") } @@ -1306,6 +1377,12 @@ func (UnimplementedProductServiceServer) ResolveCategoryPopularityScore(context. func (UnimplementedProductServiceServer) ResolveCategoryProductCount(context.Context, *ResolveCategoryProductCountRequest) (*ResolveCategoryProductCountResponse, error) { return nil, status.Error(codes.Unimplemented, "method ResolveCategoryProductCount not implemented") } +func (UnimplementedProductServiceServer) ResolveCategoryTopSubcategory(context.Context, *ResolveCategoryTopSubcategoryRequest) (*ResolveCategoryTopSubcategoryResponse, error) { + return nil, status.Error(codes.Unimplemented, "method ResolveCategoryTopSubcategory not implemented") +} +func (UnimplementedProductServiceServer) ResolveCategoryTotalProducts(context.Context, *ResolveCategoryTotalProductsRequest) (*ResolveCategoryTotalProductsResponse, error) { + return nil, status.Error(codes.Unimplemented, "method ResolveCategoryTotalProducts not implemented") +} func (UnimplementedProductServiceServer) ResolveProductMascotRecommendation(context.Context, *ResolveProductMascotRecommendationRequest) (*ResolveProductMascotRecommendationResponse, error) { return nil, status.Error(codes.Unimplemented, "method ResolveProductMascotRecommendation not implemented") } @@ -1336,6 +1413,9 @@ func (UnimplementedProductServiceServer) ResolveSubcategoryFeaturedCategory(cont func (UnimplementedProductServiceServer) ResolveSubcategoryItemCount(context.Context, *ResolveSubcategoryItemCountRequest) (*ResolveSubcategoryItemCountResponse, error) { return nil, status.Error(codes.Unimplemented, "method ResolveSubcategoryItemCount not implemented") } +func (UnimplementedProductServiceServer) ResolveSubcategoryParentCategory(context.Context, *ResolveSubcategoryParentCategoryRequest) (*ResolveSubcategoryParentCategoryResponse, error) { + return nil, status.Error(codes.Unimplemented, "method ResolveSubcategoryParentCategory not implemented") +} func (UnimplementedProductServiceServer) ResolveTestContainerDetails(context.Context, *ResolveTestContainerDetailsRequest) (*ResolveTestContainerDetailsResponse, error) { return nil, status.Error(codes.Unimplemented, "method ResolveTestContainerDetails not implemented") } @@ -2440,6 +2520,24 @@ func _ProductService_RequireWarehouseStockHealthScoreById_Handler(srv interface{ return interceptor(ctx, in, info, handler) } +func _ProductService_ResolveCategoryActiveSubcategories_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ResolveCategoryActiveSubcategoriesRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProductServiceServer).ResolveCategoryActiveSubcategories(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ProductService_ResolveCategoryActiveSubcategories_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProductServiceServer).ResolveCategoryActiveSubcategories(ctx, req.(*ResolveCategoryActiveSubcategoriesRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _ProductService_ResolveCategoryCategoryMetrics_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ResolveCategoryCategoryMetricsRequest) if err := dec(in); err != nil { @@ -2512,6 +2610,24 @@ func _ProductService_ResolveCategoryMascot_Handler(srv interface{}, ctx context. return interceptor(ctx, in, info, handler) } +func _ProductService_ResolveCategoryMetricsAverageScore_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ResolveCategoryMetricsAverageScoreRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProductServiceServer).ResolveCategoryMetricsAverageScore(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ProductService_ResolveCategoryMetricsAverageScore_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProductServiceServer).ResolveCategoryMetricsAverageScore(ctx, req.(*ResolveCategoryMetricsAverageScoreRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _ProductService_ResolveCategoryMetricsNormalizedScore_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ResolveCategoryMetricsNormalizedScoreRequest) if err := dec(in); err != nil { @@ -2602,6 +2718,42 @@ func _ProductService_ResolveCategoryProductCount_Handler(srv interface{}, ctx co return interceptor(ctx, in, info, handler) } +func _ProductService_ResolveCategoryTopSubcategory_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ResolveCategoryTopSubcategoryRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProductServiceServer).ResolveCategoryTopSubcategory(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ProductService_ResolveCategoryTopSubcategory_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProductServiceServer).ResolveCategoryTopSubcategory(ctx, req.(*ResolveCategoryTopSubcategoryRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _ProductService_ResolveCategoryTotalProducts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ResolveCategoryTotalProductsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProductServiceServer).ResolveCategoryTotalProducts(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ProductService_ResolveCategoryTotalProducts_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProductServiceServer).ResolveCategoryTotalProducts(ctx, req.(*ResolveCategoryTotalProductsRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _ProductService_ResolveProductMascotRecommendation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ResolveProductMascotRecommendationRequest) if err := dec(in); err != nil { @@ -2782,6 +2934,24 @@ func _ProductService_ResolveSubcategoryItemCount_Handler(srv interface{}, ctx co return interceptor(ctx, in, info, handler) } +func _ProductService_ResolveSubcategoryParentCategory_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ResolveSubcategoryParentCategoryRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProductServiceServer).ResolveSubcategoryParentCategory(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ProductService_ResolveSubcategoryParentCategory_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProductServiceServer).ResolveSubcategoryParentCategory(ctx, req.(*ResolveSubcategoryParentCategoryRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _ProductService_ResolveTestContainerDetails_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ResolveTestContainerDetailsRequest) if err := dec(in); err != nil { @@ -3047,6 +3217,10 @@ var ProductService_ServiceDesc = grpc.ServiceDesc{ MethodName: "RequireWarehouseStockHealthScoreById", Handler: _ProductService_RequireWarehouseStockHealthScoreById_Handler, }, + { + MethodName: "ResolveCategoryActiveSubcategories", + Handler: _ProductService_ResolveCategoryActiveSubcategories_Handler, + }, { MethodName: "ResolveCategoryCategoryMetrics", Handler: _ProductService_ResolveCategoryCategoryMetrics_Handler, @@ -3063,6 +3237,10 @@ var ProductService_ServiceDesc = grpc.ServiceDesc{ MethodName: "ResolveCategoryMascot", Handler: _ProductService_ResolveCategoryMascot_Handler, }, + { + MethodName: "ResolveCategoryMetricsAverageScore", + Handler: _ProductService_ResolveCategoryMetricsAverageScore_Handler, + }, { MethodName: "ResolveCategoryMetricsNormalizedScore", Handler: _ProductService_ResolveCategoryMetricsNormalizedScore_Handler, @@ -3083,6 +3261,14 @@ var ProductService_ServiceDesc = grpc.ServiceDesc{ MethodName: "ResolveCategoryProductCount", Handler: _ProductService_ResolveCategoryProductCount_Handler, }, + { + MethodName: "ResolveCategoryTopSubcategory", + Handler: _ProductService_ResolveCategoryTopSubcategory_Handler, + }, + { + MethodName: "ResolveCategoryTotalProducts", + Handler: _ProductService_ResolveCategoryTotalProducts_Handler, + }, { MethodName: "ResolveProductMascotRecommendation", Handler: _ProductService_ResolveProductMascotRecommendation_Handler, @@ -3123,6 +3309,10 @@ var ProductService_ServiceDesc = grpc.ServiceDesc{ MethodName: "ResolveSubcategoryItemCount", Handler: _ProductService_ResolveSubcategoryItemCount_Handler, }, + { + MethodName: "ResolveSubcategoryParentCategory", + Handler: _ProductService_ResolveSubcategoryParentCategory_Handler, + }, { MethodName: "ResolveTestContainerDetails", Handler: _ProductService_ResolveTestContainerDetails_Handler, diff --git a/v2/pkg/grpctest/testdata/products.graphqls b/v2/pkg/grpctest/testdata/products.graphqls index 75ab52baa8..0d3d1585b3 100644 --- a/v2/pkg/grpctest/testdata/products.graphqls +++ b/v2/pkg/grpctest/testdata/products.graphqls @@ -192,6 +192,10 @@ type Category { optionalCategories(include: Boolean): [Category!] @connect__fieldResolver(context: "id name") # The nullMetrics field is used to test that nested field resolvers are not invoked when the parent result is null. nullMetrics: CategoryMetrics + # Argument-less field resolvers + totalProducts: Int! @connect__fieldResolver(context: "id") + topSubcategory: Subcategory @connect__fieldResolver(context: "id name") + activeSubcategories: [Subcategory!]! @connect__fieldResolver(context: "id") } type Subcategory { @@ -201,6 +205,8 @@ type Subcategory { isActive: Boolean! itemCount(filters: SubcategoryItemFilter): Int! @connect__fieldResolver(context: "id") featuredCategory(includeChildren: Boolean!): Category @connect__fieldResolver(context: "id") + # Argument-less field resolver + parentCategory: Category @connect__fieldResolver(context: "id") } type CategoryMetrics { @@ -211,6 +217,8 @@ type CategoryMetrics { categoryId: ID! normalizedScore(baseline: Float!): Float! @connect__fieldResolver(context: "id value metricType") relatedCategory(include: Boolean): Category @connect__fieldResolver(context: "categoryId") + # Argument-less field resolver (nested: CategoryMetrics is returned by a field resolver on Category) + averageScore: Float! @connect__fieldResolver(context: "id metricType") } enum CategoryKind {