From 76521383cbaae77dda725bd3deafc6ebb64f6220 Mon Sep 17 00:00:00 2001 From: Ludwig Bedacht Date: Wed, 11 Mar 2026 14:01:19 +0100 Subject: [PATCH 1/3] feat: support field resolvers without arguments --- .../datasource/grpc_datasource/compiler.go | 34 +- .../grpc_datasource/execution_plan.go | 61 +- .../execution_plan_field_resolvers_test.go | 810 +++++- .../grpc_datasource_spy_test.go | 123 +- .../grpc_datasource/mapping_test_helper.go | 55 + v2/pkg/grpctest/mapping/mapping.go | 15 + v2/pkg/grpctest/mockservice_resolve.go | 107 + v2/pkg/grpctest/product.proto | 97 + v2/pkg/grpctest/productv1/product.pb.go | 2322 ++++++++++++----- v2/pkg/grpctest/productv1/product_grpc.pb.go | 190 ++ v2/pkg/grpctest/testdata/products.graphqls | 8 + 11 files changed, 3011 insertions(+), 811 deletions(-) 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..e972c9aa8f 100644 --- a/v2/pkg/engine/datasource/grpc_datasource/mapping_test_helper.go +++ b/v2/pkg/engine/datasource/grpc_datasource/mapping_test_helper.go @@ -312,6 +312,30 @@ func testMapping() *GRPCMapping { Request: "ResolveCategoryOptionalCategoriesRequest", Response: "ResolveCategoryOptionalCategoriesResponse", }, + "totalProducts": { + FieldMappingData: FieldMapData{ + TargetName: "total_products", + }, + RPC: "ResolveCategoryTotalProducts", + Request: "ResolveCategoryTotalProductsRequest", + Response: "ResolveCategoryTotalProductsResponse", + }, + "topSubcategory": { + FieldMappingData: FieldMapData{ + TargetName: "top_subcategory", + }, + RPC: "ResolveCategoryTopSubcategory", + Request: "ResolveCategoryTopSubcategoryRequest", + Response: "ResolveCategoryTopSubcategoryResponse", + }, + "activeSubcategories": { + FieldMappingData: FieldMapData{ + TargetName: "active_subcategories", + }, + RPC: "ResolveCategoryActiveSubcategories", + Request: "ResolveCategoryActiveSubcategoriesRequest", + Response: "ResolveCategoryActiveSubcategoriesResponse", + }, }, "CategoryMetrics": { "normalizedScore": { @@ -336,6 +360,14 @@ func testMapping() *GRPCMapping { Request: "ResolveCategoryMetricsRelatedCategoryRequest", Response: "ResolveCategoryMetricsRelatedCategoryResponse", }, + "averageScore": { + FieldMappingData: FieldMapData{ + TargetName: "average_score", + }, + RPC: "ResolveCategoryMetricsAverageScore", + Request: "ResolveCategoryMetricsAverageScoreRequest", + Response: "ResolveCategoryMetricsAverageScoreResponse", + }, }, "Product": { "shippingEstimate": { @@ -452,6 +484,14 @@ func testMapping() *GRPCMapping { Request: "ResolveSubcategoryFeaturedCategoryRequest", Response: "ResolveSubcategoryFeaturedCategoryResponse", }, + "parentCategory": { + FieldMappingData: FieldMapData{ + TargetName: "parent_category", + }, + RPC: "ResolveSubcategoryParentCategory", + Request: "ResolveSubcategoryParentCategoryRequest", + Response: "ResolveSubcategoryParentCategoryResponse", + }, }, "TestContainer": { "details": { @@ -1253,6 +1293,15 @@ func testMapping() *GRPCMapping { "nullMetrics": { TargetName: "null_metrics", }, + "totalProducts": { + TargetName: "total_products", + }, + "topSubcategory": { + TargetName: "top_subcategory", + }, + "activeSubcategories": { + TargetName: "active_subcategories", + }, }, "Subcategory": { "id": { @@ -1279,6 +1328,9 @@ func testMapping() *GRPCMapping { "includeChildren": "include_children", }, }, + "parentCategory": { + TargetName: "parent_category", + }, }, "CategoryMetrics": { "id": { @@ -1308,6 +1360,9 @@ func testMapping() *GRPCMapping { "include": "include", }, }, + "averageScore": { + TargetName: "average_score", + }, }, "Cat": { "id": { diff --git a/v2/pkg/grpctest/mapping/mapping.go b/v2/pkg/grpctest/mapping/mapping.go index 1ded5e95cb..a43fc0350d 100644 --- a/v2/pkg/grpctest/mapping/mapping.go +++ b/v2/pkg/grpctest/mapping/mapping.go @@ -1260,6 +1260,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 +1295,9 @@ func DefaultGRPCMapping() *grpcdatasource.GRPCMapping { "includeChildren": "include_children", }, }, + "parentCategory": { + TargetName: "parent_category", + }, }, "CategoryMetrics": { "id": { @@ -1315,6 +1327,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..4c29db43a4 100644 --- a/v2/pkg/grpctest/product.proto +++ b/v2/pkg/grpctest/product.proto @@ -90,6 +90,11 @@ service ProductService { rpc ResolveSubcategoryFeaturedCategory(ResolveSubcategoryFeaturedCategoryRequest) returns (ResolveSubcategoryFeaturedCategoryResponse) {} rpc ResolveSubcategoryItemCount(ResolveSubcategoryItemCountRequest) returns (ResolveSubcategoryItemCountResponse) {} rpc ResolveTestContainerDetails(ResolveTestContainerDetailsRequest) returns (ResolveTestContainerDetailsResponse) {} + rpc ResolveCategoryTotalProducts(ResolveCategoryTotalProductsRequest) returns (ResolveCategoryTotalProductsResponse) {} + rpc ResolveCategoryTopSubcategory(ResolveCategoryTopSubcategoryRequest) returns (ResolveCategoryTopSubcategoryResponse) {} + rpc ResolveCategoryActiveSubcategories(ResolveCategoryActiveSubcategoriesRequest) returns (ResolveCategoryActiveSubcategoriesResponse) {} + rpc ResolveSubcategoryParentCategory(ResolveSubcategoryParentCategoryRequest) returns (ResolveSubcategoryParentCategoryResponse) {} + rpc ResolveCategoryMetricsAverageScore(ResolveCategoryMetricsAverageScoreRequest) returns (ResolveCategoryMetricsAverageScoreResponse) {} } // Wrapper message for a list of AuthorFilter. @@ -1559,6 +1564,9 @@ message Category { CategoryKind kind = 3; ListOfSubcategory subcategories = 4; CategoryMetrics null_metrics = 5; + int32 total_products = 6; + Subcategory top_subcategory = 7; + repeated Subcategory active_subcategories = 8; } message CategoryFilter { @@ -1782,6 +1790,7 @@ message Subcategory { string name = 2; google.protobuf.StringValue description = 3; bool is_active = 4; + Category parent_category = 5; } message CategoryMetrics { @@ -1790,6 +1799,7 @@ message CategoryMetrics { double value = 3; string timestamp = 4; string category_id = 5; + double average_score = 6; } enum CategoryKind { @@ -1906,4 +1916,91 @@ message ShippingEstimateInput { ShippingDestination destination = 1; double weight = 2; google.protobuf.BoolValue expedited = 3; +} + +// Argument-less field resolver messages for Category.totalProducts +message ResolveCategoryTotalProductsContext { + string id = 1; +} + +message ResolveCategoryTotalProductsRequest { + repeated ResolveCategoryTotalProductsContext context = 1; +} + +message ResolveCategoryTotalProductsResult { + int32 total_products = 1; +} + +message ResolveCategoryTotalProductsResponse { + repeated ResolveCategoryTotalProductsResult result = 1; +} + +// Argument-less field resolver messages for Category.topSubcategory +message ResolveCategoryTopSubcategoryContext { + string id = 1; + string name = 2; +} + +message ResolveCategoryTopSubcategoryRequest { + repeated ResolveCategoryTopSubcategoryContext context = 1; +} + +message ResolveCategoryTopSubcategoryResult { + Subcategory top_subcategory = 1; +} + +message ResolveCategoryTopSubcategoryResponse { + repeated ResolveCategoryTopSubcategoryResult result = 1; +} + +// Argument-less field resolver messages for Category.activeSubcategories +message ResolveCategoryActiveSubcategoriesContext { + string id = 1; +} + +message ResolveCategoryActiveSubcategoriesRequest { + repeated ResolveCategoryActiveSubcategoriesContext context = 1; +} + +message ResolveCategoryActiveSubcategoriesResult { + repeated Subcategory active_subcategories = 1; +} + +message ResolveCategoryActiveSubcategoriesResponse { + repeated ResolveCategoryActiveSubcategoriesResult result = 1; +} + +// Argument-less field resolver messages for Subcategory.parentCategory +message ResolveSubcategoryParentCategoryContext { + string id = 1; +} + +message ResolveSubcategoryParentCategoryRequest { + repeated ResolveSubcategoryParentCategoryContext context = 1; +} + +message ResolveSubcategoryParentCategoryResult { + Category parent_category = 1; +} + +message ResolveSubcategoryParentCategoryResponse { + repeated ResolveSubcategoryParentCategoryResult result = 1; +} + +// Argument-less field resolver messages for CategoryMetrics.averageScore +message ResolveCategoryMetricsAverageScoreContext { + string id = 1; + string metric_type = 2; +} + +message ResolveCategoryMetricsAverageScoreRequest { + repeated ResolveCategoryMetricsAverageScoreContext context = 1; +} + +message ResolveCategoryMetricsAverageScoreResult { + double average_score = 1; +} + +message ResolveCategoryMetricsAverageScoreResponse { + repeated ResolveCategoryMetricsAverageScoreResult result = 1; } \ No newline at end of file diff --git a/v2/pkg/grpctest/productv1/product.pb.go b/v2/pkg/grpctest/productv1/product.pb.go index 2969c86e3f..c41950292d 100644 --- a/v2/pkg/grpctest/productv1/product.pb.go +++ b/v2/pkg/grpctest/productv1/product.pb.go @@ -13738,14 +13738,17 @@ func (x *Order) GetOrderLines() *ListOfOrderLine { } type Category struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` - Kind CategoryKind `protobuf:"varint,3,opt,name=kind,proto3,enum=productv1.CategoryKind" json:"kind,omitempty"` - Subcategories *ListOfSubcategory `protobuf:"bytes,4,opt,name=subcategories,proto3" json:"subcategories,omitempty"` - NullMetrics *CategoryMetrics `protobuf:"bytes,5,opt,name=null_metrics,json=nullMetrics,proto3" json:"null_metrics,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + Kind CategoryKind `protobuf:"varint,3,opt,name=kind,proto3,enum=productv1.CategoryKind" json:"kind,omitempty"` + Subcategories *ListOfSubcategory `protobuf:"bytes,4,opt,name=subcategories,proto3" json:"subcategories,omitempty"` + NullMetrics *CategoryMetrics `protobuf:"bytes,5,opt,name=null_metrics,json=nullMetrics,proto3" json:"null_metrics,omitempty"` + TotalProducts int32 `protobuf:"varint,6,opt,name=total_products,json=totalProducts,proto3" json:"total_products,omitempty"` + TopSubcategory *Subcategory `protobuf:"bytes,7,opt,name=top_subcategory,json=topSubcategory,proto3" json:"top_subcategory,omitempty"` + ActiveSubcategories []*Subcategory `protobuf:"bytes,8,rep,name=active_subcategories,json=activeSubcategories,proto3" json:"active_subcategories,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *Category) Reset() { @@ -13813,6 +13816,27 @@ func (x *Category) GetNullMetrics() *CategoryMetrics { return nil } +func (x *Category) GetTotalProducts() int32 { + if x != nil { + return x.TotalProducts + } + return 0 +} + +func (x *Category) GetTopSubcategory() *Subcategory { + if x != nil { + return x.TopSubcategory + } + return nil +} + +func (x *Category) GetActiveSubcategories() []*Subcategory { + if x != nil { + return x.ActiveSubcategories + } + return nil +} + type CategoryFilter struct { state protoimpl.MessageState `protogen:"open.v1"` Category CategoryKind `protobuf:"varint,1,opt,name=category,proto3,enum=productv1.CategoryKind" json:"category,omitempty"` @@ -15916,13 +15940,14 @@ func (x *OrderLine) GetModifiers() *ListOfString { } type Subcategory struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` - Description *wrapperspb.StringValue `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"` - IsActive bool `protobuf:"varint,4,opt,name=is_active,json=isActive,proto3" json:"is_active,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + Description *wrapperspb.StringValue `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"` + IsActive bool `protobuf:"varint,4,opt,name=is_active,json=isActive,proto3" json:"is_active,omitempty"` + ParentCategory *Category `protobuf:"bytes,5,opt,name=parent_category,json=parentCategory,proto3" json:"parent_category,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *Subcategory) Reset() { @@ -15983,6 +16008,13 @@ func (x *Subcategory) GetIsActive() bool { return false } +func (x *Subcategory) GetParentCategory() *Category { + if x != nil { + return x.ParentCategory + } + return nil +} + type CategoryMetrics struct { state protoimpl.MessageState `protogen:"open.v1"` Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` @@ -15990,6 +16022,7 @@ type CategoryMetrics struct { Value float64 `protobuf:"fixed64,3,opt,name=value,proto3" json:"value,omitempty"` Timestamp string `protobuf:"bytes,4,opt,name=timestamp,proto3" json:"timestamp,omitempty"` CategoryId string `protobuf:"bytes,5,opt,name=category_id,json=categoryId,proto3" json:"category_id,omitempty"` + AverageScore float64 `protobuf:"fixed64,6,opt,name=average_score,json=averageScore,proto3" json:"average_score,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } @@ -16059,6 +16092,13 @@ func (x *CategoryMetrics) GetCategoryId() string { return "" } +func (x *CategoryMetrics) GetAverageScore() float64 { + if x != nil { + return x.AverageScore + } + return 0 +} + type Cat struct { state protoimpl.MessageState `protogen:"open.v1"` Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` @@ -17047,27 +17087,28 @@ func (x *ShippingEstimateInput) GetExpedited() *wrapperspb.BoolValue { return nil } -type ListOfAuthorFilter_List struct { +// Argument-less field resolver messages for Category.totalProducts +type ResolveCategoryTotalProductsContext struct { state protoimpl.MessageState `protogen:"open.v1"` - Items []*AuthorFilter `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ListOfAuthorFilter_List) Reset() { - *x = ListOfAuthorFilter_List{} +func (x *ResolveCategoryTotalProductsContext) Reset() { + *x = ResolveCategoryTotalProductsContext{} mi := &file_product_proto_msgTypes[337] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ListOfAuthorFilter_List) String() string { +func (x *ResolveCategoryTotalProductsContext) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListOfAuthorFilter_List) ProtoMessage() {} +func (*ResolveCategoryTotalProductsContext) ProtoMessage() {} -func (x *ListOfAuthorFilter_List) ProtoReflect() protoreflect.Message { +func (x *ResolveCategoryTotalProductsContext) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[337] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -17079,39 +17120,39 @@ func (x *ListOfAuthorFilter_List) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ListOfAuthorFilter_List.ProtoReflect.Descriptor instead. -func (*ListOfAuthorFilter_List) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{0, 0} +// Deprecated: Use ResolveCategoryTotalProductsContext.ProtoReflect.Descriptor instead. +func (*ResolveCategoryTotalProductsContext) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{337} } -func (x *ListOfAuthorFilter_List) GetItems() []*AuthorFilter { +func (x *ResolveCategoryTotalProductsContext) GetId() string { if x != nil { - return x.Items + return x.Id } - return nil + return "" } -type ListOfAuthorInput_List struct { - state protoimpl.MessageState `protogen:"open.v1"` - Items []*AuthorInput `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` +type ResolveCategoryTotalProductsRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Context []*ResolveCategoryTotalProductsContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ListOfAuthorInput_List) Reset() { - *x = ListOfAuthorInput_List{} +func (x *ResolveCategoryTotalProductsRequest) Reset() { + *x = ResolveCategoryTotalProductsRequest{} mi := &file_product_proto_msgTypes[338] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ListOfAuthorInput_List) String() string { +func (x *ResolveCategoryTotalProductsRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListOfAuthorInput_List) ProtoMessage() {} +func (*ResolveCategoryTotalProductsRequest) ProtoMessage() {} -func (x *ListOfAuthorInput_List) ProtoReflect() protoreflect.Message { +func (x *ResolveCategoryTotalProductsRequest) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[338] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -17123,39 +17164,39 @@ func (x *ListOfAuthorInput_List) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ListOfAuthorInput_List.ProtoReflect.Descriptor instead. -func (*ListOfAuthorInput_List) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{1, 0} +// Deprecated: Use ResolveCategoryTotalProductsRequest.ProtoReflect.Descriptor instead. +func (*ResolveCategoryTotalProductsRequest) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{338} } -func (x *ListOfAuthorInput_List) GetItems() []*AuthorInput { +func (x *ResolveCategoryTotalProductsRequest) GetContext() []*ResolveCategoryTotalProductsContext { if x != nil { - return x.Items + return x.Context } return nil } -type ListOfBlogPost_List struct { +type ResolveCategoryTotalProductsResult struct { state protoimpl.MessageState `protogen:"open.v1"` - Items []*BlogPost `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` + TotalProducts int32 `protobuf:"varint,1,opt,name=total_products,json=totalProducts,proto3" json:"total_products,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ListOfBlogPost_List) Reset() { - *x = ListOfBlogPost_List{} +func (x *ResolveCategoryTotalProductsResult) Reset() { + *x = ResolveCategoryTotalProductsResult{} mi := &file_product_proto_msgTypes[339] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ListOfBlogPost_List) String() string { +func (x *ResolveCategoryTotalProductsResult) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListOfBlogPost_List) ProtoMessage() {} +func (*ResolveCategoryTotalProductsResult) ProtoMessage() {} -func (x *ListOfBlogPost_List) ProtoReflect() protoreflect.Message { +func (x *ResolveCategoryTotalProductsResult) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[339] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -17167,39 +17208,39 @@ func (x *ListOfBlogPost_List) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ListOfBlogPost_List.ProtoReflect.Descriptor instead. -func (*ListOfBlogPost_List) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{2, 0} +// Deprecated: Use ResolveCategoryTotalProductsResult.ProtoReflect.Descriptor instead. +func (*ResolveCategoryTotalProductsResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{339} } -func (x *ListOfBlogPost_List) GetItems() []*BlogPost { +func (x *ResolveCategoryTotalProductsResult) GetTotalProducts() int32 { if x != nil { - return x.Items + return x.TotalProducts } - return nil + return 0 } -type ListOfBlogPostFilter_List struct { - state protoimpl.MessageState `protogen:"open.v1"` - Items []*BlogPostFilter `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` +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 *ListOfBlogPostFilter_List) Reset() { - *x = ListOfBlogPostFilter_List{} +func (x *ResolveCategoryTotalProductsResponse) Reset() { + *x = ResolveCategoryTotalProductsResponse{} mi := &file_product_proto_msgTypes[340] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ListOfBlogPostFilter_List) String() string { +func (x *ResolveCategoryTotalProductsResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListOfBlogPostFilter_List) ProtoMessage() {} +func (*ResolveCategoryTotalProductsResponse) ProtoMessage() {} -func (x *ListOfBlogPostFilter_List) ProtoReflect() protoreflect.Message { +func (x *ResolveCategoryTotalProductsResponse) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[340] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -17211,39 +17252,41 @@ func (x *ListOfBlogPostFilter_List) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ListOfBlogPostFilter_List.ProtoReflect.Descriptor instead. -func (*ListOfBlogPostFilter_List) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{3, 0} +// Deprecated: Use ResolveCategoryTotalProductsResponse.ProtoReflect.Descriptor instead. +func (*ResolveCategoryTotalProductsResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{340} } -func (x *ListOfBlogPostFilter_List) GetItems() []*BlogPostFilter { +func (x *ResolveCategoryTotalProductsResponse) GetResult() []*ResolveCategoryTotalProductsResult { if x != nil { - return x.Items + return x.Result } return nil } -type ListOfBlogPostInput_List struct { +// Argument-less field resolver messages for Category.topSubcategory +type ResolveCategoryTopSubcategoryContext struct { state protoimpl.MessageState `protogen:"open.v1"` - Items []*BlogPostInput `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` + 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 *ListOfBlogPostInput_List) Reset() { - *x = ListOfBlogPostInput_List{} +func (x *ResolveCategoryTopSubcategoryContext) Reset() { + *x = ResolveCategoryTopSubcategoryContext{} mi := &file_product_proto_msgTypes[341] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ListOfBlogPostInput_List) String() string { +func (x *ResolveCategoryTopSubcategoryContext) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListOfBlogPostInput_List) ProtoMessage() {} +func (*ResolveCategoryTopSubcategoryContext) ProtoMessage() {} -func (x *ListOfBlogPostInput_List) ProtoReflect() protoreflect.Message { +func (x *ResolveCategoryTopSubcategoryContext) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[341] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -17255,39 +17298,46 @@ func (x *ListOfBlogPostInput_List) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ListOfBlogPostInput_List.ProtoReflect.Descriptor instead. -func (*ListOfBlogPostInput_List) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{4, 0} +// Deprecated: Use ResolveCategoryTopSubcategoryContext.ProtoReflect.Descriptor instead. +func (*ResolveCategoryTopSubcategoryContext) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{341} } -func (x *ListOfBlogPostInput_List) GetItems() []*BlogPostInput { +func (x *ResolveCategoryTopSubcategoryContext) GetId() string { if x != nil { - return x.Items + return x.Id } - return nil + return "" } -type ListOfBoolean_List struct { - state protoimpl.MessageState `protogen:"open.v1"` - Items []bool `protobuf:"varint,1,rep,packed,name=items,proto3" json:"items,omitempty"` +func (x *ResolveCategoryTopSubcategoryContext) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +type ResolveCategoryTopSubcategoryRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Context []*ResolveCategoryTopSubcategoryContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ListOfBoolean_List) Reset() { - *x = ListOfBoolean_List{} +func (x *ResolveCategoryTopSubcategoryRequest) Reset() { + *x = ResolveCategoryTopSubcategoryRequest{} mi := &file_product_proto_msgTypes[342] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ListOfBoolean_List) String() string { +func (x *ResolveCategoryTopSubcategoryRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListOfBoolean_List) ProtoMessage() {} +func (*ResolveCategoryTopSubcategoryRequest) ProtoMessage() {} -func (x *ListOfBoolean_List) ProtoReflect() protoreflect.Message { +func (x *ResolveCategoryTopSubcategoryRequest) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[342] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -17299,39 +17349,39 @@ func (x *ListOfBoolean_List) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ListOfBoolean_List.ProtoReflect.Descriptor instead. -func (*ListOfBoolean_List) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{5, 0} +// Deprecated: Use ResolveCategoryTopSubcategoryRequest.ProtoReflect.Descriptor instead. +func (*ResolveCategoryTopSubcategoryRequest) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{342} } -func (x *ListOfBoolean_List) GetItems() []bool { +func (x *ResolveCategoryTopSubcategoryRequest) GetContext() []*ResolveCategoryTopSubcategoryContext { if x != nil { - return x.Items + return x.Context } return nil } -type ListOfCategory_List struct { - state protoimpl.MessageState `protogen:"open.v1"` - Items []*Category `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +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 *ListOfCategory_List) Reset() { - *x = ListOfCategory_List{} +func (x *ResolveCategoryTopSubcategoryResult) Reset() { + *x = ResolveCategoryTopSubcategoryResult{} mi := &file_product_proto_msgTypes[343] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ListOfCategory_List) String() string { +func (x *ResolveCategoryTopSubcategoryResult) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListOfCategory_List) ProtoMessage() {} +func (*ResolveCategoryTopSubcategoryResult) ProtoMessage() {} -func (x *ListOfCategory_List) ProtoReflect() protoreflect.Message { +func (x *ResolveCategoryTopSubcategoryResult) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[343] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -17343,39 +17393,39 @@ func (x *ListOfCategory_List) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ListOfCategory_List.ProtoReflect.Descriptor instead. -func (*ListOfCategory_List) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{6, 0} +// Deprecated: Use ResolveCategoryTopSubcategoryResult.ProtoReflect.Descriptor instead. +func (*ResolveCategoryTopSubcategoryResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{343} } -func (x *ListOfCategory_List) GetItems() []*Category { +func (x *ResolveCategoryTopSubcategoryResult) GetTopSubcategory() *Subcategory { if x != nil { - return x.Items + return x.TopSubcategory } return nil } -type ListOfCategoryInput_List struct { - state protoimpl.MessageState `protogen:"open.v1"` - Items []*CategoryInput `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` +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 *ListOfCategoryInput_List) Reset() { - *x = ListOfCategoryInput_List{} +func (x *ResolveCategoryTopSubcategoryResponse) Reset() { + *x = ResolveCategoryTopSubcategoryResponse{} mi := &file_product_proto_msgTypes[344] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ListOfCategoryInput_List) String() string { +func (x *ResolveCategoryTopSubcategoryResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListOfCategoryInput_List) ProtoMessage() {} +func (*ResolveCategoryTopSubcategoryResponse) ProtoMessage() {} -func (x *ListOfCategoryInput_List) ProtoReflect() protoreflect.Message { +func (x *ResolveCategoryTopSubcategoryResponse) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[344] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -17387,39 +17437,40 @@ func (x *ListOfCategoryInput_List) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ListOfCategoryInput_List.ProtoReflect.Descriptor instead. -func (*ListOfCategoryInput_List) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{7, 0} +// Deprecated: Use ResolveCategoryTopSubcategoryResponse.ProtoReflect.Descriptor instead. +func (*ResolveCategoryTopSubcategoryResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{344} } -func (x *ListOfCategoryInput_List) GetItems() []*CategoryInput { +func (x *ResolveCategoryTopSubcategoryResponse) GetResult() []*ResolveCategoryTopSubcategoryResult { if x != nil { - return x.Items + return x.Result } return nil } -type ListOfFloat_List struct { +// Argument-less field resolver messages for Category.activeSubcategories +type ResolveCategoryActiveSubcategoriesContext struct { state protoimpl.MessageState `protogen:"open.v1"` - Items []float64 `protobuf:"fixed64,1,rep,packed,name=items,proto3" json:"items,omitempty"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ListOfFloat_List) Reset() { - *x = ListOfFloat_List{} +func (x *ResolveCategoryActiveSubcategoriesContext) Reset() { + *x = ResolveCategoryActiveSubcategoriesContext{} mi := &file_product_proto_msgTypes[345] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ListOfFloat_List) String() string { +func (x *ResolveCategoryActiveSubcategoriesContext) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListOfFloat_List) ProtoMessage() {} +func (*ResolveCategoryActiveSubcategoriesContext) ProtoMessage() {} -func (x *ListOfFloat_List) ProtoReflect() protoreflect.Message { +func (x *ResolveCategoryActiveSubcategoriesContext) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[345] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -17431,39 +17482,39 @@ func (x *ListOfFloat_List) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ListOfFloat_List.ProtoReflect.Descriptor instead. -func (*ListOfFloat_List) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{8, 0} +// Deprecated: Use ResolveCategoryActiveSubcategoriesContext.ProtoReflect.Descriptor instead. +func (*ResolveCategoryActiveSubcategoriesContext) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{345} } -func (x *ListOfFloat_List) GetItems() []float64 { +func (x *ResolveCategoryActiveSubcategoriesContext) GetId() string { if x != nil { - return x.Items + return x.Id } - return nil + return "" } -type ListOfListOfCategory_List struct { - state protoimpl.MessageState `protogen:"open.v1"` - Items []*ListOfCategory `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` +type ResolveCategoryActiveSubcategoriesRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Context []*ResolveCategoryActiveSubcategoriesContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ListOfListOfCategory_List) Reset() { - *x = ListOfListOfCategory_List{} +func (x *ResolveCategoryActiveSubcategoriesRequest) Reset() { + *x = ResolveCategoryActiveSubcategoriesRequest{} mi := &file_product_proto_msgTypes[346] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ListOfListOfCategory_List) String() string { +func (x *ResolveCategoryActiveSubcategoriesRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListOfListOfCategory_List) ProtoMessage() {} +func (*ResolveCategoryActiveSubcategoriesRequest) ProtoMessage() {} -func (x *ListOfListOfCategory_List) ProtoReflect() protoreflect.Message { +func (x *ResolveCategoryActiveSubcategoriesRequest) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[346] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -17475,39 +17526,39 @@ func (x *ListOfListOfCategory_List) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ListOfListOfCategory_List.ProtoReflect.Descriptor instead. -func (*ListOfListOfCategory_List) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{9, 0} +// Deprecated: Use ResolveCategoryActiveSubcategoriesRequest.ProtoReflect.Descriptor instead. +func (*ResolveCategoryActiveSubcategoriesRequest) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{346} } -func (x *ListOfListOfCategory_List) GetItems() []*ListOfCategory { +func (x *ResolveCategoryActiveSubcategoriesRequest) GetContext() []*ResolveCategoryActiveSubcategoriesContext { if x != nil { - return x.Items + return x.Context } return nil } -type ListOfListOfCategoryInput_List struct { - state protoimpl.MessageState `protogen:"open.v1"` - Items []*ListOfCategoryInput `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +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 *ListOfListOfCategoryInput_List) Reset() { - *x = ListOfListOfCategoryInput_List{} +func (x *ResolveCategoryActiveSubcategoriesResult) Reset() { + *x = ResolveCategoryActiveSubcategoriesResult{} mi := &file_product_proto_msgTypes[347] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ListOfListOfCategoryInput_List) String() string { +func (x *ResolveCategoryActiveSubcategoriesResult) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListOfListOfCategoryInput_List) ProtoMessage() {} +func (*ResolveCategoryActiveSubcategoriesResult) ProtoMessage() {} -func (x *ListOfListOfCategoryInput_List) ProtoReflect() protoreflect.Message { +func (x *ResolveCategoryActiveSubcategoriesResult) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[347] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -17519,39 +17570,39 @@ func (x *ListOfListOfCategoryInput_List) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ListOfListOfCategoryInput_List.ProtoReflect.Descriptor instead. -func (*ListOfListOfCategoryInput_List) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{10, 0} +// Deprecated: Use ResolveCategoryActiveSubcategoriesResult.ProtoReflect.Descriptor instead. +func (*ResolveCategoryActiveSubcategoriesResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{347} } -func (x *ListOfListOfCategoryInput_List) GetItems() []*ListOfCategoryInput { +func (x *ResolveCategoryActiveSubcategoriesResult) GetActiveSubcategories() []*Subcategory { if x != nil { - return x.Items + return x.ActiveSubcategories } return nil } -type ListOfListOfString_List struct { - state protoimpl.MessageState `protogen:"open.v1"` - Items []*ListOfString `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` +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 *ListOfListOfString_List) Reset() { - *x = ListOfListOfString_List{} +func (x *ResolveCategoryActiveSubcategoriesResponse) Reset() { + *x = ResolveCategoryActiveSubcategoriesResponse{} mi := &file_product_proto_msgTypes[348] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ListOfListOfString_List) String() string { +func (x *ResolveCategoryActiveSubcategoriesResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListOfListOfString_List) ProtoMessage() {} +func (*ResolveCategoryActiveSubcategoriesResponse) ProtoMessage() {} -func (x *ListOfListOfString_List) ProtoReflect() protoreflect.Message { +func (x *ResolveCategoryActiveSubcategoriesResponse) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[348] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -17563,39 +17614,40 @@ func (x *ListOfListOfString_List) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ListOfListOfString_List.ProtoReflect.Descriptor instead. -func (*ListOfListOfString_List) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{11, 0} +// Deprecated: Use ResolveCategoryActiveSubcategoriesResponse.ProtoReflect.Descriptor instead. +func (*ResolveCategoryActiveSubcategoriesResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{348} } -func (x *ListOfListOfString_List) GetItems() []*ListOfString { +func (x *ResolveCategoryActiveSubcategoriesResponse) GetResult() []*ResolveCategoryActiveSubcategoriesResult { if x != nil { - return x.Items + return x.Result } return nil } -type ListOfListOfUser_List struct { +// Argument-less field resolver messages for Subcategory.parentCategory +type ResolveSubcategoryParentCategoryContext struct { state protoimpl.MessageState `protogen:"open.v1"` - Items []*ListOfUser `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ListOfListOfUser_List) Reset() { - *x = ListOfListOfUser_List{} +func (x *ResolveSubcategoryParentCategoryContext) Reset() { + *x = ResolveSubcategoryParentCategoryContext{} mi := &file_product_proto_msgTypes[349] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ListOfListOfUser_List) String() string { +func (x *ResolveSubcategoryParentCategoryContext) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListOfListOfUser_List) ProtoMessage() {} +func (*ResolveSubcategoryParentCategoryContext) ProtoMessage() {} -func (x *ListOfListOfUser_List) ProtoReflect() protoreflect.Message { +func (x *ResolveSubcategoryParentCategoryContext) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[349] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -17607,28 +17659,917 @@ func (x *ListOfListOfUser_List) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ListOfListOfUser_List.ProtoReflect.Descriptor instead. -func (*ListOfListOfUser_List) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{12, 0} +// Deprecated: Use ResolveSubcategoryParentCategoryContext.ProtoReflect.Descriptor instead. +func (*ResolveSubcategoryParentCategoryContext) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{349} } -func (x *ListOfListOfUser_List) GetItems() []*ListOfUser { +func (x *ResolveSubcategoryParentCategoryContext) GetId() string { if x != nil { - return x.Items + return x.Id } - return nil + return "" } -type ListOfListOfUserInput_List struct { - state protoimpl.MessageState `protogen:"open.v1"` - Items []*ListOfUserInput `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` +type ResolveSubcategoryParentCategoryRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + 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[350] + 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[350] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ResolveSubcategoryParentCategoryRequest.ProtoReflect.Descriptor instead. +func (*ResolveSubcategoryParentCategoryRequest) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{350} +} + +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[351] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveSubcategoryParentCategoryResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveSubcategoryParentCategoryResult) ProtoMessage() {} + +func (x *ResolveSubcategoryParentCategoryResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[351] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ResolveSubcategoryParentCategoryResult.ProtoReflect.Descriptor instead. +func (*ResolveSubcategoryParentCategoryResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{351} +} + +func (x *ResolveSubcategoryParentCategoryResult) GetParentCategory() *Category { + if x != nil { + return x.ParentCategory + } + return nil +} + +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 *ResolveSubcategoryParentCategoryResponse) Reset() { + *x = ResolveSubcategoryParentCategoryResponse{} + mi := &file_product_proto_msgTypes[352] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveSubcategoryParentCategoryResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveSubcategoryParentCategoryResponse) ProtoMessage() {} + +func (x *ResolveSubcategoryParentCategoryResponse) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[352] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ResolveSubcategoryParentCategoryResponse.ProtoReflect.Descriptor instead. +func (*ResolveSubcategoryParentCategoryResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{352} +} + +func (x *ResolveSubcategoryParentCategoryResponse) GetResult() []*ResolveSubcategoryParentCategoryResult { + if x != nil { + return x.Result + } + return nil +} + +// Argument-less field resolver messages for CategoryMetrics.averageScore +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[353] + 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[353] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ResolveCategoryMetricsAverageScoreContext.ProtoReflect.Descriptor instead. +func (*ResolveCategoryMetricsAverageScoreContext) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{353} +} + +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 []*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[354] + 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[354] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ResolveCategoryMetricsAverageScoreRequest.ProtoReflect.Descriptor instead. +func (*ResolveCategoryMetricsAverageScoreRequest) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{354} +} + +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[355] + 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[355] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ResolveCategoryMetricsAverageScoreResult.ProtoReflect.Descriptor instead. +func (*ResolveCategoryMetricsAverageScoreResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{355} +} + +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[356] + 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[356] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ResolveCategoryMetricsAverageScoreResponse.ProtoReflect.Descriptor instead. +func (*ResolveCategoryMetricsAverageScoreResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{356} +} + +func (x *ResolveCategoryMetricsAverageScoreResponse) GetResult() []*ResolveCategoryMetricsAverageScoreResult { + if x != nil { + return x.Result + } + return nil +} + +type ListOfAuthorFilter_List struct { + state protoimpl.MessageState `protogen:"open.v1"` + Items []*AuthorFilter `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListOfAuthorFilter_List) Reset() { + *x = ListOfAuthorFilter_List{} + mi := &file_product_proto_msgTypes[357] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListOfAuthorFilter_List) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListOfAuthorFilter_List) ProtoMessage() {} + +func (x *ListOfAuthorFilter_List) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[357] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListOfAuthorFilter_List.ProtoReflect.Descriptor instead. +func (*ListOfAuthorFilter_List) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{0, 0} +} + +func (x *ListOfAuthorFilter_List) GetItems() []*AuthorFilter { + if x != nil { + return x.Items + } + return nil +} + +type ListOfAuthorInput_List struct { + state protoimpl.MessageState `protogen:"open.v1"` + Items []*AuthorInput `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListOfAuthorInput_List) Reset() { + *x = ListOfAuthorInput_List{} + mi := &file_product_proto_msgTypes[358] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListOfAuthorInput_List) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListOfAuthorInput_List) ProtoMessage() {} + +func (x *ListOfAuthorInput_List) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[358] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListOfAuthorInput_List.ProtoReflect.Descriptor instead. +func (*ListOfAuthorInput_List) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{1, 0} +} + +func (x *ListOfAuthorInput_List) GetItems() []*AuthorInput { + if x != nil { + return x.Items + } + return nil +} + +type ListOfBlogPost_List struct { + state protoimpl.MessageState `protogen:"open.v1"` + Items []*BlogPost `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListOfBlogPost_List) Reset() { + *x = ListOfBlogPost_List{} + mi := &file_product_proto_msgTypes[359] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListOfBlogPost_List) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListOfBlogPost_List) ProtoMessage() {} + +func (x *ListOfBlogPost_List) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[359] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListOfBlogPost_List.ProtoReflect.Descriptor instead. +func (*ListOfBlogPost_List) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{2, 0} +} + +func (x *ListOfBlogPost_List) GetItems() []*BlogPost { + if x != nil { + return x.Items + } + return nil +} + +type ListOfBlogPostFilter_List struct { + state protoimpl.MessageState `protogen:"open.v1"` + Items []*BlogPostFilter `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListOfBlogPostFilter_List) Reset() { + *x = ListOfBlogPostFilter_List{} + mi := &file_product_proto_msgTypes[360] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListOfBlogPostFilter_List) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListOfBlogPostFilter_List) ProtoMessage() {} + +func (x *ListOfBlogPostFilter_List) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[360] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListOfBlogPostFilter_List.ProtoReflect.Descriptor instead. +func (*ListOfBlogPostFilter_List) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{3, 0} +} + +func (x *ListOfBlogPostFilter_List) GetItems() []*BlogPostFilter { + if x != nil { + return x.Items + } + return nil +} + +type ListOfBlogPostInput_List struct { + state protoimpl.MessageState `protogen:"open.v1"` + Items []*BlogPostInput `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListOfBlogPostInput_List) Reset() { + *x = ListOfBlogPostInput_List{} + mi := &file_product_proto_msgTypes[361] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListOfBlogPostInput_List) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListOfBlogPostInput_List) ProtoMessage() {} + +func (x *ListOfBlogPostInput_List) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[361] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListOfBlogPostInput_List.ProtoReflect.Descriptor instead. +func (*ListOfBlogPostInput_List) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{4, 0} +} + +func (x *ListOfBlogPostInput_List) GetItems() []*BlogPostInput { + if x != nil { + return x.Items + } + return nil +} + +type ListOfBoolean_List struct { + state protoimpl.MessageState `protogen:"open.v1"` + Items []bool `protobuf:"varint,1,rep,packed,name=items,proto3" json:"items,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListOfBoolean_List) Reset() { + *x = ListOfBoolean_List{} + mi := &file_product_proto_msgTypes[362] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListOfBoolean_List) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListOfBoolean_List) ProtoMessage() {} + +func (x *ListOfBoolean_List) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[362] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListOfBoolean_List.ProtoReflect.Descriptor instead. +func (*ListOfBoolean_List) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{5, 0} +} + +func (x *ListOfBoolean_List) GetItems() []bool { + if x != nil { + return x.Items + } + return nil +} + +type ListOfCategory_List struct { + state protoimpl.MessageState `protogen:"open.v1"` + Items []*Category `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListOfCategory_List) Reset() { + *x = ListOfCategory_List{} + mi := &file_product_proto_msgTypes[363] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListOfCategory_List) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListOfCategory_List) ProtoMessage() {} + +func (x *ListOfCategory_List) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[363] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListOfCategory_List.ProtoReflect.Descriptor instead. +func (*ListOfCategory_List) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{6, 0} +} + +func (x *ListOfCategory_List) GetItems() []*Category { + if x != nil { + return x.Items + } + return nil +} + +type ListOfCategoryInput_List struct { + state protoimpl.MessageState `protogen:"open.v1"` + Items []*CategoryInput `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListOfCategoryInput_List) Reset() { + *x = ListOfCategoryInput_List{} + mi := &file_product_proto_msgTypes[364] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListOfCategoryInput_List) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListOfCategoryInput_List) ProtoMessage() {} + +func (x *ListOfCategoryInput_List) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[364] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListOfCategoryInput_List.ProtoReflect.Descriptor instead. +func (*ListOfCategoryInput_List) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{7, 0} +} + +func (x *ListOfCategoryInput_List) GetItems() []*CategoryInput { + if x != nil { + return x.Items + } + return nil +} + +type ListOfFloat_List struct { + state protoimpl.MessageState `protogen:"open.v1"` + Items []float64 `protobuf:"fixed64,1,rep,packed,name=items,proto3" json:"items,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListOfFloat_List) Reset() { + *x = ListOfFloat_List{} + mi := &file_product_proto_msgTypes[365] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListOfFloat_List) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListOfFloat_List) ProtoMessage() {} + +func (x *ListOfFloat_List) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[365] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListOfFloat_List.ProtoReflect.Descriptor instead. +func (*ListOfFloat_List) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{8, 0} +} + +func (x *ListOfFloat_List) GetItems() []float64 { + if x != nil { + return x.Items + } + return nil +} + +type ListOfListOfCategory_List struct { + state protoimpl.MessageState `protogen:"open.v1"` + Items []*ListOfCategory `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListOfListOfCategory_List) Reset() { + *x = ListOfListOfCategory_List{} + mi := &file_product_proto_msgTypes[366] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListOfListOfCategory_List) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListOfListOfCategory_List) ProtoMessage() {} + +func (x *ListOfListOfCategory_List) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[366] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListOfListOfCategory_List.ProtoReflect.Descriptor instead. +func (*ListOfListOfCategory_List) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{9, 0} +} + +func (x *ListOfListOfCategory_List) GetItems() []*ListOfCategory { + if x != nil { + return x.Items + } + return nil +} + +type ListOfListOfCategoryInput_List struct { + state protoimpl.MessageState `protogen:"open.v1"` + Items []*ListOfCategoryInput `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListOfListOfCategoryInput_List) Reset() { + *x = ListOfListOfCategoryInput_List{} + mi := &file_product_proto_msgTypes[367] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListOfListOfCategoryInput_List) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListOfListOfCategoryInput_List) ProtoMessage() {} + +func (x *ListOfListOfCategoryInput_List) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[367] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListOfListOfCategoryInput_List.ProtoReflect.Descriptor instead. +func (*ListOfListOfCategoryInput_List) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{10, 0} +} + +func (x *ListOfListOfCategoryInput_List) GetItems() []*ListOfCategoryInput { + if x != nil { + return x.Items + } + return nil +} + +type ListOfListOfString_List struct { + state protoimpl.MessageState `protogen:"open.v1"` + Items []*ListOfString `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListOfListOfString_List) Reset() { + *x = ListOfListOfString_List{} + mi := &file_product_proto_msgTypes[368] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListOfListOfString_List) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListOfListOfString_List) ProtoMessage() {} + +func (x *ListOfListOfString_List) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[368] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListOfListOfString_List.ProtoReflect.Descriptor instead. +func (*ListOfListOfString_List) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{11, 0} +} + +func (x *ListOfListOfString_List) GetItems() []*ListOfString { + if x != nil { + return x.Items + } + return nil +} + +type ListOfListOfUser_List struct { + state protoimpl.MessageState `protogen:"open.v1"` + Items []*ListOfUser `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListOfListOfUser_List) Reset() { + *x = ListOfListOfUser_List{} + mi := &file_product_proto_msgTypes[369] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListOfListOfUser_List) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListOfListOfUser_List) ProtoMessage() {} + +func (x *ListOfListOfUser_List) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[369] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListOfListOfUser_List.ProtoReflect.Descriptor instead. +func (*ListOfListOfUser_List) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{12, 0} +} + +func (x *ListOfListOfUser_List) GetItems() []*ListOfUser { + if x != nil { + return x.Items + } + return nil +} + +type ListOfListOfUserInput_List struct { + state protoimpl.MessageState `protogen:"open.v1"` + Items []*ListOfUserInput `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } 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 +18581,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 +18613,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 +18625,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 +18657,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 +18669,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 +18701,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 +18713,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 +18745,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 +18757,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 +18789,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 +18801,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 +18833,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 +18845,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 +18877,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 +18889,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 +18921,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 +18933,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 { @@ -18025,7 +18966,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 +18978,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 { @@ -18078,7 +19019,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 +19031,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 { @@ -18137,7 +19078,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 +19090,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 { @@ -18189,7 +19130,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 +19142,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 { @@ -18241,7 +19182,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 +19194,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 { @@ -18292,7 +19233,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 +19245,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 { @@ -19082,13 +20023,16 @@ const file_product_proto_rawDesc = "" + "\vtotal_items\x18\x03 \x01(\x05R\n" + "totalItems\x12;\n" + "\vorder_lines\x18\x04 \x01(\v2\x1a.productv1.ListOfOrderLineR\n" + - "orderLines\"\xde\x01\n" + + "orderLines\"\x91\x03\n" + "\bCategory\x12\x0e\n" + "\x02id\x18\x01 \x01(\tR\x02id\x12\x12\n" + "\x04name\x18\x02 \x01(\tR\x04name\x12+\n" + "\x04kind\x18\x03 \x01(\x0e2\x17.productv1.CategoryKindR\x04kind\x12B\n" + "\rsubcategories\x18\x04 \x01(\v2\x1c.productv1.ListOfSubcategoryR\rsubcategories\x12=\n" + - "\fnull_metrics\x18\x05 \x01(\v2\x1a.productv1.CategoryMetricsR\vnullMetrics\"|\n" + + "\fnull_metrics\x18\x05 \x01(\v2\x1a.productv1.CategoryMetricsR\vnullMetrics\x12%\n" + + "\x0etotal_products\x18\x06 \x01(\x05R\rtotalProducts\x12?\n" + + "\x0ftop_subcategory\x18\a \x01(\v2\x16.productv1.SubcategoryR\x0etopSubcategory\x12I\n" + + "\x14active_subcategories\x18\b \x03(\v2\x16.productv1.SubcategoryR\x13activeSubcategories\"|\n" + "\x0eCategoryFilter\x123\n" + "\bcategory\x18\x01 \x01(\x0e2\x17.productv1.CategoryKindR\bcategory\x125\n" + "\n" + @@ -19269,12 +20213,13 @@ const file_product_proto_rawDesc = "" + "\n" + "product_id\x18\x01 \x01(\tR\tproductId\x12\x1a\n" + "\bquantity\x18\x02 \x01(\x05R\bquantity\x125\n" + - "\tmodifiers\x18\x03 \x01(\v2\x17.productv1.ListOfStringR\tmodifiers\"\x8e\x01\n" + + "\tmodifiers\x18\x03 \x01(\v2\x17.productv1.ListOfStringR\tmodifiers\"\xcc\x01\n" + "\vSubcategory\x12\x0e\n" + "\x02id\x18\x01 \x01(\tR\x02id\x12\x12\n" + "\x04name\x18\x02 \x01(\tR\x04name\x12>\n" + "\vdescription\x18\x03 \x01(\v2\x1c.google.protobuf.StringValueR\vdescription\x12\x1b\n" + - "\tis_active\x18\x04 \x01(\bR\bisActive\"\x97\x01\n" + + "\tis_active\x18\x04 \x01(\bR\bisActive\x12<\n" + + "\x0fparent_category\x18\x05 \x01(\v2\x13.productv1.CategoryR\x0eparentCategory\"\xbc\x01\n" + "\x0fCategoryMetrics\x12\x0e\n" + "\x02id\x18\x01 \x01(\tR\x02id\x12\x1f\n" + "\vmetric_type\x18\x02 \x01(\tR\n" + @@ -19282,7 +20227,8 @@ const file_product_proto_rawDesc = "" + "\x05value\x18\x03 \x01(\x01R\x05value\x12\x1c\n" + "\ttimestamp\x18\x04 \x01(\tR\ttimestamp\x12\x1f\n" + "\vcategory_id\x18\x05 \x01(\tR\n" + - "categoryId\"\xb1\x01\n" + + "categoryId\x12#\n" + + "\raverage_score\x18\x06 \x01(\x01R\faverageScore\"\xb1\x01\n" + "\x03Cat\x12\x0e\n" + "\x02id\x18\x01 \x01(\tR\x02id\x12\x12\n" + "\x04name\x18\x02 \x01(\tR\x04name\x12\x12\n" + @@ -19357,7 +20303,50 @@ const file_product_proto_rawDesc = "" + "\x15ShippingEstimateInput\x12@\n" + "\vdestination\x18\x01 \x01(\x0e2\x1e.productv1.ShippingDestinationR\vdestination\x12\x16\n" + "\x06weight\x18\x02 \x01(\x01R\x06weight\x128\n" + - "\texpedited\x18\x03 \x01(\v2\x1a.google.protobuf.BoolValueR\texpedited*\x9a\x01\n" + + "\texpedited\x18\x03 \x01(\v2\x1a.google.protobuf.BoolValueR\texpedited\"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\"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\"\\\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*\x9a\x01\n" + "\fCategoryKind\x12\x1d\n" + "\x19CATEGORY_KIND_UNSPECIFIED\x10\x00\x12\x16\n" + "\x12CATEGORY_KIND_BOOK\x10\x01\x12\x1d\n" + @@ -19368,7 +20357,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" + @@ -19450,7 +20439,12 @@ const file_product_proto_rawDesc = "" + "\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" + - "\x1bResolveTestContainerDetails\x12-.productv1.ResolveTestContainerDetailsRequest\x1a..productv1.ResolveTestContainerDetailsResponse\"\x00B%Z#cosmo/pkg/proto/productv1;productv1b\x06proto3" + "\x1bResolveTestContainerDetails\x12-.productv1.ResolveTestContainerDetailsRequest\x1a..productv1.ResolveTestContainerDetailsResponse\"\x00\x12\x81\x01\n" + + "\x1cResolveCategoryTotalProducts\x12..productv1.ResolveCategoryTotalProductsRequest\x1a/.productv1.ResolveCategoryTotalProductsResponse\"\x00\x12\x84\x01\n" + + "\x1dResolveCategoryTopSubcategory\x12/.productv1.ResolveCategoryTopSubcategoryRequest\x1a0.productv1.ResolveCategoryTopSubcategoryResponse\"\x00\x12\x93\x01\n" + + "\"ResolveCategoryActiveSubcategories\x124.productv1.ResolveCategoryActiveSubcategoriesRequest\x1a5.productv1.ResolveCategoryActiveSubcategoriesResponse\"\x00\x12\x8d\x01\n" + + " ResolveSubcategoryParentCategory\x122.productv1.ResolveSubcategoryParentCategoryRequest\x1a3.productv1.ResolveSubcategoryParentCategoryResponse\"\x00\x12\x93\x01\n" + + "\"ResolveCategoryMetricsAverageScore\x124.productv1.ResolveCategoryMetricsAverageScoreRequest\x1a5.productv1.ResolveCategoryMetricsAverageScoreResponse\"\x00B%Z#cosmo/pkg/proto/productv1;productv1b\x06proto3" var ( file_product_proto_rawDescOnce sync.Once @@ -19465,7 +20459,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 @@ -19749,118 +20743,138 @@ var file_product_proto_goTypes = []any{ (*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 + (*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 + (*ResolveCategoryTotalProductsContext)(nil), // 339: productv1.ResolveCategoryTotalProductsContext + (*ResolveCategoryTotalProductsRequest)(nil), // 340: productv1.ResolveCategoryTotalProductsRequest + (*ResolveCategoryTotalProductsResult)(nil), // 341: productv1.ResolveCategoryTotalProductsResult + (*ResolveCategoryTotalProductsResponse)(nil), // 342: productv1.ResolveCategoryTotalProductsResponse + (*ResolveCategoryTopSubcategoryContext)(nil), // 343: productv1.ResolveCategoryTopSubcategoryContext + (*ResolveCategoryTopSubcategoryRequest)(nil), // 344: productv1.ResolveCategoryTopSubcategoryRequest + (*ResolveCategoryTopSubcategoryResult)(nil), // 345: productv1.ResolveCategoryTopSubcategoryResult + (*ResolveCategoryTopSubcategoryResponse)(nil), // 346: productv1.ResolveCategoryTopSubcategoryResponse + (*ResolveCategoryActiveSubcategoriesContext)(nil), // 347: productv1.ResolveCategoryActiveSubcategoriesContext + (*ResolveCategoryActiveSubcategoriesRequest)(nil), // 348: productv1.ResolveCategoryActiveSubcategoriesRequest + (*ResolveCategoryActiveSubcategoriesResult)(nil), // 349: productv1.ResolveCategoryActiveSubcategoriesResult + (*ResolveCategoryActiveSubcategoriesResponse)(nil), // 350: productv1.ResolveCategoryActiveSubcategoriesResponse + (*ResolveSubcategoryParentCategoryContext)(nil), // 351: productv1.ResolveSubcategoryParentCategoryContext + (*ResolveSubcategoryParentCategoryRequest)(nil), // 352: productv1.ResolveSubcategoryParentCategoryRequest + (*ResolveSubcategoryParentCategoryResult)(nil), // 353: productv1.ResolveSubcategoryParentCategoryResult + (*ResolveSubcategoryParentCategoryResponse)(nil), // 354: productv1.ResolveSubcategoryParentCategoryResponse + (*ResolveCategoryMetricsAverageScoreContext)(nil), // 355: productv1.ResolveCategoryMetricsAverageScoreContext + (*ResolveCategoryMetricsAverageScoreRequest)(nil), // 356: productv1.ResolveCategoryMetricsAverageScoreRequest + (*ResolveCategoryMetricsAverageScoreResult)(nil), // 357: productv1.ResolveCategoryMetricsAverageScoreResult + (*ResolveCategoryMetricsAverageScoreResponse)(nil), // 358: productv1.ResolveCategoryMetricsAverageScoreResponse + (*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 26, // 23: productv1.LookupStorageByIdRequest.keys:type_name -> productv1.LookupStorageByIdRequestKey @@ -19964,7 +20978,7 @@ var file_product_proto_depIdxs = []int32{ 152, // 121: productv1.ResolveStorageLinkedStoragesRequest.field_args:type_name -> productv1.ResolveStorageLinkedStoragesArgs 283, // 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 @@ -19973,10 +20987,10 @@ var file_product_proto_depIdxs = []int32{ 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 @@ -19991,12 +21005,12 @@ var file_product_proto_depIdxs = []int32{ 182, // 148: productv1.ResolveCategoryCategoryStatusRequest.field_args:type_name -> productv1.ResolveCategoryCategoryStatusArgs 308, // 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 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 @@ -20012,7 +21026,7 @@ var file_product_proto_depIdxs = []int32{ 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 + 388, // 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 @@ -20025,7 +21039,7 @@ var file_product_proto_depIdxs = []int32{ 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 + 380, // 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 @@ -20034,25 +21048,25 @@ var file_product_proto_depIdxs = []int32{ 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 + 389, // 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 + 381, // 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 + 382, // 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 + 383, // 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 @@ -20068,7 +21082,7 @@ var file_product_proto_depIdxs = []int32{ 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 + 384, // 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 @@ -20078,12 +21092,12 @@ var file_product_proto_depIdxs = []int32{ 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 + 385, // 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 + 386, // 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 @@ -20092,292 +21106,318 @@ var file_product_proto_depIdxs = []int32{ 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 + 322, // 252: productv1.Category.top_subcategory:type_name -> productv1.Subcategory + 322, // 253: productv1.Category.active_subcategories:type_name -> productv1.Subcategory + 0, // 254: productv1.CategoryFilter.category:type_name -> productv1.CategoryKind + 319, // 255: productv1.CategoryFilter.pagination:type_name -> productv1.Pagination + 324, // 256: productv1.Animal.cat:type_name -> productv1.Cat + 325, // 257: productv1.Animal.dog:type_name -> productv1.Dog + 387, // 258: productv1.SearchInput.limit:type_name -> google.protobuf.Int32Value + 282, // 259: productv1.SearchResult.product:type_name -> productv1.Product + 285, // 260: productv1.SearchResult.user:type_name -> productv1.User + 294, // 261: productv1.SearchResult.category:type_name -> productv1.Category + 389, // 262: productv1.NullableFieldsType.optional_string:type_name -> google.protobuf.StringValue + 387, // 263: productv1.NullableFieldsType.optional_int:type_name -> google.protobuf.Int32Value + 390, // 264: productv1.NullableFieldsType.optional_float:type_name -> google.protobuf.DoubleValue + 388, // 265: productv1.NullableFieldsType.optional_boolean:type_name -> google.protobuf.BoolValue + 389, // 266: productv1.NullableFieldsFilter.name:type_name -> google.protobuf.StringValue + 389, // 267: productv1.NullableFieldsFilter.optional_string:type_name -> google.protobuf.StringValue + 388, // 268: productv1.NullableFieldsFilter.include_nulls:type_name -> google.protobuf.BoolValue + 19, // 269: productv1.BlogPost.optional_tags:type_name -> productv1.ListOfString + 19, // 270: productv1.BlogPost.keywords:type_name -> productv1.ListOfString + 10, // 271: productv1.BlogPost.ratings:type_name -> productv1.ListOfFloat + 7, // 272: productv1.BlogPost.is_published:type_name -> productv1.ListOfBoolean + 13, // 273: productv1.BlogPost.tag_groups:type_name -> productv1.ListOfListOfString + 13, // 274: productv1.BlogPost.related_topics:type_name -> productv1.ListOfListOfString + 13, // 275: productv1.BlogPost.comment_threads:type_name -> productv1.ListOfListOfString + 13, // 276: productv1.BlogPost.suggestions:type_name -> productv1.ListOfListOfString + 294, // 277: productv1.BlogPost.related_categories:type_name -> productv1.Category + 285, // 278: productv1.BlogPost.contributors:type_name -> productv1.User + 17, // 279: productv1.BlogPost.mentioned_products:type_name -> productv1.ListOfProduct + 21, // 280: productv1.BlogPost.mentioned_users:type_name -> productv1.ListOfUser + 11, // 281: productv1.BlogPost.category_groups:type_name -> productv1.ListOfListOfCategory + 14, // 282: productv1.BlogPost.contributor_teams:type_name -> productv1.ListOfListOfUser + 389, // 283: productv1.BlogPostFilter.title:type_name -> google.protobuf.StringValue + 388, // 284: productv1.BlogPostFilter.has_categories:type_name -> google.protobuf.BoolValue + 387, // 285: productv1.BlogPostFilter.min_tags:type_name -> google.protobuf.Int32Value + 389, // 286: productv1.Author.email:type_name -> google.protobuf.StringValue + 19, // 287: productv1.Author.social_links:type_name -> productv1.ListOfString + 13, // 288: productv1.Author.teams_by_project:type_name -> productv1.ListOfListOfString + 13, // 289: productv1.Author.collaborations:type_name -> productv1.ListOfListOfString + 4, // 290: productv1.Author.written_posts:type_name -> productv1.ListOfBlogPost + 294, // 291: productv1.Author.favorite_categories:type_name -> productv1.Category + 21, // 292: productv1.Author.related_authors:type_name -> productv1.ListOfUser + 17, // 293: productv1.Author.product_reviews:type_name -> productv1.ListOfProduct + 14, // 294: productv1.Author.author_groups:type_name -> productv1.ListOfListOfUser + 11, // 295: productv1.Author.category_preferences:type_name -> productv1.ListOfListOfCategory + 14, // 296: productv1.Author.project_teams:type_name -> productv1.ListOfListOfUser + 389, // 297: productv1.AuthorFilter.name:type_name -> google.protobuf.StringValue + 388, // 298: productv1.AuthorFilter.has_teams:type_name -> google.protobuf.BoolValue + 387, // 299: productv1.AuthorFilter.skill_count:type_name -> google.protobuf.Int32Value + 389, // 300: productv1.TestContainer.description:type_name -> google.protobuf.StringValue + 332, // 301: productv1.ActionResult.action_success:type_name -> productv1.ActionSuccess + 333, // 302: productv1.ActionResult.action_error:type_name -> productv1.ActionError + 389, // 303: productv1.NullableFieldsInput.optional_string:type_name -> google.protobuf.StringValue + 387, // 304: productv1.NullableFieldsInput.optional_int:type_name -> google.protobuf.Int32Value + 390, // 305: productv1.NullableFieldsInput.optional_float:type_name -> google.protobuf.DoubleValue + 388, // 306: productv1.NullableFieldsInput.optional_boolean:type_name -> google.protobuf.BoolValue + 19, // 307: productv1.BlogPostInput.optional_tags:type_name -> productv1.ListOfString + 19, // 308: productv1.BlogPostInput.keywords:type_name -> productv1.ListOfString + 10, // 309: productv1.BlogPostInput.ratings:type_name -> productv1.ListOfFloat + 7, // 310: productv1.BlogPostInput.is_published:type_name -> productv1.ListOfBoolean + 13, // 311: productv1.BlogPostInput.tag_groups:type_name -> productv1.ListOfListOfString + 13, // 312: productv1.BlogPostInput.related_topics:type_name -> productv1.ListOfListOfString + 13, // 313: productv1.BlogPostInput.comment_threads:type_name -> productv1.ListOfListOfString + 13, // 314: productv1.BlogPostInput.suggestions:type_name -> productv1.ListOfListOfString + 9, // 315: productv1.BlogPostInput.related_categories:type_name -> productv1.ListOfCategoryInput + 22, // 316: productv1.BlogPostInput.contributors:type_name -> productv1.ListOfUserInput + 12, // 317: productv1.BlogPostInput.category_groups:type_name -> productv1.ListOfListOfCategoryInput + 389, // 318: productv1.AuthorInput.email:type_name -> google.protobuf.StringValue + 19, // 319: productv1.AuthorInput.social_links:type_name -> productv1.ListOfString + 13, // 320: productv1.AuthorInput.teams_by_project:type_name -> productv1.ListOfListOfString + 13, // 321: productv1.AuthorInput.collaborations:type_name -> productv1.ListOfListOfString + 335, // 322: productv1.AuthorInput.favorite_categories:type_name -> productv1.CategoryInput + 15, // 323: productv1.AuthorInput.author_groups:type_name -> productv1.ListOfListOfUserInput + 15, // 324: productv1.AuthorInput.project_teams:type_name -> productv1.ListOfListOfUserInput + 308, // 325: productv1.ProductDetails.review_summary:type_name -> productv1.ActionResult + 296, // 326: productv1.ProductDetails.recommended_pet:type_name -> productv1.Animal + 0, // 327: productv1.StorageCategoryInfo.kind:type_name -> productv1.CategoryKind + 317, // 328: productv1.NestedTypeB.c:type_name -> productv1.NestedTypeC + 319, // 329: productv1.FilterType.pagination:type_name -> productv1.Pagination + 19, // 330: productv1.OrderLineInput.modifiers:type_name -> productv1.ListOfString + 19, // 331: productv1.OrderLine.modifiers:type_name -> productv1.ListOfString + 389, // 332: productv1.Subcategory.description:type_name -> google.protobuf.StringValue + 294, // 333: productv1.Subcategory.parent_category:type_name -> productv1.Category + 326, // 334: productv1.Cat.owner:type_name -> productv1.Owner + 329, // 335: productv1.Cat.breed:type_name -> productv1.CatBreed + 326, // 336: productv1.Dog.owner:type_name -> productv1.Owner + 330, // 337: productv1.Dog.breed:type_name -> productv1.DogBreed + 327, // 338: productv1.Owner.contact:type_name -> productv1.ContactInfo + 296, // 339: productv1.Owner.pet:type_name -> productv1.Animal + 328, // 340: productv1.ContactInfo.address:type_name -> productv1.Address + 331, // 341: productv1.CatBreed.characteristics:type_name -> productv1.BreedCharacteristics + 331, // 342: productv1.DogBreed.characteristics:type_name -> productv1.BreedCharacteristics + 296, // 343: productv1.TestDetails.pet:type_name -> productv1.Animal + 308, // 344: productv1.TestDetails.status:type_name -> productv1.ActionResult + 0, // 345: productv1.CategoryInput.kind:type_name -> productv1.CategoryKind + 390, // 346: productv1.ProductCountFilter.min_price:type_name -> google.protobuf.DoubleValue + 390, // 347: productv1.ProductCountFilter.max_price:type_name -> google.protobuf.DoubleValue + 388, // 348: productv1.ProductCountFilter.in_stock:type_name -> google.protobuf.BoolValue + 389, // 349: productv1.ProductCountFilter.search_term:type_name -> google.protobuf.StringValue + 390, // 350: productv1.SubcategoryItemFilter.min_price:type_name -> google.protobuf.DoubleValue + 390, // 351: productv1.SubcategoryItemFilter.max_price:type_name -> google.protobuf.DoubleValue + 388, // 352: productv1.SubcategoryItemFilter.in_stock:type_name -> google.protobuf.BoolValue + 388, // 353: productv1.SubcategoryItemFilter.is_active:type_name -> google.protobuf.BoolValue + 389, // 354: productv1.SubcategoryItemFilter.search_term:type_name -> google.protobuf.StringValue + 1, // 355: productv1.ShippingEstimateInput.destination:type_name -> productv1.ShippingDestination + 388, // 356: productv1.ShippingEstimateInput.expedited:type_name -> google.protobuf.BoolValue + 339, // 357: productv1.ResolveCategoryTotalProductsRequest.context:type_name -> productv1.ResolveCategoryTotalProductsContext + 341, // 358: productv1.ResolveCategoryTotalProductsResponse.result:type_name -> productv1.ResolveCategoryTotalProductsResult + 343, // 359: productv1.ResolveCategoryTopSubcategoryRequest.context:type_name -> productv1.ResolveCategoryTopSubcategoryContext + 322, // 360: productv1.ResolveCategoryTopSubcategoryResult.top_subcategory:type_name -> productv1.Subcategory + 345, // 361: productv1.ResolveCategoryTopSubcategoryResponse.result:type_name -> productv1.ResolveCategoryTopSubcategoryResult + 347, // 362: productv1.ResolveCategoryActiveSubcategoriesRequest.context:type_name -> productv1.ResolveCategoryActiveSubcategoriesContext + 322, // 363: productv1.ResolveCategoryActiveSubcategoriesResult.active_subcategories:type_name -> productv1.Subcategory + 349, // 364: productv1.ResolveCategoryActiveSubcategoriesResponse.result:type_name -> productv1.ResolveCategoryActiveSubcategoriesResult + 351, // 365: productv1.ResolveSubcategoryParentCategoryRequest.context:type_name -> productv1.ResolveSubcategoryParentCategoryContext + 294, // 366: productv1.ResolveSubcategoryParentCategoryResult.parent_category:type_name -> productv1.Category + 353, // 367: productv1.ResolveSubcategoryParentCategoryResponse.result:type_name -> productv1.ResolveSubcategoryParentCategoryResult + 355, // 368: productv1.ResolveCategoryMetricsAverageScoreRequest.context:type_name -> productv1.ResolveCategoryMetricsAverageScoreContext + 357, // 369: productv1.ResolveCategoryMetricsAverageScoreResponse.result:type_name -> productv1.ResolveCategoryMetricsAverageScoreResult + 304, // 370: productv1.ListOfAuthorFilter.List.items:type_name -> productv1.AuthorFilter + 311, // 371: productv1.ListOfAuthorInput.List.items:type_name -> productv1.AuthorInput + 301, // 372: productv1.ListOfBlogPost.List.items:type_name -> productv1.BlogPost + 302, // 373: productv1.ListOfBlogPostFilter.List.items:type_name -> productv1.BlogPostFilter + 310, // 374: productv1.ListOfBlogPostInput.List.items:type_name -> productv1.BlogPostInput + 294, // 375: productv1.ListOfCategory.List.items:type_name -> productv1.Category + 335, // 376: productv1.ListOfCategoryInput.List.items:type_name -> productv1.CategoryInput + 8, // 377: productv1.ListOfListOfCategory.List.items:type_name -> productv1.ListOfCategory + 9, // 378: productv1.ListOfListOfCategoryInput.List.items:type_name -> productv1.ListOfCategoryInput + 19, // 379: productv1.ListOfListOfString.List.items:type_name -> productv1.ListOfString + 21, // 380: productv1.ListOfListOfUser.List.items:type_name -> productv1.ListOfUser + 22, // 381: productv1.ListOfListOfUserInput.List.items:type_name -> productv1.ListOfUserInput + 321, // 382: productv1.ListOfOrderLine.List.items:type_name -> productv1.OrderLine + 282, // 383: productv1.ListOfProduct.List.items:type_name -> productv1.Product + 283, // 384: productv1.ListOfStorage.List.items:type_name -> productv1.Storage + 322, // 385: productv1.ListOfSubcategory.List.items:type_name -> productv1.Subcategory + 285, // 386: productv1.ListOfUser.List.items:type_name -> productv1.User + 306, // 387: productv1.ListOfUserInput.List.items:type_name -> productv1.UserInput + 0, // 388: productv1.RequireStorageCategoryInfoSummaryByIdFields.StorageCategoryInfo.kind:type_name -> productv1.CategoryKind + 24, // 389: productv1.ProductService.LookupProductById:input_type -> productv1.LookupProductByIdRequest + 27, // 390: productv1.ProductService.LookupStorageById:input_type -> productv1.LookupStorageByIdRequest + 30, // 391: productv1.ProductService.LookupWarehouseById:input_type -> productv1.LookupWarehouseByIdRequest + 114, // 392: productv1.ProductService.MutationBulkCreateAuthors:input_type -> productv1.MutationBulkCreateAuthorsRequest + 118, // 393: productv1.ProductService.MutationBulkCreateBlogPosts:input_type -> productv1.MutationBulkCreateBlogPostsRequest + 116, // 394: productv1.ProductService.MutationBulkUpdateAuthors:input_type -> productv1.MutationBulkUpdateAuthorsRequest + 120, // 395: productv1.ProductService.MutationBulkUpdateBlogPosts:input_type -> productv1.MutationBulkUpdateBlogPostsRequest + 110, // 396: productv1.ProductService.MutationCreateAuthor:input_type -> productv1.MutationCreateAuthorRequest + 106, // 397: productv1.ProductService.MutationCreateBlogPost:input_type -> productv1.MutationCreateBlogPostRequest + 102, // 398: productv1.ProductService.MutationCreateNullableFieldsType:input_type -> productv1.MutationCreateNullableFieldsTypeRequest + 98, // 399: productv1.ProductService.MutationCreateUser:input_type -> productv1.MutationCreateUserRequest + 100, // 400: productv1.ProductService.MutationPerformAction:input_type -> productv1.MutationPerformActionRequest + 112, // 401: productv1.ProductService.MutationUpdateAuthor:input_type -> productv1.MutationUpdateAuthorRequest + 108, // 402: productv1.ProductService.MutationUpdateBlogPost:input_type -> productv1.MutationUpdateBlogPostRequest + 104, // 403: productv1.ProductService.MutationUpdateNullableFieldsType:input_type -> productv1.MutationUpdateNullableFieldsTypeRequest + 88, // 404: productv1.ProductService.QueryAllAuthors:input_type -> productv1.QueryAllAuthorsRequest + 80, // 405: productv1.ProductService.QueryAllBlogPosts:input_type -> productv1.QueryAllBlogPostsRequest + 72, // 406: productv1.ProductService.QueryAllNullableFieldsTypes:input_type -> productv1.QueryAllNullableFieldsTypesRequest + 60, // 407: productv1.ProductService.QueryAllPets:input_type -> productv1.QueryAllPetsRequest + 82, // 408: productv1.ProductService.QueryAuthor:input_type -> productv1.QueryAuthorRequest + 84, // 409: productv1.ProductService.QueryAuthorById:input_type -> productv1.QueryAuthorByIdRequest + 86, // 410: productv1.ProductService.QueryAuthorsWithFilter:input_type -> productv1.QueryAuthorsWithFilterRequest + 74, // 411: productv1.ProductService.QueryBlogPost:input_type -> productv1.QueryBlogPostRequest + 76, // 412: productv1.ProductService.QueryBlogPostById:input_type -> productv1.QueryBlogPostByIdRequest + 78, // 413: productv1.ProductService.QueryBlogPostsWithFilter:input_type -> productv1.QueryBlogPostsWithFilterRequest + 90, // 414: productv1.ProductService.QueryBulkSearchAuthors:input_type -> productv1.QueryBulkSearchAuthorsRequest + 92, // 415: productv1.ProductService.QueryBulkSearchBlogPosts:input_type -> productv1.QueryBulkSearchBlogPostsRequest + 46, // 416: productv1.ProductService.QueryCalculateTotals:input_type -> productv1.QueryCalculateTotalsRequest + 48, // 417: productv1.ProductService.QueryCategories:input_type -> productv1.QueryCategoriesRequest + 52, // 418: productv1.ProductService.QueryCategoriesByKind:input_type -> productv1.QueryCategoriesByKindRequest + 54, // 419: productv1.ProductService.QueryCategoriesByKinds:input_type -> productv1.QueryCategoriesByKindsRequest + 50, // 420: productv1.ProductService.QueryCategory:input_type -> productv1.QueryCategoryRequest + 44, // 421: productv1.ProductService.QueryComplexFilterType:input_type -> productv1.QueryComplexFilterTypeRequest + 56, // 422: productv1.ProductService.QueryFilterCategories:input_type -> productv1.QueryFilterCategoriesRequest + 36, // 423: productv1.ProductService.QueryNestedType:input_type -> productv1.QueryNestedTypeRequest + 66, // 424: productv1.ProductService.QueryNullableFieldsType:input_type -> productv1.QueryNullableFieldsTypeRequest + 68, // 425: productv1.ProductService.QueryNullableFieldsTypeById:input_type -> productv1.QueryNullableFieldsTypeByIdRequest + 70, // 426: productv1.ProductService.QueryNullableFieldsTypeWithFilter:input_type -> productv1.QueryNullableFieldsTypeWithFilterRequest + 58, // 427: productv1.ProductService.QueryRandomPet:input_type -> productv1.QueryRandomPetRequest + 64, // 428: productv1.ProductService.QueryRandomSearchResult:input_type -> productv1.QueryRandomSearchResultRequest + 38, // 429: productv1.ProductService.QueryRecursiveType:input_type -> productv1.QueryRecursiveTypeRequest + 62, // 430: productv1.ProductService.QuerySearch:input_type -> productv1.QuerySearchRequest + 94, // 431: productv1.ProductService.QueryTestContainer:input_type -> productv1.QueryTestContainerRequest + 96, // 432: productv1.ProductService.QueryTestContainers:input_type -> productv1.QueryTestContainersRequest + 40, // 433: productv1.ProductService.QueryTypeFilterWithArguments:input_type -> productv1.QueryTypeFilterWithArgumentsRequest + 42, // 434: productv1.ProductService.QueryTypeWithMultipleFilterFields:input_type -> productv1.QueryTypeWithMultipleFilterFieldsRequest + 34, // 435: productv1.ProductService.QueryUser:input_type -> productv1.QueryUserRequest + 32, // 436: productv1.ProductService.QueryUsers:input_type -> productv1.QueryUsersRequest + 272, // 437: productv1.ProductService.RequireStorageCategoryInfoSummaryById:input_type -> productv1.RequireStorageCategoryInfoSummaryByIdRequest + 267, // 438: productv1.ProductService.RequireStorageKindSummaryById:input_type -> productv1.RequireStorageKindSummaryByIdRequest + 237, // 439: productv1.ProductService.RequireStorageMetadataScoreById:input_type -> productv1.RequireStorageMetadataScoreByIdRequest + 247, // 440: productv1.ProductService.RequireStorageOptionalProcessedMetadataById:input_type -> productv1.RequireStorageOptionalProcessedMetadataByIdRequest + 257, // 441: productv1.ProductService.RequireStorageOptionalProcessedTagsById:input_type -> productv1.RequireStorageOptionalProcessedTagsByIdRequest + 232, // 442: productv1.ProductService.RequireStorageOptionalTagSummaryById:input_type -> productv1.RequireStorageOptionalTagSummaryByIdRequest + 242, // 443: productv1.ProductService.RequireStorageProcessedMetadataById:input_type -> productv1.RequireStorageProcessedMetadataByIdRequest + 262, // 444: productv1.ProductService.RequireStorageProcessedMetadataHistoryById:input_type -> productv1.RequireStorageProcessedMetadataHistoryByIdRequest + 252, // 445: productv1.ProductService.RequireStorageProcessedTagsById:input_type -> productv1.RequireStorageProcessedTagsByIdRequest + 222, // 446: productv1.ProductService.RequireStorageStockHealthScoreById:input_type -> productv1.RequireStorageStockHealthScoreByIdRequest + 227, // 447: productv1.ProductService.RequireStorageTagSummaryById:input_type -> productv1.RequireStorageTagSummaryByIdRequest + 277, // 448: productv1.ProductService.RequireWarehouseStockHealthScoreById:input_type -> productv1.RequireWarehouseStockHealthScoreByIdRequest + 174, // 449: productv1.ProductService.ResolveCategoryCategoryMetrics:input_type -> productv1.ResolveCategoryCategoryMetricsRequest + 184, // 450: productv1.ProductService.ResolveCategoryCategoryStatus:input_type -> productv1.ResolveCategoryCategoryStatusRequest + 189, // 451: productv1.ProductService.ResolveCategoryChildCategories:input_type -> productv1.ResolveCategoryChildCategoriesRequest + 179, // 452: productv1.ProductService.ResolveCategoryMascot:input_type -> productv1.ResolveCategoryMascotRequest + 209, // 453: productv1.ProductService.ResolveCategoryMetricsNormalizedScore:input_type -> productv1.ResolveCategoryMetricsNormalizedScoreRequest + 214, // 454: productv1.ProductService.ResolveCategoryMetricsRelatedCategory:input_type -> productv1.ResolveCategoryMetricsRelatedCategoryRequest + 194, // 455: productv1.ProductService.ResolveCategoryOptionalCategories:input_type -> productv1.ResolveCategoryOptionalCategoriesRequest + 169, // 456: productv1.ProductService.ResolveCategoryPopularityScore:input_type -> productv1.ResolveCategoryPopularityScoreRequest + 164, // 457: productv1.ProductService.ResolveCategoryProductCount:input_type -> productv1.ResolveCategoryProductCountRequest + 134, // 458: productv1.ProductService.ResolveProductMascotRecommendation:input_type -> productv1.ResolveProductMascotRecommendationRequest + 144, // 459: productv1.ProductService.ResolveProductProductDetails:input_type -> productv1.ResolveProductProductDetailsRequest + 129, // 460: productv1.ProductService.ResolveProductRecommendedCategory:input_type -> productv1.ResolveProductRecommendedCategoryRequest + 124, // 461: productv1.ProductService.ResolveProductShippingEstimate:input_type -> productv1.ResolveProductShippingEstimateRequest + 139, // 462: productv1.ProductService.ResolveProductStockStatus:input_type -> productv1.ResolveProductStockStatusRequest + 154, // 463: productv1.ProductService.ResolveStorageLinkedStorages:input_type -> productv1.ResolveStorageLinkedStoragesRequest + 159, // 464: productv1.ProductService.ResolveStorageNearbyStorages:input_type -> productv1.ResolveStorageNearbyStoragesRequest + 149, // 465: productv1.ProductService.ResolveStorageStorageStatus:input_type -> productv1.ResolveStorageStorageStatusRequest + 204, // 466: productv1.ProductService.ResolveSubcategoryFeaturedCategory:input_type -> productv1.ResolveSubcategoryFeaturedCategoryRequest + 199, // 467: productv1.ProductService.ResolveSubcategoryItemCount:input_type -> productv1.ResolveSubcategoryItemCountRequest + 219, // 468: productv1.ProductService.ResolveTestContainerDetails:input_type -> productv1.ResolveTestContainerDetailsRequest + 340, // 469: productv1.ProductService.ResolveCategoryTotalProducts:input_type -> productv1.ResolveCategoryTotalProductsRequest + 344, // 470: productv1.ProductService.ResolveCategoryTopSubcategory:input_type -> productv1.ResolveCategoryTopSubcategoryRequest + 348, // 471: productv1.ProductService.ResolveCategoryActiveSubcategories:input_type -> productv1.ResolveCategoryActiveSubcategoriesRequest + 352, // 472: productv1.ProductService.ResolveSubcategoryParentCategory:input_type -> productv1.ResolveSubcategoryParentCategoryRequest + 356, // 473: productv1.ProductService.ResolveCategoryMetricsAverageScore:input_type -> productv1.ResolveCategoryMetricsAverageScoreRequest + 25, // 474: productv1.ProductService.LookupProductById:output_type -> productv1.LookupProductByIdResponse + 28, // 475: productv1.ProductService.LookupStorageById:output_type -> productv1.LookupStorageByIdResponse + 31, // 476: productv1.ProductService.LookupWarehouseById:output_type -> productv1.LookupWarehouseByIdResponse + 115, // 477: productv1.ProductService.MutationBulkCreateAuthors:output_type -> productv1.MutationBulkCreateAuthorsResponse + 119, // 478: productv1.ProductService.MutationBulkCreateBlogPosts:output_type -> productv1.MutationBulkCreateBlogPostsResponse + 117, // 479: productv1.ProductService.MutationBulkUpdateAuthors:output_type -> productv1.MutationBulkUpdateAuthorsResponse + 121, // 480: productv1.ProductService.MutationBulkUpdateBlogPosts:output_type -> productv1.MutationBulkUpdateBlogPostsResponse + 111, // 481: productv1.ProductService.MutationCreateAuthor:output_type -> productv1.MutationCreateAuthorResponse + 107, // 482: productv1.ProductService.MutationCreateBlogPost:output_type -> productv1.MutationCreateBlogPostResponse + 103, // 483: productv1.ProductService.MutationCreateNullableFieldsType:output_type -> productv1.MutationCreateNullableFieldsTypeResponse + 99, // 484: productv1.ProductService.MutationCreateUser:output_type -> productv1.MutationCreateUserResponse + 101, // 485: productv1.ProductService.MutationPerformAction:output_type -> productv1.MutationPerformActionResponse + 113, // 486: productv1.ProductService.MutationUpdateAuthor:output_type -> productv1.MutationUpdateAuthorResponse + 109, // 487: productv1.ProductService.MutationUpdateBlogPost:output_type -> productv1.MutationUpdateBlogPostResponse + 105, // 488: productv1.ProductService.MutationUpdateNullableFieldsType:output_type -> productv1.MutationUpdateNullableFieldsTypeResponse + 89, // 489: productv1.ProductService.QueryAllAuthors:output_type -> productv1.QueryAllAuthorsResponse + 81, // 490: productv1.ProductService.QueryAllBlogPosts:output_type -> productv1.QueryAllBlogPostsResponse + 73, // 491: productv1.ProductService.QueryAllNullableFieldsTypes:output_type -> productv1.QueryAllNullableFieldsTypesResponse + 61, // 492: productv1.ProductService.QueryAllPets:output_type -> productv1.QueryAllPetsResponse + 83, // 493: productv1.ProductService.QueryAuthor:output_type -> productv1.QueryAuthorResponse + 85, // 494: productv1.ProductService.QueryAuthorById:output_type -> productv1.QueryAuthorByIdResponse + 87, // 495: productv1.ProductService.QueryAuthorsWithFilter:output_type -> productv1.QueryAuthorsWithFilterResponse + 75, // 496: productv1.ProductService.QueryBlogPost:output_type -> productv1.QueryBlogPostResponse + 77, // 497: productv1.ProductService.QueryBlogPostById:output_type -> productv1.QueryBlogPostByIdResponse + 79, // 498: productv1.ProductService.QueryBlogPostsWithFilter:output_type -> productv1.QueryBlogPostsWithFilterResponse + 91, // 499: productv1.ProductService.QueryBulkSearchAuthors:output_type -> productv1.QueryBulkSearchAuthorsResponse + 93, // 500: productv1.ProductService.QueryBulkSearchBlogPosts:output_type -> productv1.QueryBulkSearchBlogPostsResponse + 47, // 501: productv1.ProductService.QueryCalculateTotals:output_type -> productv1.QueryCalculateTotalsResponse + 49, // 502: productv1.ProductService.QueryCategories:output_type -> productv1.QueryCategoriesResponse + 53, // 503: productv1.ProductService.QueryCategoriesByKind:output_type -> productv1.QueryCategoriesByKindResponse + 55, // 504: productv1.ProductService.QueryCategoriesByKinds:output_type -> productv1.QueryCategoriesByKindsResponse + 51, // 505: productv1.ProductService.QueryCategory:output_type -> productv1.QueryCategoryResponse + 45, // 506: productv1.ProductService.QueryComplexFilterType:output_type -> productv1.QueryComplexFilterTypeResponse + 57, // 507: productv1.ProductService.QueryFilterCategories:output_type -> productv1.QueryFilterCategoriesResponse + 37, // 508: productv1.ProductService.QueryNestedType:output_type -> productv1.QueryNestedTypeResponse + 67, // 509: productv1.ProductService.QueryNullableFieldsType:output_type -> productv1.QueryNullableFieldsTypeResponse + 69, // 510: productv1.ProductService.QueryNullableFieldsTypeById:output_type -> productv1.QueryNullableFieldsTypeByIdResponse + 71, // 511: productv1.ProductService.QueryNullableFieldsTypeWithFilter:output_type -> productv1.QueryNullableFieldsTypeWithFilterResponse + 59, // 512: productv1.ProductService.QueryRandomPet:output_type -> productv1.QueryRandomPetResponse + 65, // 513: productv1.ProductService.QueryRandomSearchResult:output_type -> productv1.QueryRandomSearchResultResponse + 39, // 514: productv1.ProductService.QueryRecursiveType:output_type -> productv1.QueryRecursiveTypeResponse + 63, // 515: productv1.ProductService.QuerySearch:output_type -> productv1.QuerySearchResponse + 95, // 516: productv1.ProductService.QueryTestContainer:output_type -> productv1.QueryTestContainerResponse + 97, // 517: productv1.ProductService.QueryTestContainers:output_type -> productv1.QueryTestContainersResponse + 41, // 518: productv1.ProductService.QueryTypeFilterWithArguments:output_type -> productv1.QueryTypeFilterWithArgumentsResponse + 43, // 519: productv1.ProductService.QueryTypeWithMultipleFilterFields:output_type -> productv1.QueryTypeWithMultipleFilterFieldsResponse + 35, // 520: productv1.ProductService.QueryUser:output_type -> productv1.QueryUserResponse + 33, // 521: productv1.ProductService.QueryUsers:output_type -> productv1.QueryUsersResponse + 274, // 522: productv1.ProductService.RequireStorageCategoryInfoSummaryById:output_type -> productv1.RequireStorageCategoryInfoSummaryByIdResponse + 269, // 523: productv1.ProductService.RequireStorageKindSummaryById:output_type -> productv1.RequireStorageKindSummaryByIdResponse + 239, // 524: productv1.ProductService.RequireStorageMetadataScoreById:output_type -> productv1.RequireStorageMetadataScoreByIdResponse + 249, // 525: productv1.ProductService.RequireStorageOptionalProcessedMetadataById:output_type -> productv1.RequireStorageOptionalProcessedMetadataByIdResponse + 259, // 526: productv1.ProductService.RequireStorageOptionalProcessedTagsById:output_type -> productv1.RequireStorageOptionalProcessedTagsByIdResponse + 234, // 527: productv1.ProductService.RequireStorageOptionalTagSummaryById:output_type -> productv1.RequireStorageOptionalTagSummaryByIdResponse + 244, // 528: productv1.ProductService.RequireStorageProcessedMetadataById:output_type -> productv1.RequireStorageProcessedMetadataByIdResponse + 264, // 529: productv1.ProductService.RequireStorageProcessedMetadataHistoryById:output_type -> productv1.RequireStorageProcessedMetadataHistoryByIdResponse + 254, // 530: productv1.ProductService.RequireStorageProcessedTagsById:output_type -> productv1.RequireStorageProcessedTagsByIdResponse + 224, // 531: productv1.ProductService.RequireStorageStockHealthScoreById:output_type -> productv1.RequireStorageStockHealthScoreByIdResponse + 229, // 532: productv1.ProductService.RequireStorageTagSummaryById:output_type -> productv1.RequireStorageTagSummaryByIdResponse + 279, // 533: productv1.ProductService.RequireWarehouseStockHealthScoreById:output_type -> productv1.RequireWarehouseStockHealthScoreByIdResponse + 176, // 534: productv1.ProductService.ResolveCategoryCategoryMetrics:output_type -> productv1.ResolveCategoryCategoryMetricsResponse + 186, // 535: productv1.ProductService.ResolveCategoryCategoryStatus:output_type -> productv1.ResolveCategoryCategoryStatusResponse + 191, // 536: productv1.ProductService.ResolveCategoryChildCategories:output_type -> productv1.ResolveCategoryChildCategoriesResponse + 181, // 537: productv1.ProductService.ResolveCategoryMascot:output_type -> productv1.ResolveCategoryMascotResponse + 211, // 538: productv1.ProductService.ResolveCategoryMetricsNormalizedScore:output_type -> productv1.ResolveCategoryMetricsNormalizedScoreResponse + 216, // 539: productv1.ProductService.ResolveCategoryMetricsRelatedCategory:output_type -> productv1.ResolveCategoryMetricsRelatedCategoryResponse + 196, // 540: productv1.ProductService.ResolveCategoryOptionalCategories:output_type -> productv1.ResolveCategoryOptionalCategoriesResponse + 171, // 541: productv1.ProductService.ResolveCategoryPopularityScore:output_type -> productv1.ResolveCategoryPopularityScoreResponse + 166, // 542: productv1.ProductService.ResolveCategoryProductCount:output_type -> productv1.ResolveCategoryProductCountResponse + 136, // 543: productv1.ProductService.ResolveProductMascotRecommendation:output_type -> productv1.ResolveProductMascotRecommendationResponse + 146, // 544: productv1.ProductService.ResolveProductProductDetails:output_type -> productv1.ResolveProductProductDetailsResponse + 131, // 545: productv1.ProductService.ResolveProductRecommendedCategory:output_type -> productv1.ResolveProductRecommendedCategoryResponse + 126, // 546: productv1.ProductService.ResolveProductShippingEstimate:output_type -> productv1.ResolveProductShippingEstimateResponse + 141, // 547: productv1.ProductService.ResolveProductStockStatus:output_type -> productv1.ResolveProductStockStatusResponse + 156, // 548: productv1.ProductService.ResolveStorageLinkedStorages:output_type -> productv1.ResolveStorageLinkedStoragesResponse + 161, // 549: productv1.ProductService.ResolveStorageNearbyStorages:output_type -> productv1.ResolveStorageNearbyStoragesResponse + 151, // 550: productv1.ProductService.ResolveStorageStorageStatus:output_type -> productv1.ResolveStorageStorageStatusResponse + 206, // 551: productv1.ProductService.ResolveSubcategoryFeaturedCategory:output_type -> productv1.ResolveSubcategoryFeaturedCategoryResponse + 201, // 552: productv1.ProductService.ResolveSubcategoryItemCount:output_type -> productv1.ResolveSubcategoryItemCountResponse + 221, // 553: productv1.ProductService.ResolveTestContainerDetails:output_type -> productv1.ResolveTestContainerDetailsResponse + 342, // 554: productv1.ProductService.ResolveCategoryTotalProducts:output_type -> productv1.ResolveCategoryTotalProductsResponse + 346, // 555: productv1.ProductService.ResolveCategoryTopSubcategory:output_type -> productv1.ResolveCategoryTopSubcategoryResponse + 350, // 556: productv1.ProductService.ResolveCategoryActiveSubcategories:output_type -> productv1.ResolveCategoryActiveSubcategoriesResponse + 354, // 557: productv1.ProductService.ResolveSubcategoryParentCategory:output_type -> productv1.ResolveSubcategoryParentCategoryResponse + 358, // 558: productv1.ProductService.ResolveCategoryMetricsAverageScore:output_type -> productv1.ResolveCategoryMetricsAverageScoreResponse + 474, // [474:559] is the sub-list for method output_type + 389, // [389:474] is the sub-list for method input_type + 389, // [389:389] is the sub-list for extension type_name + 389, // [389:389] is the sub-list for extension extendee + 0, // [0:389] is the sub-list for field type_name } func init() { file_product_proto_init() } @@ -20404,7 +21444,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..440b986a70 100644 --- a/v2/pkg/grpctest/productv1/product_grpc.pb.go +++ b/v2/pkg/grpctest/productv1/product_grpc.pb.go @@ -99,6 +99,11 @@ const ( ProductService_ResolveSubcategoryFeaturedCategory_FullMethodName = "/productv1.ProductService/ResolveSubcategoryFeaturedCategory" ProductService_ResolveSubcategoryItemCount_FullMethodName = "/productv1.ProductService/ResolveSubcategoryItemCount" ProductService_ResolveTestContainerDetails_FullMethodName = "/productv1.ProductService/ResolveTestContainerDetails" + ProductService_ResolveCategoryTotalProducts_FullMethodName = "/productv1.ProductService/ResolveCategoryTotalProducts" + ProductService_ResolveCategoryTopSubcategory_FullMethodName = "/productv1.ProductService/ResolveCategoryTopSubcategory" + ProductService_ResolveCategoryActiveSubcategories_FullMethodName = "/productv1.ProductService/ResolveCategoryActiveSubcategories" + ProductService_ResolveSubcategoryParentCategory_FullMethodName = "/productv1.ProductService/ResolveSubcategoryParentCategory" + ProductService_ResolveCategoryMetricsAverageScore_FullMethodName = "/productv1.ProductService/ResolveCategoryMetricsAverageScore" ) // ProductServiceClient is the client API for ProductService service. @@ -190,6 +195,11 @@ type ProductServiceClient interface { ResolveSubcategoryFeaturedCategory(ctx context.Context, in *ResolveSubcategoryFeaturedCategoryRequest, opts ...grpc.CallOption) (*ResolveSubcategoryFeaturedCategoryResponse, error) ResolveSubcategoryItemCount(ctx context.Context, in *ResolveSubcategoryItemCountRequest, opts ...grpc.CallOption) (*ResolveSubcategoryItemCountResponse, error) ResolveTestContainerDetails(ctx context.Context, in *ResolveTestContainerDetailsRequest, opts ...grpc.CallOption) (*ResolveTestContainerDetailsResponse, error) + ResolveCategoryTotalProducts(ctx context.Context, in *ResolveCategoryTotalProductsRequest, opts ...grpc.CallOption) (*ResolveCategoryTotalProductsResponse, error) + ResolveCategoryTopSubcategory(ctx context.Context, in *ResolveCategoryTopSubcategoryRequest, opts ...grpc.CallOption) (*ResolveCategoryTopSubcategoryResponse, error) + ResolveCategoryActiveSubcategories(ctx context.Context, in *ResolveCategoryActiveSubcategoriesRequest, opts ...grpc.CallOption) (*ResolveCategoryActiveSubcategoriesResponse, error) + ResolveSubcategoryParentCategory(ctx context.Context, in *ResolveSubcategoryParentCategoryRequest, opts ...grpc.CallOption) (*ResolveSubcategoryParentCategoryResponse, error) + ResolveCategoryMetricsAverageScore(ctx context.Context, in *ResolveCategoryMetricsAverageScoreRequest, opts ...grpc.CallOption) (*ResolveCategoryMetricsAverageScoreResponse, error) } type productServiceClient struct { @@ -1000,6 +1010,56 @@ func (c *productServiceClient) ResolveTestContainerDetails(ctx context.Context, 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) 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) 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) 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) 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 +} + // ProductServiceServer is the server API for ProductService service. // All implementations must embed UnimplementedProductServiceServer // for forward compatibility. @@ -1089,6 +1149,11 @@ type ProductServiceServer interface { ResolveSubcategoryFeaturedCategory(context.Context, *ResolveSubcategoryFeaturedCategoryRequest) (*ResolveSubcategoryFeaturedCategoryResponse, error) ResolveSubcategoryItemCount(context.Context, *ResolveSubcategoryItemCountRequest) (*ResolveSubcategoryItemCountResponse, error) ResolveTestContainerDetails(context.Context, *ResolveTestContainerDetailsRequest) (*ResolveTestContainerDetailsResponse, error) + ResolveCategoryTotalProducts(context.Context, *ResolveCategoryTotalProductsRequest) (*ResolveCategoryTotalProductsResponse, error) + ResolveCategoryTopSubcategory(context.Context, *ResolveCategoryTopSubcategoryRequest) (*ResolveCategoryTopSubcategoryResponse, error) + ResolveCategoryActiveSubcategories(context.Context, *ResolveCategoryActiveSubcategoriesRequest) (*ResolveCategoryActiveSubcategoriesResponse, error) + ResolveSubcategoryParentCategory(context.Context, *ResolveSubcategoryParentCategoryRequest) (*ResolveSubcategoryParentCategoryResponse, error) + ResolveCategoryMetricsAverageScore(context.Context, *ResolveCategoryMetricsAverageScoreRequest) (*ResolveCategoryMetricsAverageScoreResponse, error) mustEmbedUnimplementedProductServiceServer() } @@ -1339,6 +1404,21 @@ func (UnimplementedProductServiceServer) ResolveSubcategoryItemCount(context.Con func (UnimplementedProductServiceServer) ResolveTestContainerDetails(context.Context, *ResolveTestContainerDetailsRequest) (*ResolveTestContainerDetailsResponse, error) { return nil, status.Error(codes.Unimplemented, "method ResolveTestContainerDetails not implemented") } +func (UnimplementedProductServiceServer) ResolveCategoryTotalProducts(context.Context, *ResolveCategoryTotalProductsRequest) (*ResolveCategoryTotalProductsResponse, error) { + return nil, status.Error(codes.Unimplemented, "method ResolveCategoryTotalProducts not implemented") +} +func (UnimplementedProductServiceServer) ResolveCategoryTopSubcategory(context.Context, *ResolveCategoryTopSubcategoryRequest) (*ResolveCategoryTopSubcategoryResponse, error) { + return nil, status.Error(codes.Unimplemented, "method ResolveCategoryTopSubcategory not implemented") +} +func (UnimplementedProductServiceServer) ResolveCategoryActiveSubcategories(context.Context, *ResolveCategoryActiveSubcategoriesRequest) (*ResolveCategoryActiveSubcategoriesResponse, error) { + return nil, status.Error(codes.Unimplemented, "method ResolveCategoryActiveSubcategories not implemented") +} +func (UnimplementedProductServiceServer) ResolveSubcategoryParentCategory(context.Context, *ResolveSubcategoryParentCategoryRequest) (*ResolveSubcategoryParentCategoryResponse, error) { + return nil, status.Error(codes.Unimplemented, "method ResolveSubcategoryParentCategory not implemented") +} +func (UnimplementedProductServiceServer) ResolveCategoryMetricsAverageScore(context.Context, *ResolveCategoryMetricsAverageScoreRequest) (*ResolveCategoryMetricsAverageScoreResponse, error) { + return nil, status.Error(codes.Unimplemented, "method ResolveCategoryMetricsAverageScore not implemented") +} func (UnimplementedProductServiceServer) mustEmbedUnimplementedProductServiceServer() {} func (UnimplementedProductServiceServer) testEmbeddedByValue() {} @@ -2800,6 +2880,96 @@ func _ProductService_ResolveTestContainerDetails_Handler(srv interface{}, ctx co 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_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_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_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_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) +} + // ProductService_ServiceDesc is the grpc.ServiceDesc for ProductService service. // It's only intended for direct use with grpc.RegisterService, // and not to be introspected or modified (even as a copy) @@ -3127,6 +3297,26 @@ var ProductService_ServiceDesc = grpc.ServiceDesc{ MethodName: "ResolveTestContainerDetails", Handler: _ProductService_ResolveTestContainerDetails_Handler, }, + { + MethodName: "ResolveCategoryTotalProducts", + Handler: _ProductService_ResolveCategoryTotalProducts_Handler, + }, + { + MethodName: "ResolveCategoryTopSubcategory", + Handler: _ProductService_ResolveCategoryTopSubcategory_Handler, + }, + { + MethodName: "ResolveCategoryActiveSubcategories", + Handler: _ProductService_ResolveCategoryActiveSubcategories_Handler, + }, + { + MethodName: "ResolveSubcategoryParentCategory", + Handler: _ProductService_ResolveSubcategoryParentCategory_Handler, + }, + { + MethodName: "ResolveCategoryMetricsAverageScore", + Handler: _ProductService_ResolveCategoryMetricsAverageScore_Handler, + }, }, Streams: []grpc.StreamDesc{}, Metadata: "product.proto", 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 { From c7200bf9b51740d69f10bf0e4642882759efd958 Mon Sep 17 00:00:00 2001 From: Ludwig Bedacht Date: Wed, 11 Mar 2026 14:34:03 +0100 Subject: [PATCH 2/3] chore: simplify mapping code generation and regenerate mapping --- .../grpc_datasource/mapping_test_helper.go | 17 +- v2/pkg/grpctest/Makefile | 19 +- v2/pkg/grpctest/cmd/mapping_helper/main.go | 23 +- .../grcp_datasource_mapping_helper.tmpl | 117 + v2/pkg/grpctest/mapping/mapping.go | 45 + v2/pkg/grpctest/product.proto | 189 +- v2/pkg/grpctest/productv1/product.pb.go | 8386 ++++++++--------- v2/pkg/grpctest/productv1/product_grpc.pb.go | 334 +- 8 files changed, 4635 insertions(+), 4495 deletions(-) create mode 100644 v2/pkg/grpctest/cmd/mapping_helper/templates/grcp_datasource_mapping_helper.tmpl 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 e972c9aa8f..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", @@ -314,7 +315,8 @@ func testMapping() *GRPCMapping { }, "totalProducts": { FieldMappingData: FieldMapData{ - TargetName: "total_products", + TargetName: "total_products", + ArgumentMappings: FieldArgumentMap{}, }, RPC: "ResolveCategoryTotalProducts", Request: "ResolveCategoryTotalProductsRequest", @@ -322,7 +324,8 @@ func testMapping() *GRPCMapping { }, "topSubcategory": { FieldMappingData: FieldMapData{ - TargetName: "top_subcategory", + TargetName: "top_subcategory", + ArgumentMappings: FieldArgumentMap{}, }, RPC: "ResolveCategoryTopSubcategory", Request: "ResolveCategoryTopSubcategoryRequest", @@ -330,7 +333,8 @@ func testMapping() *GRPCMapping { }, "activeSubcategories": { FieldMappingData: FieldMapData{ - TargetName: "active_subcategories", + TargetName: "active_subcategories", + ArgumentMappings: FieldArgumentMap{}, }, RPC: "ResolveCategoryActiveSubcategories", Request: "ResolveCategoryActiveSubcategoriesRequest", @@ -362,7 +366,8 @@ func testMapping() *GRPCMapping { }, "averageScore": { FieldMappingData: FieldMapData{ - TargetName: "average_score", + TargetName: "average_score", + ArgumentMappings: FieldArgumentMap{}, }, RPC: "ResolveCategoryMetricsAverageScore", Request: "ResolveCategoryMetricsAverageScoreRequest", @@ -486,7 +491,8 @@ func testMapping() *GRPCMapping { }, "parentCategory": { FieldMappingData: FieldMapData{ - TargetName: "parent_category", + TargetName: "parent_category", + ArgumentMappings: FieldArgumentMap{}, }, RPC: "ResolveSubcategoryParentCategory", Request: "ResolveSubcategoryParentCategoryRequest", @@ -1875,5 +1881,4 @@ func testMapping() *GRPCMapping { }, }, } - } diff --git a/v2/pkg/grpctest/Makefile b/v2/pkg/grpctest/Makefile index 14e008ef17..dd701ca9e9 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: generate-mapping-code-grpc-test generate-mapping-code-grpc-datasource regenerate-proto cleanup-mapping-file + +.PHONY: generate-mapping-code-grpc-test +generate-mapping-code-grpc-test: 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: + go run $(mkfile_dir)/cmd/mapping_helper/main.go -without-package $(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: rm -f $(mkfile_dir)/testdata/mapping.json @@ -35,10 +47,7 @@ regenerate-proto-local: rm -f $(mkfile_dir)/testdata/service.proto.lock.json .PHONY: generate-mapping-code-local -generate-mapping-code-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 - rm -f $(mkfile_dir)/testdata/mapping.json +generate-mapping-code-local: regenerate-proto-local generate-mapping-code-grpc-test generate-mapping-code-grpc-datasource cleanup-mapping-file .PHONY: generate-all diff --git a/v2/pkg/grpctest/cmd/mapping_helper/main.go b/v2/pkg/grpctest/cmd/mapping_helper/main.go index b33cde4aa8..1fc45c9579 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 + tplWithoutPackage string + + withoutPackage bool ) +// define flags for the command +func init() { + flag.BoolVar(&withoutPackage, "without-package", false, "generate mapping without package") +} + 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 withoutPackage { + usedTemplate = tplWithoutPackage + } + + 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 a43fc0350d..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": { diff --git a/v2/pkg/grpctest/product.proto b/v2/pkg/grpctest/product.proto index 4c29db43a4..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,12 +93,8 @@ service ProductService { rpc ResolveStorageStorageStatus(ResolveStorageStorageStatusRequest) returns (ResolveStorageStorageStatusResponse) {} rpc ResolveSubcategoryFeaturedCategory(ResolveSubcategoryFeaturedCategoryRequest) returns (ResolveSubcategoryFeaturedCategoryResponse) {} rpc ResolveSubcategoryItemCount(ResolveSubcategoryItemCountRequest) returns (ResolveSubcategoryItemCountResponse) {} - rpc ResolveTestContainerDetails(ResolveTestContainerDetailsRequest) returns (ResolveTestContainerDetailsResponse) {} - rpc ResolveCategoryTotalProducts(ResolveCategoryTotalProductsRequest) returns (ResolveCategoryTotalProductsResponse) {} - rpc ResolveCategoryTopSubcategory(ResolveCategoryTopSubcategoryRequest) returns (ResolveCategoryTopSubcategoryResponse) {} - rpc ResolveCategoryActiveSubcategories(ResolveCategoryActiveSubcategoriesRequest) returns (ResolveCategoryActiveSubcategoriesResponse) {} rpc ResolveSubcategoryParentCategory(ResolveSubcategoryParentCategoryRequest) returns (ResolveSubcategoryParentCategoryResponse) {} - rpc ResolveCategoryMetricsAverageScore(ResolveCategoryMetricsAverageScoreRequest) returns (ResolveCategoryMetricsAverageScoreResponse) {} + rpc ResolveTestContainerDetails(ResolveTestContainerDetailsRequest) returns (ResolveTestContainerDetailsResponse) {} } // Wrapper message for a list of AuthorFilter. @@ -1059,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; } @@ -1105,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; } @@ -1153,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; } @@ -1564,9 +1651,6 @@ message Category { CategoryKind kind = 3; ListOfSubcategory subcategories = 4; CategoryMetrics null_metrics = 5; - int32 total_products = 6; - Subcategory top_subcategory = 7; - repeated Subcategory active_subcategories = 8; } message CategoryFilter { @@ -1790,7 +1874,6 @@ message Subcategory { string name = 2; google.protobuf.StringValue description = 3; bool is_active = 4; - Category parent_category = 5; } message CategoryMetrics { @@ -1799,7 +1882,6 @@ message CategoryMetrics { double value = 3; string timestamp = 4; string category_id = 5; - double average_score = 6; } enum CategoryKind { @@ -1916,91 +1998,4 @@ message ShippingEstimateInput { ShippingDestination destination = 1; double weight = 2; google.protobuf.BoolValue expedited = 3; -} - -// Argument-less field resolver messages for Category.totalProducts -message ResolveCategoryTotalProductsContext { - string id = 1; -} - -message ResolveCategoryTotalProductsRequest { - repeated ResolveCategoryTotalProductsContext context = 1; -} - -message ResolveCategoryTotalProductsResult { - int32 total_products = 1; -} - -message ResolveCategoryTotalProductsResponse { - repeated ResolveCategoryTotalProductsResult result = 1; -} - -// Argument-less field resolver messages for Category.topSubcategory -message ResolveCategoryTopSubcategoryContext { - string id = 1; - string name = 2; -} - -message ResolveCategoryTopSubcategoryRequest { - repeated ResolveCategoryTopSubcategoryContext context = 1; -} - -message ResolveCategoryTopSubcategoryResult { - Subcategory top_subcategory = 1; -} - -message ResolveCategoryTopSubcategoryResponse { - repeated ResolveCategoryTopSubcategoryResult result = 1; -} - -// Argument-less field resolver messages for Category.activeSubcategories -message ResolveCategoryActiveSubcategoriesContext { - string id = 1; -} - -message ResolveCategoryActiveSubcategoriesRequest { - repeated ResolveCategoryActiveSubcategoriesContext context = 1; -} - -message ResolveCategoryActiveSubcategoriesResult { - repeated Subcategory active_subcategories = 1; -} - -message ResolveCategoryActiveSubcategoriesResponse { - repeated ResolveCategoryActiveSubcategoriesResult result = 1; -} - -// Argument-less field resolver messages for Subcategory.parentCategory -message ResolveSubcategoryParentCategoryContext { - string id = 1; -} - -message ResolveSubcategoryParentCategoryRequest { - repeated ResolveSubcategoryParentCategoryContext context = 1; -} - -message ResolveSubcategoryParentCategoryResult { - Category parent_category = 1; -} - -message ResolveSubcategoryParentCategoryResponse { - repeated ResolveSubcategoryParentCategoryResult result = 1; -} - -// Argument-less field resolver messages for CategoryMetrics.averageScore -message ResolveCategoryMetricsAverageScoreContext { - string id = 1; - string metric_type = 2; -} - -message ResolveCategoryMetricsAverageScoreRequest { - repeated ResolveCategoryMetricsAverageScoreContext context = 1; -} - -message ResolveCategoryMetricsAverageScoreResult { - double average_score = 1; -} - -message ResolveCategoryMetricsAverageScoreResponse { - repeated ResolveCategoryMetricsAverageScoreResult result = 1; } \ No newline at end of file diff --git a/v2/pkg/grpctest/productv1/product.pb.go b/v2/pkg/grpctest/productv1/product.pb.go index c41950292d..d7dbf11daf 100644 --- a/v2/pkg/grpctest/productv1/product.pb.go +++ b/v2/pkg/grpctest/productv1/product.pb.go @@ -9091,27 +9091,27 @@ func (x *ResolveCategoryOptionalCategoriesResponse) GetResult() []*ResolveCatego return nil } -type ResolveSubcategoryItemCountArgs struct { +type ResolveCategoryTotalProductsContext struct { state protoimpl.MessageState `protogen:"open.v1"` - Filters *SubcategoryItemFilter `protobuf:"bytes,1,opt,name=filters,proto3" json:"filters,omitempty"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ResolveSubcategoryItemCountArgs) Reset() { - *x = ResolveSubcategoryItemCountArgs{} +func (x *ResolveCategoryTotalProductsContext) Reset() { + *x = ResolveCategoryTotalProductsContext{} mi := &file_product_proto_msgTypes[195] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveSubcategoryItemCountArgs) String() string { +func (x *ResolveCategoryTotalProductsContext) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveSubcategoryItemCountArgs) ProtoMessage() {} +func (*ResolveCategoryTotalProductsContext) ProtoMessage() {} -func (x *ResolveSubcategoryItemCountArgs) ProtoReflect() protoreflect.Message { +func (x *ResolveCategoryTotalProductsContext) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[195] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -9123,39 +9123,40 @@ func (x *ResolveSubcategoryItemCountArgs) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ResolveSubcategoryItemCountArgs.ProtoReflect.Descriptor instead. -func (*ResolveSubcategoryItemCountArgs) Descriptor() ([]byte, []int) { +// Deprecated: Use ResolveCategoryTotalProductsContext.ProtoReflect.Descriptor instead. +func (*ResolveCategoryTotalProductsContext) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{195} } -func (x *ResolveSubcategoryItemCountArgs) GetFilters() *SubcategoryItemFilter { +func (x *ResolveCategoryTotalProductsContext) GetId() string { if x != nil { - return x.Filters + return x.Id } - return nil + return "" } -type ResolveSubcategoryItemCountContext struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` +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 *ResolveSubcategoryItemCountContext) Reset() { - *x = ResolveSubcategoryItemCountContext{} +func (x *ResolveCategoryTotalProductsRequest) Reset() { + *x = ResolveCategoryTotalProductsRequest{} mi := &file_product_proto_msgTypes[196] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveSubcategoryItemCountContext) String() string { +func (x *ResolveCategoryTotalProductsRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveSubcategoryItemCountContext) ProtoMessage() {} +func (*ResolveCategoryTotalProductsRequest) ProtoMessage() {} -func (x *ResolveSubcategoryItemCountContext) ProtoReflect() protoreflect.Message { +func (x *ResolveCategoryTotalProductsRequest) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[196] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -9167,42 +9168,39 @@ func (x *ResolveSubcategoryItemCountContext) ProtoReflect() protoreflect.Message return mi.MessageOf(x) } -// Deprecated: Use ResolveSubcategoryItemCountContext.ProtoReflect.Descriptor instead. -func (*ResolveSubcategoryItemCountContext) Descriptor() ([]byte, []int) { +// Deprecated: Use ResolveCategoryTotalProductsRequest.ProtoReflect.Descriptor instead. +func (*ResolveCategoryTotalProductsRequest) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{196} } -func (x *ResolveSubcategoryItemCountContext) GetId() string { +func (x *ResolveCategoryTotalProductsRequest) GetContext() []*ResolveCategoryTotalProductsContext { if x != nil { - return x.Id + return x.Context } - return "" + return nil } -type ResolveSubcategoryItemCountRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - // context provides the resolver context for the field itemCount of type Subcategory. - Context []*ResolveSubcategoryItemCountContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` - // field_args provides the arguments for the resolver field itemCount of type Subcategory. - FieldArgs *ResolveSubcategoryItemCountArgs `protobuf:"bytes,2,opt,name=field_args,json=fieldArgs,proto3" json:"field_args,omitempty"` +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 *ResolveSubcategoryItemCountRequest) Reset() { - *x = ResolveSubcategoryItemCountRequest{} +func (x *ResolveCategoryTotalProductsResult) Reset() { + *x = ResolveCategoryTotalProductsResult{} mi := &file_product_proto_msgTypes[197] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveSubcategoryItemCountRequest) String() string { +func (x *ResolveCategoryTotalProductsResult) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveSubcategoryItemCountRequest) ProtoMessage() {} +func (*ResolveCategoryTotalProductsResult) ProtoMessage() {} -func (x *ResolveSubcategoryItemCountRequest) ProtoReflect() protoreflect.Message { +func (x *ResolveCategoryTotalProductsResult) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[197] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -9214,46 +9212,39 @@ func (x *ResolveSubcategoryItemCountRequest) ProtoReflect() protoreflect.Message return mi.MessageOf(x) } -// Deprecated: Use ResolveSubcategoryItemCountRequest.ProtoReflect.Descriptor instead. -func (*ResolveSubcategoryItemCountRequest) Descriptor() ([]byte, []int) { +// Deprecated: Use ResolveCategoryTotalProductsResult.ProtoReflect.Descriptor instead. +func (*ResolveCategoryTotalProductsResult) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{197} } -func (x *ResolveSubcategoryItemCountRequest) GetContext() []*ResolveSubcategoryItemCountContext { - if x != nil { - return x.Context - } - return nil -} - -func (x *ResolveSubcategoryItemCountRequest) GetFieldArgs() *ResolveSubcategoryItemCountArgs { +func (x *ResolveCategoryTotalProductsResult) GetTotalProducts() int32 { if x != nil { - return x.FieldArgs + return x.TotalProducts } - return nil + return 0 } -type ResolveSubcategoryItemCountResult struct { - state protoimpl.MessageState `protogen:"open.v1"` - ItemCount int32 `protobuf:"varint,1,opt,name=item_count,json=itemCount,proto3" json:"item_count,omitempty"` +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 *ResolveSubcategoryItemCountResult) Reset() { - *x = ResolveSubcategoryItemCountResult{} +func (x *ResolveCategoryTotalProductsResponse) Reset() { + *x = ResolveCategoryTotalProductsResponse{} mi := &file_product_proto_msgTypes[198] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveSubcategoryItemCountResult) String() string { +func (x *ResolveCategoryTotalProductsResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveSubcategoryItemCountResult) ProtoMessage() {} +func (*ResolveCategoryTotalProductsResponse) ProtoMessage() {} -func (x *ResolveSubcategoryItemCountResult) ProtoReflect() protoreflect.Message { +func (x *ResolveCategoryTotalProductsResponse) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[198] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -9265,39 +9256,40 @@ func (x *ResolveSubcategoryItemCountResult) ProtoReflect() protoreflect.Message return mi.MessageOf(x) } -// Deprecated: Use ResolveSubcategoryItemCountResult.ProtoReflect.Descriptor instead. -func (*ResolveSubcategoryItemCountResult) Descriptor() ([]byte, []int) { +// Deprecated: Use ResolveCategoryTotalProductsResponse.ProtoReflect.Descriptor instead. +func (*ResolveCategoryTotalProductsResponse) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{198} } -func (x *ResolveSubcategoryItemCountResult) GetItemCount() int32 { +func (x *ResolveCategoryTotalProductsResponse) GetResult() []*ResolveCategoryTotalProductsResult { if x != nil { - return x.ItemCount + return x.Result } - return 0 + return nil } -type ResolveSubcategoryItemCountResponse struct { - state protoimpl.MessageState `protogen:"open.v1"` - Result []*ResolveSubcategoryItemCountResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` +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 *ResolveSubcategoryItemCountResponse) Reset() { - *x = ResolveSubcategoryItemCountResponse{} +func (x *ResolveCategoryTopSubcategoryContext) Reset() { + *x = ResolveCategoryTopSubcategoryContext{} mi := &file_product_proto_msgTypes[199] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveSubcategoryItemCountResponse) String() string { +func (x *ResolveCategoryTopSubcategoryContext) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveSubcategoryItemCountResponse) ProtoMessage() {} +func (*ResolveCategoryTopSubcategoryContext) ProtoMessage() {} -func (x *ResolveSubcategoryItemCountResponse) ProtoReflect() protoreflect.Message { +func (x *ResolveCategoryTopSubcategoryContext) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[199] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -9309,39 +9301,47 @@ func (x *ResolveSubcategoryItemCountResponse) ProtoReflect() protoreflect.Messag return mi.MessageOf(x) } -// Deprecated: Use ResolveSubcategoryItemCountResponse.ProtoReflect.Descriptor instead. -func (*ResolveSubcategoryItemCountResponse) Descriptor() ([]byte, []int) { +// Deprecated: Use ResolveCategoryTopSubcategoryContext.ProtoReflect.Descriptor instead. +func (*ResolveCategoryTopSubcategoryContext) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{199} } -func (x *ResolveSubcategoryItemCountResponse) GetResult() []*ResolveSubcategoryItemCountResult { +func (x *ResolveCategoryTopSubcategoryContext) GetId() string { if x != nil { - return x.Result + return x.Id } - return nil + return "" } -type ResolveSubcategoryFeaturedCategoryArgs struct { - state protoimpl.MessageState `protogen:"open.v1"` - IncludeChildren bool `protobuf:"varint,1,opt,name=include_children,json=includeChildren,proto3" json:"include_children,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +func (x *ResolveCategoryTopSubcategoryContext) GetName() string { + if x != nil { + return x.Name + } + return "" } -func (x *ResolveSubcategoryFeaturedCategoryArgs) Reset() { - *x = ResolveSubcategoryFeaturedCategoryArgs{} +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 *ResolveSubcategoryFeaturedCategoryArgs) String() string { +func (x *ResolveCategoryTopSubcategoryRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveSubcategoryFeaturedCategoryArgs) ProtoMessage() {} +func (*ResolveCategoryTopSubcategoryRequest) ProtoMessage() {} -func (x *ResolveSubcategoryFeaturedCategoryArgs) ProtoReflect() protoreflect.Message { +func (x *ResolveCategoryTopSubcategoryRequest) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[200] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -9353,39 +9353,39 @@ func (x *ResolveSubcategoryFeaturedCategoryArgs) ProtoReflect() protoreflect.Mes return mi.MessageOf(x) } -// Deprecated: Use ResolveSubcategoryFeaturedCategoryArgs.ProtoReflect.Descriptor instead. -func (*ResolveSubcategoryFeaturedCategoryArgs) Descriptor() ([]byte, []int) { +// Deprecated: Use ResolveCategoryTopSubcategoryRequest.ProtoReflect.Descriptor instead. +func (*ResolveCategoryTopSubcategoryRequest) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{200} } -func (x *ResolveSubcategoryFeaturedCategoryArgs) GetIncludeChildren() bool { +func (x *ResolveCategoryTopSubcategoryRequest) GetContext() []*ResolveCategoryTopSubcategoryContext { if x != nil { - return x.IncludeChildren + return x.Context } - return false + return nil } -type ResolveSubcategoryFeaturedCategoryContext 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 +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 *ResolveSubcategoryFeaturedCategoryContext) Reset() { - *x = ResolveSubcategoryFeaturedCategoryContext{} +func (x *ResolveCategoryTopSubcategoryResult) Reset() { + *x = ResolveCategoryTopSubcategoryResult{} mi := &file_product_proto_msgTypes[201] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveSubcategoryFeaturedCategoryContext) String() string { +func (x *ResolveCategoryTopSubcategoryResult) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveSubcategoryFeaturedCategoryContext) ProtoMessage() {} +func (*ResolveCategoryTopSubcategoryResult) ProtoMessage() {} -func (x *ResolveSubcategoryFeaturedCategoryContext) ProtoReflect() protoreflect.Message { +func (x *ResolveCategoryTopSubcategoryResult) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[201] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -9397,42 +9397,39 @@ func (x *ResolveSubcategoryFeaturedCategoryContext) ProtoReflect() protoreflect. return mi.MessageOf(x) } -// Deprecated: Use ResolveSubcategoryFeaturedCategoryContext.ProtoReflect.Descriptor instead. -func (*ResolveSubcategoryFeaturedCategoryContext) Descriptor() ([]byte, []int) { +// Deprecated: Use ResolveCategoryTopSubcategoryResult.ProtoReflect.Descriptor instead. +func (*ResolveCategoryTopSubcategoryResult) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{201} } -func (x *ResolveSubcategoryFeaturedCategoryContext) GetId() string { +func (x *ResolveCategoryTopSubcategoryResult) GetTopSubcategory() *Subcategory { if x != nil { - return x.Id + return x.TopSubcategory } - return "" + return nil } -type ResolveSubcategoryFeaturedCategoryRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - // context provides the resolver context for the field featuredCategory of type Subcategory. - Context []*ResolveSubcategoryFeaturedCategoryContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` - // field_args provides the arguments for the resolver field featuredCategory of type Subcategory. - FieldArgs *ResolveSubcategoryFeaturedCategoryArgs `protobuf:"bytes,2,opt,name=field_args,json=fieldArgs,proto3" json:"field_args,omitempty"` +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 *ResolveSubcategoryFeaturedCategoryRequest) Reset() { - *x = ResolveSubcategoryFeaturedCategoryRequest{} +func (x *ResolveCategoryTopSubcategoryResponse) Reset() { + *x = ResolveCategoryTopSubcategoryResponse{} mi := &file_product_proto_msgTypes[202] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveSubcategoryFeaturedCategoryRequest) String() string { +func (x *ResolveCategoryTopSubcategoryResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveSubcategoryFeaturedCategoryRequest) ProtoMessage() {} +func (*ResolveCategoryTopSubcategoryResponse) ProtoMessage() {} -func (x *ResolveSubcategoryFeaturedCategoryRequest) ProtoReflect() protoreflect.Message { +func (x *ResolveCategoryTopSubcategoryResponse) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[202] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -9444,46 +9441,39 @@ func (x *ResolveSubcategoryFeaturedCategoryRequest) ProtoReflect() protoreflect. return mi.MessageOf(x) } -// Deprecated: Use ResolveSubcategoryFeaturedCategoryRequest.ProtoReflect.Descriptor instead. -func (*ResolveSubcategoryFeaturedCategoryRequest) Descriptor() ([]byte, []int) { +// Deprecated: Use ResolveCategoryTopSubcategoryResponse.ProtoReflect.Descriptor instead. +func (*ResolveCategoryTopSubcategoryResponse) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{202} } -func (x *ResolveSubcategoryFeaturedCategoryRequest) GetContext() []*ResolveSubcategoryFeaturedCategoryContext { - if x != nil { - return x.Context - } - return nil -} - -func (x *ResolveSubcategoryFeaturedCategoryRequest) GetFieldArgs() *ResolveSubcategoryFeaturedCategoryArgs { +func (x *ResolveCategoryTopSubcategoryResponse) GetResult() []*ResolveCategoryTopSubcategoryResult { if x != nil { - return x.FieldArgs + return x.Result } return nil } -type ResolveSubcategoryFeaturedCategoryResult struct { - state protoimpl.MessageState `protogen:"open.v1"` - FeaturedCategory *Category `protobuf:"bytes,1,opt,name=featured_category,json=featuredCategory,proto3" json:"featured_category,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +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 *ResolveSubcategoryFeaturedCategoryResult) Reset() { - *x = ResolveSubcategoryFeaturedCategoryResult{} +func (x *ResolveCategoryActiveSubcategoriesContext) Reset() { + *x = ResolveCategoryActiveSubcategoriesContext{} mi := &file_product_proto_msgTypes[203] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveSubcategoryFeaturedCategoryResult) String() string { +func (x *ResolveCategoryActiveSubcategoriesContext) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveSubcategoryFeaturedCategoryResult) ProtoMessage() {} +func (*ResolveCategoryActiveSubcategoriesContext) ProtoMessage() {} -func (x *ResolveSubcategoryFeaturedCategoryResult) ProtoReflect() protoreflect.Message { +func (x *ResolveCategoryActiveSubcategoriesContext) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[203] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -9495,39 +9485,40 @@ func (x *ResolveSubcategoryFeaturedCategoryResult) ProtoReflect() protoreflect.M return mi.MessageOf(x) } -// Deprecated: Use ResolveSubcategoryFeaturedCategoryResult.ProtoReflect.Descriptor instead. -func (*ResolveSubcategoryFeaturedCategoryResult) Descriptor() ([]byte, []int) { +// Deprecated: Use ResolveCategoryActiveSubcategoriesContext.ProtoReflect.Descriptor instead. +func (*ResolveCategoryActiveSubcategoriesContext) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{203} } -func (x *ResolveSubcategoryFeaturedCategoryResult) GetFeaturedCategory() *Category { +func (x *ResolveCategoryActiveSubcategoriesContext) GetId() string { if x != nil { - return x.FeaturedCategory + return x.Id } - return nil + return "" } -type ResolveSubcategoryFeaturedCategoryResponse struct { - state protoimpl.MessageState `protogen:"open.v1"` - Result []*ResolveSubcategoryFeaturedCategoryResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` +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 *ResolveSubcategoryFeaturedCategoryResponse) Reset() { - *x = ResolveSubcategoryFeaturedCategoryResponse{} +func (x *ResolveCategoryActiveSubcategoriesRequest) Reset() { + *x = ResolveCategoryActiveSubcategoriesRequest{} mi := &file_product_proto_msgTypes[204] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveSubcategoryFeaturedCategoryResponse) String() string { +func (x *ResolveCategoryActiveSubcategoriesRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveSubcategoryFeaturedCategoryResponse) ProtoMessage() {} +func (*ResolveCategoryActiveSubcategoriesRequest) ProtoMessage() {} -func (x *ResolveSubcategoryFeaturedCategoryResponse) ProtoReflect() protoreflect.Message { +func (x *ResolveCategoryActiveSubcategoriesRequest) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[204] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -9539,39 +9530,39 @@ func (x *ResolveSubcategoryFeaturedCategoryResponse) ProtoReflect() protoreflect return mi.MessageOf(x) } -// Deprecated: Use ResolveSubcategoryFeaturedCategoryResponse.ProtoReflect.Descriptor instead. -func (*ResolveSubcategoryFeaturedCategoryResponse) Descriptor() ([]byte, []int) { +// Deprecated: Use ResolveCategoryActiveSubcategoriesRequest.ProtoReflect.Descriptor instead. +func (*ResolveCategoryActiveSubcategoriesRequest) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{204} } -func (x *ResolveSubcategoryFeaturedCategoryResponse) GetResult() []*ResolveSubcategoryFeaturedCategoryResult { +func (x *ResolveCategoryActiveSubcategoriesRequest) GetContext() []*ResolveCategoryActiveSubcategoriesContext { if x != nil { - return x.Result + return x.Context } return nil } -type ResolveCategoryMetricsNormalizedScoreArgs struct { - state protoimpl.MessageState `protogen:"open.v1"` - Baseline float64 `protobuf:"fixed64,1,opt,name=baseline,proto3" json:"baseline,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +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 *ResolveCategoryMetricsNormalizedScoreArgs) Reset() { - *x = ResolveCategoryMetricsNormalizedScoreArgs{} +func (x *ResolveCategoryActiveSubcategoriesResult) Reset() { + *x = ResolveCategoryActiveSubcategoriesResult{} mi := &file_product_proto_msgTypes[205] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveCategoryMetricsNormalizedScoreArgs) String() string { +func (x *ResolveCategoryActiveSubcategoriesResult) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveCategoryMetricsNormalizedScoreArgs) ProtoMessage() {} +func (*ResolveCategoryActiveSubcategoriesResult) ProtoMessage() {} -func (x *ResolveCategoryMetricsNormalizedScoreArgs) ProtoReflect() protoreflect.Message { +func (x *ResolveCategoryActiveSubcategoriesResult) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[205] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -9583,41 +9574,39 @@ func (x *ResolveCategoryMetricsNormalizedScoreArgs) ProtoReflect() protoreflect. return mi.MessageOf(x) } -// Deprecated: Use ResolveCategoryMetricsNormalizedScoreArgs.ProtoReflect.Descriptor instead. -func (*ResolveCategoryMetricsNormalizedScoreArgs) Descriptor() ([]byte, []int) { +// Deprecated: Use ResolveCategoryActiveSubcategoriesResult.ProtoReflect.Descriptor instead. +func (*ResolveCategoryActiveSubcategoriesResult) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{205} } -func (x *ResolveCategoryMetricsNormalizedScoreArgs) GetBaseline() float64 { +func (x *ResolveCategoryActiveSubcategoriesResult) GetActiveSubcategories() []*Subcategory { if x != nil { - return x.Baseline + return x.ActiveSubcategories } - return 0 + return nil } -type ResolveCategoryMetricsNormalizedScoreContext struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - MetricType string `protobuf:"bytes,2,opt,name=metric_type,json=metricType,proto3" json:"metric_type,omitempty"` - Value float64 `protobuf:"fixed64,3,opt,name=value,proto3" json:"value,omitempty"` +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 *ResolveCategoryMetricsNormalizedScoreContext) Reset() { - *x = ResolveCategoryMetricsNormalizedScoreContext{} +func (x *ResolveCategoryActiveSubcategoriesResponse) Reset() { + *x = ResolveCategoryActiveSubcategoriesResponse{} mi := &file_product_proto_msgTypes[206] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveCategoryMetricsNormalizedScoreContext) String() string { +func (x *ResolveCategoryActiveSubcategoriesResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveCategoryMetricsNormalizedScoreContext) ProtoMessage() {} +func (*ResolveCategoryActiveSubcategoriesResponse) ProtoMessage() {} -func (x *ResolveCategoryMetricsNormalizedScoreContext) ProtoReflect() protoreflect.Message { +func (x *ResolveCategoryActiveSubcategoriesResponse) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[206] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -9629,56 +9618,39 @@ func (x *ResolveCategoryMetricsNormalizedScoreContext) ProtoReflect() protorefle return mi.MessageOf(x) } -// Deprecated: Use ResolveCategoryMetricsNormalizedScoreContext.ProtoReflect.Descriptor instead. -func (*ResolveCategoryMetricsNormalizedScoreContext) Descriptor() ([]byte, []int) { +// Deprecated: Use ResolveCategoryActiveSubcategoriesResponse.ProtoReflect.Descriptor instead. +func (*ResolveCategoryActiveSubcategoriesResponse) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{206} } -func (x *ResolveCategoryMetricsNormalizedScoreContext) GetId() string { - if x != nil { - return x.Id - } - return "" -} - -func (x *ResolveCategoryMetricsNormalizedScoreContext) GetMetricType() string { - if x != nil { - return x.MetricType - } - return "" -} - -func (x *ResolveCategoryMetricsNormalizedScoreContext) GetValue() float64 { +func (x *ResolveCategoryActiveSubcategoriesResponse) GetResult() []*ResolveCategoryActiveSubcategoriesResult { if x != nil { - return x.Value + return x.Result } - return 0 + return nil } -type ResolveCategoryMetricsNormalizedScoreRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - // context provides the resolver context for the field normalizedScore of type CategoryMetrics. - Context []*ResolveCategoryMetricsNormalizedScoreContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` - // field_args provides the arguments for the resolver field normalizedScore of type CategoryMetrics. - FieldArgs *ResolveCategoryMetricsNormalizedScoreArgs `protobuf:"bytes,2,opt,name=field_args,json=fieldArgs,proto3" json:"field_args,omitempty"` +type ResolveSubcategoryItemCountArgs struct { + state protoimpl.MessageState `protogen:"open.v1"` + Filters *SubcategoryItemFilter `protobuf:"bytes,1,opt,name=filters,proto3" json:"filters,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ResolveCategoryMetricsNormalizedScoreRequest) Reset() { - *x = ResolveCategoryMetricsNormalizedScoreRequest{} +func (x *ResolveSubcategoryItemCountArgs) Reset() { + *x = ResolveSubcategoryItemCountArgs{} mi := &file_product_proto_msgTypes[207] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveCategoryMetricsNormalizedScoreRequest) String() string { +func (x *ResolveSubcategoryItemCountArgs) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveCategoryMetricsNormalizedScoreRequest) ProtoMessage() {} +func (*ResolveSubcategoryItemCountArgs) ProtoMessage() {} -func (x *ResolveCategoryMetricsNormalizedScoreRequest) ProtoReflect() protoreflect.Message { +func (x *ResolveSubcategoryItemCountArgs) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[207] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -9690,46 +9662,39 @@ func (x *ResolveCategoryMetricsNormalizedScoreRequest) ProtoReflect() protorefle return mi.MessageOf(x) } -// Deprecated: Use ResolveCategoryMetricsNormalizedScoreRequest.ProtoReflect.Descriptor instead. -func (*ResolveCategoryMetricsNormalizedScoreRequest) Descriptor() ([]byte, []int) { +// Deprecated: Use ResolveSubcategoryItemCountArgs.ProtoReflect.Descriptor instead. +func (*ResolveSubcategoryItemCountArgs) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{207} } -func (x *ResolveCategoryMetricsNormalizedScoreRequest) GetContext() []*ResolveCategoryMetricsNormalizedScoreContext { - if x != nil { - return x.Context - } - return nil -} - -func (x *ResolveCategoryMetricsNormalizedScoreRequest) GetFieldArgs() *ResolveCategoryMetricsNormalizedScoreArgs { +func (x *ResolveSubcategoryItemCountArgs) GetFilters() *SubcategoryItemFilter { if x != nil { - return x.FieldArgs + return x.Filters } return nil } -type ResolveCategoryMetricsNormalizedScoreResult struct { - state protoimpl.MessageState `protogen:"open.v1"` - NormalizedScore float64 `protobuf:"fixed64,1,opt,name=normalized_score,json=normalizedScore,proto3" json:"normalized_score,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type ResolveSubcategoryItemCountContext 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 *ResolveCategoryMetricsNormalizedScoreResult) Reset() { - *x = ResolveCategoryMetricsNormalizedScoreResult{} +func (x *ResolveSubcategoryItemCountContext) Reset() { + *x = ResolveSubcategoryItemCountContext{} mi := &file_product_proto_msgTypes[208] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveCategoryMetricsNormalizedScoreResult) String() string { +func (x *ResolveSubcategoryItemCountContext) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveCategoryMetricsNormalizedScoreResult) ProtoMessage() {} +func (*ResolveSubcategoryItemCountContext) ProtoMessage() {} -func (x *ResolveCategoryMetricsNormalizedScoreResult) ProtoReflect() protoreflect.Message { +func (x *ResolveSubcategoryItemCountContext) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[208] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -9741,39 +9706,42 @@ func (x *ResolveCategoryMetricsNormalizedScoreResult) ProtoReflect() protoreflec return mi.MessageOf(x) } -// Deprecated: Use ResolveCategoryMetricsNormalizedScoreResult.ProtoReflect.Descriptor instead. -func (*ResolveCategoryMetricsNormalizedScoreResult) Descriptor() ([]byte, []int) { +// Deprecated: Use ResolveSubcategoryItemCountContext.ProtoReflect.Descriptor instead. +func (*ResolveSubcategoryItemCountContext) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{208} } -func (x *ResolveCategoryMetricsNormalizedScoreResult) GetNormalizedScore() float64 { +func (x *ResolveSubcategoryItemCountContext) GetId() string { if x != nil { - return x.NormalizedScore + return x.Id } - return 0 + return "" } -type ResolveCategoryMetricsNormalizedScoreResponse struct { - state protoimpl.MessageState `protogen:"open.v1"` - Result []*ResolveCategoryMetricsNormalizedScoreResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` +type ResolveSubcategoryItemCountRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // context provides the resolver context for the field itemCount of type Subcategory. + Context []*ResolveSubcategoryItemCountContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` + // field_args provides the arguments for the resolver field itemCount of type Subcategory. + FieldArgs *ResolveSubcategoryItemCountArgs `protobuf:"bytes,2,opt,name=field_args,json=fieldArgs,proto3" json:"field_args,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ResolveCategoryMetricsNormalizedScoreResponse) Reset() { - *x = ResolveCategoryMetricsNormalizedScoreResponse{} +func (x *ResolveSubcategoryItemCountRequest) Reset() { + *x = ResolveSubcategoryItemCountRequest{} mi := &file_product_proto_msgTypes[209] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveCategoryMetricsNormalizedScoreResponse) String() string { +func (x *ResolveSubcategoryItemCountRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveCategoryMetricsNormalizedScoreResponse) ProtoMessage() {} +func (*ResolveSubcategoryItemCountRequest) ProtoMessage() {} -func (x *ResolveCategoryMetricsNormalizedScoreResponse) ProtoReflect() protoreflect.Message { +func (x *ResolveSubcategoryItemCountRequest) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[209] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -9785,39 +9753,46 @@ func (x *ResolveCategoryMetricsNormalizedScoreResponse) ProtoReflect() protorefl return mi.MessageOf(x) } -// Deprecated: Use ResolveCategoryMetricsNormalizedScoreResponse.ProtoReflect.Descriptor instead. -func (*ResolveCategoryMetricsNormalizedScoreResponse) Descriptor() ([]byte, []int) { +// Deprecated: Use ResolveSubcategoryItemCountRequest.ProtoReflect.Descriptor instead. +func (*ResolveSubcategoryItemCountRequest) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{209} } -func (x *ResolveCategoryMetricsNormalizedScoreResponse) GetResult() []*ResolveCategoryMetricsNormalizedScoreResult { +func (x *ResolveSubcategoryItemCountRequest) GetContext() []*ResolveSubcategoryItemCountContext { if x != nil { - return x.Result + return x.Context } return nil } -type ResolveCategoryMetricsRelatedCategoryArgs struct { +func (x *ResolveSubcategoryItemCountRequest) GetFieldArgs() *ResolveSubcategoryItemCountArgs { + if x != nil { + return x.FieldArgs + } + return nil +} + +type ResolveSubcategoryItemCountResult struct { state protoimpl.MessageState `protogen:"open.v1"` - Include *wrapperspb.BoolValue `protobuf:"bytes,1,opt,name=include,proto3" json:"include,omitempty"` + ItemCount int32 `protobuf:"varint,1,opt,name=item_count,json=itemCount,proto3" json:"item_count,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ResolveCategoryMetricsRelatedCategoryArgs) Reset() { - *x = ResolveCategoryMetricsRelatedCategoryArgs{} +func (x *ResolveSubcategoryItemCountResult) Reset() { + *x = ResolveSubcategoryItemCountResult{} mi := &file_product_proto_msgTypes[210] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveCategoryMetricsRelatedCategoryArgs) String() string { +func (x *ResolveSubcategoryItemCountResult) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveCategoryMetricsRelatedCategoryArgs) ProtoMessage() {} +func (*ResolveSubcategoryItemCountResult) ProtoMessage() {} -func (x *ResolveCategoryMetricsRelatedCategoryArgs) ProtoReflect() protoreflect.Message { +func (x *ResolveSubcategoryItemCountResult) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[210] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -9829,39 +9804,39 @@ func (x *ResolveCategoryMetricsRelatedCategoryArgs) ProtoReflect() protoreflect. return mi.MessageOf(x) } -// Deprecated: Use ResolveCategoryMetricsRelatedCategoryArgs.ProtoReflect.Descriptor instead. -func (*ResolveCategoryMetricsRelatedCategoryArgs) Descriptor() ([]byte, []int) { +// Deprecated: Use ResolveSubcategoryItemCountResult.ProtoReflect.Descriptor instead. +func (*ResolveSubcategoryItemCountResult) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{210} } -func (x *ResolveCategoryMetricsRelatedCategoryArgs) GetInclude() *wrapperspb.BoolValue { +func (x *ResolveSubcategoryItemCountResult) GetItemCount() int32 { if x != nil { - return x.Include + return x.ItemCount } - return nil + return 0 } -type ResolveCategoryMetricsRelatedCategoryContext struct { - state protoimpl.MessageState `protogen:"open.v1"` - CategoryId string `protobuf:"bytes,1,opt,name=category_id,json=categoryId,proto3" json:"category_id,omitempty"` +type ResolveSubcategoryItemCountResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Result []*ResolveSubcategoryItemCountResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ResolveCategoryMetricsRelatedCategoryContext) Reset() { - *x = ResolveCategoryMetricsRelatedCategoryContext{} +func (x *ResolveSubcategoryItemCountResponse) Reset() { + *x = ResolveSubcategoryItemCountResponse{} mi := &file_product_proto_msgTypes[211] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveCategoryMetricsRelatedCategoryContext) String() string { +func (x *ResolveSubcategoryItemCountResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveCategoryMetricsRelatedCategoryContext) ProtoMessage() {} +func (*ResolveSubcategoryItemCountResponse) ProtoMessage() {} -func (x *ResolveCategoryMetricsRelatedCategoryContext) ProtoReflect() protoreflect.Message { +func (x *ResolveSubcategoryItemCountResponse) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[211] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -9873,42 +9848,39 @@ func (x *ResolveCategoryMetricsRelatedCategoryContext) ProtoReflect() protorefle return mi.MessageOf(x) } -// Deprecated: Use ResolveCategoryMetricsRelatedCategoryContext.ProtoReflect.Descriptor instead. -func (*ResolveCategoryMetricsRelatedCategoryContext) Descriptor() ([]byte, []int) { +// Deprecated: Use ResolveSubcategoryItemCountResponse.ProtoReflect.Descriptor instead. +func (*ResolveSubcategoryItemCountResponse) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{211} } -func (x *ResolveCategoryMetricsRelatedCategoryContext) GetCategoryId() string { +func (x *ResolveSubcategoryItemCountResponse) GetResult() []*ResolveSubcategoryItemCountResult { if x != nil { - return x.CategoryId + return x.Result } - return "" + return nil } -type ResolveCategoryMetricsRelatedCategoryRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - // context provides the resolver context for the field relatedCategory of type CategoryMetrics. - Context []*ResolveCategoryMetricsRelatedCategoryContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` - // field_args provides the arguments for the resolver field relatedCategory of type CategoryMetrics. - FieldArgs *ResolveCategoryMetricsRelatedCategoryArgs `protobuf:"bytes,2,opt,name=field_args,json=fieldArgs,proto3" json:"field_args,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type ResolveSubcategoryFeaturedCategoryArgs struct { + state protoimpl.MessageState `protogen:"open.v1"` + IncludeChildren bool `protobuf:"varint,1,opt,name=include_children,json=includeChildren,proto3" json:"include_children,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *ResolveCategoryMetricsRelatedCategoryRequest) Reset() { - *x = ResolveCategoryMetricsRelatedCategoryRequest{} +func (x *ResolveSubcategoryFeaturedCategoryArgs) Reset() { + *x = ResolveSubcategoryFeaturedCategoryArgs{} mi := &file_product_proto_msgTypes[212] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveCategoryMetricsRelatedCategoryRequest) String() string { +func (x *ResolveSubcategoryFeaturedCategoryArgs) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveCategoryMetricsRelatedCategoryRequest) ProtoMessage() {} +func (*ResolveSubcategoryFeaturedCategoryArgs) ProtoMessage() {} -func (x *ResolveCategoryMetricsRelatedCategoryRequest) ProtoReflect() protoreflect.Message { +func (x *ResolveSubcategoryFeaturedCategoryArgs) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[212] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -9920,46 +9892,39 @@ func (x *ResolveCategoryMetricsRelatedCategoryRequest) ProtoReflect() protorefle return mi.MessageOf(x) } -// Deprecated: Use ResolveCategoryMetricsRelatedCategoryRequest.ProtoReflect.Descriptor instead. -func (*ResolveCategoryMetricsRelatedCategoryRequest) Descriptor() ([]byte, []int) { +// Deprecated: Use ResolveSubcategoryFeaturedCategoryArgs.ProtoReflect.Descriptor instead. +func (*ResolveSubcategoryFeaturedCategoryArgs) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{212} } -func (x *ResolveCategoryMetricsRelatedCategoryRequest) GetContext() []*ResolveCategoryMetricsRelatedCategoryContext { - if x != nil { - return x.Context - } - return nil -} - -func (x *ResolveCategoryMetricsRelatedCategoryRequest) GetFieldArgs() *ResolveCategoryMetricsRelatedCategoryArgs { +func (x *ResolveSubcategoryFeaturedCategoryArgs) GetIncludeChildren() bool { if x != nil { - return x.FieldArgs + return x.IncludeChildren } - return nil + return false } -type ResolveCategoryMetricsRelatedCategoryResult struct { - state protoimpl.MessageState `protogen:"open.v1"` - RelatedCategory *Category `protobuf:"bytes,1,opt,name=related_category,json=relatedCategory,proto3" json:"related_category,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type ResolveSubcategoryFeaturedCategoryContext 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 *ResolveCategoryMetricsRelatedCategoryResult) Reset() { - *x = ResolveCategoryMetricsRelatedCategoryResult{} +func (x *ResolveSubcategoryFeaturedCategoryContext) Reset() { + *x = ResolveSubcategoryFeaturedCategoryContext{} mi := &file_product_proto_msgTypes[213] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveCategoryMetricsRelatedCategoryResult) String() string { +func (x *ResolveSubcategoryFeaturedCategoryContext) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveCategoryMetricsRelatedCategoryResult) ProtoMessage() {} +func (*ResolveSubcategoryFeaturedCategoryContext) ProtoMessage() {} -func (x *ResolveCategoryMetricsRelatedCategoryResult) ProtoReflect() protoreflect.Message { +func (x *ResolveSubcategoryFeaturedCategoryContext) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[213] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -9971,39 +9936,42 @@ func (x *ResolveCategoryMetricsRelatedCategoryResult) ProtoReflect() protoreflec return mi.MessageOf(x) } -// Deprecated: Use ResolveCategoryMetricsRelatedCategoryResult.ProtoReflect.Descriptor instead. -func (*ResolveCategoryMetricsRelatedCategoryResult) Descriptor() ([]byte, []int) { +// Deprecated: Use ResolveSubcategoryFeaturedCategoryContext.ProtoReflect.Descriptor instead. +func (*ResolveSubcategoryFeaturedCategoryContext) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{213} } -func (x *ResolveCategoryMetricsRelatedCategoryResult) GetRelatedCategory() *Category { +func (x *ResolveSubcategoryFeaturedCategoryContext) GetId() string { if x != nil { - return x.RelatedCategory + return x.Id } - return nil + return "" } -type ResolveCategoryMetricsRelatedCategoryResponse struct { - state protoimpl.MessageState `protogen:"open.v1"` - Result []*ResolveCategoryMetricsRelatedCategoryResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` +type ResolveSubcategoryFeaturedCategoryRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // context provides the resolver context for the field featuredCategory of type Subcategory. + Context []*ResolveSubcategoryFeaturedCategoryContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` + // field_args provides the arguments for the resolver field featuredCategory of type Subcategory. + FieldArgs *ResolveSubcategoryFeaturedCategoryArgs `protobuf:"bytes,2,opt,name=field_args,json=fieldArgs,proto3" json:"field_args,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ResolveCategoryMetricsRelatedCategoryResponse) Reset() { - *x = ResolveCategoryMetricsRelatedCategoryResponse{} +func (x *ResolveSubcategoryFeaturedCategoryRequest) Reset() { + *x = ResolveSubcategoryFeaturedCategoryRequest{} mi := &file_product_proto_msgTypes[214] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveCategoryMetricsRelatedCategoryResponse) String() string { +func (x *ResolveSubcategoryFeaturedCategoryRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveCategoryMetricsRelatedCategoryResponse) ProtoMessage() {} +func (*ResolveSubcategoryFeaturedCategoryRequest) ProtoMessage() {} -func (x *ResolveCategoryMetricsRelatedCategoryResponse) ProtoReflect() protoreflect.Message { +func (x *ResolveSubcategoryFeaturedCategoryRequest) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[214] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -10015,39 +9983,46 @@ func (x *ResolveCategoryMetricsRelatedCategoryResponse) ProtoReflect() protorefl return mi.MessageOf(x) } -// Deprecated: Use ResolveCategoryMetricsRelatedCategoryResponse.ProtoReflect.Descriptor instead. -func (*ResolveCategoryMetricsRelatedCategoryResponse) Descriptor() ([]byte, []int) { +// Deprecated: Use ResolveSubcategoryFeaturedCategoryRequest.ProtoReflect.Descriptor instead. +func (*ResolveSubcategoryFeaturedCategoryRequest) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{214} } -func (x *ResolveCategoryMetricsRelatedCategoryResponse) GetResult() []*ResolveCategoryMetricsRelatedCategoryResult { +func (x *ResolveSubcategoryFeaturedCategoryRequest) GetContext() []*ResolveSubcategoryFeaturedCategoryContext { if x != nil { - return x.Result + return x.Context } 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"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +func (x *ResolveSubcategoryFeaturedCategoryRequest) GetFieldArgs() *ResolveSubcategoryFeaturedCategoryArgs { + if x != nil { + return x.FieldArgs + } + return nil } -func (x *ResolveTestContainerDetailsArgs) Reset() { - *x = ResolveTestContainerDetailsArgs{} +type ResolveSubcategoryFeaturedCategoryResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + FeaturedCategory *Category `protobuf:"bytes,1,opt,name=featured_category,json=featuredCategory,proto3" json:"featured_category,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveSubcategoryFeaturedCategoryResult) Reset() { + *x = ResolveSubcategoryFeaturedCategoryResult{} mi := &file_product_proto_msgTypes[215] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveTestContainerDetailsArgs) String() string { +func (x *ResolveSubcategoryFeaturedCategoryResult) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveTestContainerDetailsArgs) ProtoMessage() {} +func (*ResolveSubcategoryFeaturedCategoryResult) ProtoMessage() {} -func (x *ResolveTestContainerDetailsArgs) ProtoReflect() protoreflect.Message { +func (x *ResolveSubcategoryFeaturedCategoryResult) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[215] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -10059,40 +10034,39 @@ func (x *ResolveTestContainerDetailsArgs) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ResolveTestContainerDetailsArgs.ProtoReflect.Descriptor instead. -func (*ResolveTestContainerDetailsArgs) Descriptor() ([]byte, []int) { +// Deprecated: Use ResolveSubcategoryFeaturedCategoryResult.ProtoReflect.Descriptor instead. +func (*ResolveSubcategoryFeaturedCategoryResult) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{215} } -func (x *ResolveTestContainerDetailsArgs) GetIncludeExtended() bool { +func (x *ResolveSubcategoryFeaturedCategoryResult) GetFeaturedCategory() *Category { if x != nil { - return x.IncludeExtended + return x.FeaturedCategory } - return false + return nil } -type ResolveTestContainerDetailsContext struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` +type 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 *ResolveTestContainerDetailsContext) Reset() { - *x = ResolveTestContainerDetailsContext{} +func (x *ResolveSubcategoryFeaturedCategoryResponse) Reset() { + *x = ResolveSubcategoryFeaturedCategoryResponse{} mi := &file_product_proto_msgTypes[216] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveTestContainerDetailsContext) String() string { +func (x *ResolveSubcategoryFeaturedCategoryResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveTestContainerDetailsContext) ProtoMessage() {} +func (*ResolveSubcategoryFeaturedCategoryResponse) ProtoMessage() {} -func (x *ResolveTestContainerDetailsContext) ProtoReflect() protoreflect.Message { +func (x *ResolveSubcategoryFeaturedCategoryResponse) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[216] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -10104,49 +10078,39 @@ func (x *ResolveTestContainerDetailsContext) ProtoReflect() protoreflect.Message return mi.MessageOf(x) } -// Deprecated: Use ResolveTestContainerDetailsContext.ProtoReflect.Descriptor instead. -func (*ResolveTestContainerDetailsContext) Descriptor() ([]byte, []int) { +// Deprecated: Use ResolveSubcategoryFeaturedCategoryResponse.ProtoReflect.Descriptor instead. +func (*ResolveSubcategoryFeaturedCategoryResponse) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{216} } -func (x *ResolveTestContainerDetailsContext) GetId() string { - if x != nil { - return x.Id - } - return "" -} - -func (x *ResolveTestContainerDetailsContext) GetName() string { +func (x *ResolveSubcategoryFeaturedCategoryResponse) GetResult() []*ResolveSubcategoryFeaturedCategoryResult { if x != nil { - return x.Name + return x.Result } - return "" + return nil } -type ResolveTestContainerDetailsRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - // context provides the resolver context for the field details of type TestContainer. - Context []*ResolveTestContainerDetailsContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` - // field_args provides the arguments for the resolver field details of type TestContainer. - FieldArgs *ResolveTestContainerDetailsArgs `protobuf:"bytes,2,opt,name=field_args,json=fieldArgs,proto3" json:"field_args,omitempty"` +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 *ResolveTestContainerDetailsRequest) Reset() { - *x = ResolveTestContainerDetailsRequest{} +func (x *ResolveSubcategoryParentCategoryContext) Reset() { + *x = ResolveSubcategoryParentCategoryContext{} mi := &file_product_proto_msgTypes[217] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveTestContainerDetailsRequest) String() string { +func (x *ResolveSubcategoryParentCategoryContext) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveTestContainerDetailsRequest) ProtoMessage() {} +func (*ResolveSubcategoryParentCategoryContext) ProtoMessage() {} -func (x *ResolveTestContainerDetailsRequest) ProtoReflect() protoreflect.Message { +func (x *ResolveSubcategoryParentCategoryContext) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[217] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -10158,46 +10122,40 @@ func (x *ResolveTestContainerDetailsRequest) ProtoReflect() protoreflect.Message return mi.MessageOf(x) } -// Deprecated: Use ResolveTestContainerDetailsRequest.ProtoReflect.Descriptor instead. -func (*ResolveTestContainerDetailsRequest) Descriptor() ([]byte, []int) { +// Deprecated: Use ResolveSubcategoryParentCategoryContext.ProtoReflect.Descriptor instead. +func (*ResolveSubcategoryParentCategoryContext) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{217} } -func (x *ResolveTestContainerDetailsRequest) GetContext() []*ResolveTestContainerDetailsContext { - if x != nil { - return x.Context - } - return nil -} - -func (x *ResolveTestContainerDetailsRequest) GetFieldArgs() *ResolveTestContainerDetailsArgs { +func (x *ResolveSubcategoryParentCategoryContext) GetId() string { if x != nil { - return x.FieldArgs + return x.Id } - return nil + return "" } -type ResolveTestContainerDetailsResult struct { - state protoimpl.MessageState `protogen:"open.v1"` - Details *TestDetails `protobuf:"bytes,1,opt,name=details,proto3" json:"details,omitempty"` +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 *ResolveTestContainerDetailsResult) Reset() { - *x = ResolveTestContainerDetailsResult{} +func (x *ResolveSubcategoryParentCategoryRequest) Reset() { + *x = ResolveSubcategoryParentCategoryRequest{} mi := &file_product_proto_msgTypes[218] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveTestContainerDetailsResult) String() string { +func (x *ResolveSubcategoryParentCategoryRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveTestContainerDetailsResult) ProtoMessage() {} +func (*ResolveSubcategoryParentCategoryRequest) ProtoMessage() {} -func (x *ResolveTestContainerDetailsResult) ProtoReflect() protoreflect.Message { +func (x *ResolveSubcategoryParentCategoryRequest) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[218] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -10209,39 +10167,39 @@ func (x *ResolveTestContainerDetailsResult) ProtoReflect() protoreflect.Message return mi.MessageOf(x) } -// Deprecated: Use ResolveTestContainerDetailsResult.ProtoReflect.Descriptor instead. -func (*ResolveTestContainerDetailsResult) Descriptor() ([]byte, []int) { +// Deprecated: Use ResolveSubcategoryParentCategoryRequest.ProtoReflect.Descriptor instead. +func (*ResolveSubcategoryParentCategoryRequest) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{218} } -func (x *ResolveTestContainerDetailsResult) GetDetails() *TestDetails { +func (x *ResolveSubcategoryParentCategoryRequest) GetContext() []*ResolveSubcategoryParentCategoryContext { if x != nil { - return x.Details + return x.Context } return nil } -type ResolveTestContainerDetailsResponse struct { - state protoimpl.MessageState `protogen:"open.v1"` - Result []*ResolveTestContainerDetailsResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +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 *ResolveTestContainerDetailsResponse) Reset() { - *x = ResolveTestContainerDetailsResponse{} +func (x *ResolveSubcategoryParentCategoryResult) Reset() { + *x = ResolveSubcategoryParentCategoryResult{} mi := &file_product_proto_msgTypes[219] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveTestContainerDetailsResponse) String() string { +func (x *ResolveSubcategoryParentCategoryResult) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveTestContainerDetailsResponse) ProtoMessage() {} +func (*ResolveSubcategoryParentCategoryResult) ProtoMessage() {} -func (x *ResolveTestContainerDetailsResponse) ProtoReflect() protoreflect.Message { +func (x *ResolveSubcategoryParentCategoryResult) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[219] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -10253,40 +10211,39 @@ func (x *ResolveTestContainerDetailsResponse) ProtoReflect() protoreflect.Messag return mi.MessageOf(x) } -// Deprecated: Use ResolveTestContainerDetailsResponse.ProtoReflect.Descriptor instead. -func (*ResolveTestContainerDetailsResponse) Descriptor() ([]byte, []int) { +// Deprecated: Use ResolveSubcategoryParentCategoryResult.ProtoReflect.Descriptor instead. +func (*ResolveSubcategoryParentCategoryResult) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{219} } -func (x *ResolveTestContainerDetailsResponse) GetResult() []*ResolveTestContainerDetailsResult { +func (x *ResolveSubcategoryParentCategoryResult) GetParentCategory() *Category { if x != nil { - return x.Result + return x.ParentCategory } return nil } -type RequireStorageStockHealthScoreByIdRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - // RequireStorageStockHealthScoreByIdContext provides the context for the required fields method RequireStorageStockHealthScoreById. - Context []*RequireStorageStockHealthScoreByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,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 *RequireStorageStockHealthScoreByIdRequest) Reset() { - *x = RequireStorageStockHealthScoreByIdRequest{} +func (x *ResolveSubcategoryParentCategoryResponse) Reset() { + *x = ResolveSubcategoryParentCategoryResponse{} mi := &file_product_proto_msgTypes[220] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageStockHealthScoreByIdRequest) String() string { +func (x *ResolveSubcategoryParentCategoryResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageStockHealthScoreByIdRequest) ProtoMessage() {} +func (*ResolveSubcategoryParentCategoryResponse) ProtoMessage() {} -func (x *RequireStorageStockHealthScoreByIdRequest) ProtoReflect() protoreflect.Message { +func (x *ResolveSubcategoryParentCategoryResponse) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[220] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -10298,40 +10255,39 @@ func (x *RequireStorageStockHealthScoreByIdRequest) ProtoReflect() protoreflect. return mi.MessageOf(x) } -// Deprecated: Use RequireStorageStockHealthScoreByIdRequest.ProtoReflect.Descriptor instead. -func (*RequireStorageStockHealthScoreByIdRequest) Descriptor() ([]byte, []int) { +// Deprecated: Use ResolveSubcategoryParentCategoryResponse.ProtoReflect.Descriptor instead. +func (*ResolveSubcategoryParentCategoryResponse) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{220} } -func (x *RequireStorageStockHealthScoreByIdRequest) GetContext() []*RequireStorageStockHealthScoreByIdContext { +func (x *ResolveSubcategoryParentCategoryResponse) GetResult() []*ResolveSubcategoryParentCategoryResult { if x != nil { - return x.Context + return x.Result } return nil } -type RequireStorageStockHealthScoreByIdContext struct { - state protoimpl.MessageState `protogen:"open.v1"` - Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` - Fields *RequireStorageStockHealthScoreByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` +type ResolveCategoryMetricsNormalizedScoreArgs struct { + state protoimpl.MessageState `protogen:"open.v1"` + Baseline float64 `protobuf:"fixed64,1,opt,name=baseline,proto3" json:"baseline,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageStockHealthScoreByIdContext) Reset() { - *x = RequireStorageStockHealthScoreByIdContext{} +func (x *ResolveCategoryMetricsNormalizedScoreArgs) Reset() { + *x = ResolveCategoryMetricsNormalizedScoreArgs{} mi := &file_product_proto_msgTypes[221] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageStockHealthScoreByIdContext) String() string { +func (x *ResolveCategoryMetricsNormalizedScoreArgs) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageStockHealthScoreByIdContext) ProtoMessage() {} +func (*ResolveCategoryMetricsNormalizedScoreArgs) ProtoMessage() {} -func (x *RequireStorageStockHealthScoreByIdContext) ProtoReflect() protoreflect.Message { +func (x *ResolveCategoryMetricsNormalizedScoreArgs) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[221] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -10343,47 +10299,41 @@ func (x *RequireStorageStockHealthScoreByIdContext) ProtoReflect() protoreflect. return mi.MessageOf(x) } -// Deprecated: Use RequireStorageStockHealthScoreByIdContext.ProtoReflect.Descriptor instead. -func (*RequireStorageStockHealthScoreByIdContext) Descriptor() ([]byte, []int) { +// Deprecated: Use ResolveCategoryMetricsNormalizedScoreArgs.ProtoReflect.Descriptor instead. +func (*ResolveCategoryMetricsNormalizedScoreArgs) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{221} } -func (x *RequireStorageStockHealthScoreByIdContext) GetKey() *LookupStorageByIdRequestKey { - if x != nil { - return x.Key - } - return nil -} - -func (x *RequireStorageStockHealthScoreByIdContext) GetFields() *RequireStorageStockHealthScoreByIdFields { +func (x *ResolveCategoryMetricsNormalizedScoreArgs) GetBaseline() float64 { if x != nil { - return x.Fields + return x.Baseline } - return nil + return 0 } -type RequireStorageStockHealthScoreByIdResponse struct { - state protoimpl.MessageState `protogen:"open.v1"` - // RequireStorageStockHealthScoreByIdResult provides the result for the required fields method RequireStorageStockHealthScoreById. - Result []*RequireStorageStockHealthScoreByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` +type ResolveCategoryMetricsNormalizedScoreContext struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + MetricType string `protobuf:"bytes,2,opt,name=metric_type,json=metricType,proto3" json:"metric_type,omitempty"` + Value float64 `protobuf:"fixed64,3,opt,name=value,proto3" json:"value,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageStockHealthScoreByIdResponse) Reset() { - *x = RequireStorageStockHealthScoreByIdResponse{} +func (x *ResolveCategoryMetricsNormalizedScoreContext) Reset() { + *x = ResolveCategoryMetricsNormalizedScoreContext{} mi := &file_product_proto_msgTypes[222] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageStockHealthScoreByIdResponse) String() string { +func (x *ResolveCategoryMetricsNormalizedScoreContext) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageStockHealthScoreByIdResponse) ProtoMessage() {} +func (*ResolveCategoryMetricsNormalizedScoreContext) ProtoMessage() {} -func (x *RequireStorageStockHealthScoreByIdResponse) ProtoReflect() protoreflect.Message { +func (x *ResolveCategoryMetricsNormalizedScoreContext) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[222] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -10395,39 +10345,56 @@ func (x *RequireStorageStockHealthScoreByIdResponse) ProtoReflect() protoreflect return mi.MessageOf(x) } -// Deprecated: Use RequireStorageStockHealthScoreByIdResponse.ProtoReflect.Descriptor instead. -func (*RequireStorageStockHealthScoreByIdResponse) Descriptor() ([]byte, []int) { +// Deprecated: Use ResolveCategoryMetricsNormalizedScoreContext.ProtoReflect.Descriptor instead. +func (*ResolveCategoryMetricsNormalizedScoreContext) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{222} } -func (x *RequireStorageStockHealthScoreByIdResponse) GetResult() []*RequireStorageStockHealthScoreByIdResult { +func (x *ResolveCategoryMetricsNormalizedScoreContext) GetId() string { if x != nil { - return x.Result + return x.Id } - return nil + return "" } -type RequireStorageStockHealthScoreByIdResult struct { - state protoimpl.MessageState `protogen:"open.v1"` - StockHealthScore float64 `protobuf:"fixed64,1,opt,name=stock_health_score,json=stockHealthScore,proto3" json:"stock_health_score,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +func (x *ResolveCategoryMetricsNormalizedScoreContext) GetMetricType() string { + if x != nil { + return x.MetricType + } + return "" } -func (x *RequireStorageStockHealthScoreByIdResult) Reset() { - *x = RequireStorageStockHealthScoreByIdResult{} +func (x *ResolveCategoryMetricsNormalizedScoreContext) GetValue() float64 { + if x != nil { + return x.Value + } + return 0 +} + +type ResolveCategoryMetricsNormalizedScoreRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // context provides the resolver context for the field normalizedScore of type CategoryMetrics. + Context []*ResolveCategoryMetricsNormalizedScoreContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` + // field_args provides the arguments for the resolver field normalizedScore of type CategoryMetrics. + FieldArgs *ResolveCategoryMetricsNormalizedScoreArgs `protobuf:"bytes,2,opt,name=field_args,json=fieldArgs,proto3" json:"field_args,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryMetricsNormalizedScoreRequest) Reset() { + *x = ResolveCategoryMetricsNormalizedScoreRequest{} mi := &file_product_proto_msgTypes[223] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageStockHealthScoreByIdResult) String() string { +func (x *ResolveCategoryMetricsNormalizedScoreRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageStockHealthScoreByIdResult) ProtoMessage() {} +func (*ResolveCategoryMetricsNormalizedScoreRequest) ProtoMessage() {} -func (x *RequireStorageStockHealthScoreByIdResult) ProtoReflect() protoreflect.Message { +func (x *ResolveCategoryMetricsNormalizedScoreRequest) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[223] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -10439,40 +10406,46 @@ func (x *RequireStorageStockHealthScoreByIdResult) ProtoReflect() protoreflect.M return mi.MessageOf(x) } -// Deprecated: Use RequireStorageStockHealthScoreByIdResult.ProtoReflect.Descriptor instead. -func (*RequireStorageStockHealthScoreByIdResult) Descriptor() ([]byte, []int) { +// Deprecated: Use ResolveCategoryMetricsNormalizedScoreRequest.ProtoReflect.Descriptor instead. +func (*ResolveCategoryMetricsNormalizedScoreRequest) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{223} } -func (x *RequireStorageStockHealthScoreByIdResult) GetStockHealthScore() float64 { +func (x *ResolveCategoryMetricsNormalizedScoreRequest) GetContext() []*ResolveCategoryMetricsNormalizedScoreContext { if x != nil { - return x.StockHealthScore + return x.Context } - return 0 + return nil } -type RequireStorageStockHealthScoreByIdFields struct { - state protoimpl.MessageState `protogen:"open.v1"` - ItemCount int32 `protobuf:"varint,1,opt,name=item_count,json=itemCount,proto3" json:"item_count,omitempty"` - RestockData *RequireStorageStockHealthScoreByIdFields_RestockData `protobuf:"bytes,2,opt,name=restock_data,json=restockData,proto3" json:"restock_data,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +func (x *ResolveCategoryMetricsNormalizedScoreRequest) GetFieldArgs() *ResolveCategoryMetricsNormalizedScoreArgs { + if x != nil { + return x.FieldArgs + } + return nil } -func (x *RequireStorageStockHealthScoreByIdFields) Reset() { - *x = RequireStorageStockHealthScoreByIdFields{} +type ResolveCategoryMetricsNormalizedScoreResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + NormalizedScore float64 `protobuf:"fixed64,1,opt,name=normalized_score,json=normalizedScore,proto3" json:"normalized_score,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryMetricsNormalizedScoreResult) Reset() { + *x = ResolveCategoryMetricsNormalizedScoreResult{} mi := &file_product_proto_msgTypes[224] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageStockHealthScoreByIdFields) String() string { +func (x *ResolveCategoryMetricsNormalizedScoreResult) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageStockHealthScoreByIdFields) ProtoMessage() {} +func (*ResolveCategoryMetricsNormalizedScoreResult) ProtoMessage() {} -func (x *RequireStorageStockHealthScoreByIdFields) ProtoReflect() protoreflect.Message { +func (x *ResolveCategoryMetricsNormalizedScoreResult) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[224] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -10484,47 +10457,39 @@ func (x *RequireStorageStockHealthScoreByIdFields) ProtoReflect() protoreflect.M return mi.MessageOf(x) } -// Deprecated: Use RequireStorageStockHealthScoreByIdFields.ProtoReflect.Descriptor instead. -func (*RequireStorageStockHealthScoreByIdFields) Descriptor() ([]byte, []int) { +// Deprecated: Use ResolveCategoryMetricsNormalizedScoreResult.ProtoReflect.Descriptor instead. +func (*ResolveCategoryMetricsNormalizedScoreResult) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{224} } -func (x *RequireStorageStockHealthScoreByIdFields) GetItemCount() int32 { +func (x *ResolveCategoryMetricsNormalizedScoreResult) GetNormalizedScore() float64 { if x != nil { - return x.ItemCount + return x.NormalizedScore } return 0 } -func (x *RequireStorageStockHealthScoreByIdFields) GetRestockData() *RequireStorageStockHealthScoreByIdFields_RestockData { - if x != nil { - return x.RestockData - } - return nil -} - -type RequireStorageTagSummaryByIdRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - // RequireStorageTagSummaryByIdContext provides the context for the required fields method RequireStorageTagSummaryById. - Context []*RequireStorageTagSummaryByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` +type ResolveCategoryMetricsNormalizedScoreResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Result []*ResolveCategoryMetricsNormalizedScoreResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageTagSummaryByIdRequest) Reset() { - *x = RequireStorageTagSummaryByIdRequest{} +func (x *ResolveCategoryMetricsNormalizedScoreResponse) Reset() { + *x = ResolveCategoryMetricsNormalizedScoreResponse{} mi := &file_product_proto_msgTypes[225] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageTagSummaryByIdRequest) String() string { +func (x *ResolveCategoryMetricsNormalizedScoreResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageTagSummaryByIdRequest) ProtoMessage() {} +func (*ResolveCategoryMetricsNormalizedScoreResponse) ProtoMessage() {} -func (x *RequireStorageTagSummaryByIdRequest) ProtoReflect() protoreflect.Message { +func (x *ResolveCategoryMetricsNormalizedScoreResponse) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[225] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -10536,40 +10501,39 @@ func (x *RequireStorageTagSummaryByIdRequest) ProtoReflect() protoreflect.Messag return mi.MessageOf(x) } -// Deprecated: Use RequireStorageTagSummaryByIdRequest.ProtoReflect.Descriptor instead. -func (*RequireStorageTagSummaryByIdRequest) Descriptor() ([]byte, []int) { +// Deprecated: Use ResolveCategoryMetricsNormalizedScoreResponse.ProtoReflect.Descriptor instead. +func (*ResolveCategoryMetricsNormalizedScoreResponse) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{225} } -func (x *RequireStorageTagSummaryByIdRequest) GetContext() []*RequireStorageTagSummaryByIdContext { +func (x *ResolveCategoryMetricsNormalizedScoreResponse) GetResult() []*ResolveCategoryMetricsNormalizedScoreResult { if x != nil { - return x.Context + return x.Result } return nil } -type RequireStorageTagSummaryByIdContext struct { - state protoimpl.MessageState `protogen:"open.v1"` - Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` - Fields *RequireStorageTagSummaryByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` +type ResolveCategoryMetricsRelatedCategoryArgs struct { + state protoimpl.MessageState `protogen:"open.v1"` + Include *wrapperspb.BoolValue `protobuf:"bytes,1,opt,name=include,proto3" json:"include,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageTagSummaryByIdContext) Reset() { - *x = RequireStorageTagSummaryByIdContext{} +func (x *ResolveCategoryMetricsRelatedCategoryArgs) Reset() { + *x = ResolveCategoryMetricsRelatedCategoryArgs{} mi := &file_product_proto_msgTypes[226] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageTagSummaryByIdContext) String() string { +func (x *ResolveCategoryMetricsRelatedCategoryArgs) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageTagSummaryByIdContext) ProtoMessage() {} +func (*ResolveCategoryMetricsRelatedCategoryArgs) ProtoMessage() {} -func (x *RequireStorageTagSummaryByIdContext) ProtoReflect() protoreflect.Message { +func (x *ResolveCategoryMetricsRelatedCategoryArgs) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[226] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -10581,47 +10545,39 @@ func (x *RequireStorageTagSummaryByIdContext) ProtoReflect() protoreflect.Messag return mi.MessageOf(x) } -// Deprecated: Use RequireStorageTagSummaryByIdContext.ProtoReflect.Descriptor instead. -func (*RequireStorageTagSummaryByIdContext) Descriptor() ([]byte, []int) { +// Deprecated: Use ResolveCategoryMetricsRelatedCategoryArgs.ProtoReflect.Descriptor instead. +func (*ResolveCategoryMetricsRelatedCategoryArgs) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{226} } -func (x *RequireStorageTagSummaryByIdContext) GetKey() *LookupStorageByIdRequestKey { - if x != nil { - return x.Key - } - return nil -} - -func (x *RequireStorageTagSummaryByIdContext) GetFields() *RequireStorageTagSummaryByIdFields { +func (x *ResolveCategoryMetricsRelatedCategoryArgs) GetInclude() *wrapperspb.BoolValue { if x != nil { - return x.Fields + return x.Include } return nil } -type RequireStorageTagSummaryByIdResponse struct { - state protoimpl.MessageState `protogen:"open.v1"` - // RequireStorageTagSummaryByIdResult provides the result for the required fields method RequireStorageTagSummaryById. - Result []*RequireStorageTagSummaryByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` +type ResolveCategoryMetricsRelatedCategoryContext struct { + state protoimpl.MessageState `protogen:"open.v1"` + CategoryId string `protobuf:"bytes,1,opt,name=category_id,json=categoryId,proto3" json:"category_id,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageTagSummaryByIdResponse) Reset() { - *x = RequireStorageTagSummaryByIdResponse{} +func (x *ResolveCategoryMetricsRelatedCategoryContext) Reset() { + *x = ResolveCategoryMetricsRelatedCategoryContext{} mi := &file_product_proto_msgTypes[227] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageTagSummaryByIdResponse) String() string { +func (x *ResolveCategoryMetricsRelatedCategoryContext) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageTagSummaryByIdResponse) ProtoMessage() {} +func (*ResolveCategoryMetricsRelatedCategoryContext) ProtoMessage() {} -func (x *RequireStorageTagSummaryByIdResponse) ProtoReflect() protoreflect.Message { +func (x *ResolveCategoryMetricsRelatedCategoryContext) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[227] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -10633,39 +10589,42 @@ func (x *RequireStorageTagSummaryByIdResponse) ProtoReflect() protoreflect.Messa return mi.MessageOf(x) } -// Deprecated: Use RequireStorageTagSummaryByIdResponse.ProtoReflect.Descriptor instead. -func (*RequireStorageTagSummaryByIdResponse) Descriptor() ([]byte, []int) { +// Deprecated: Use ResolveCategoryMetricsRelatedCategoryContext.ProtoReflect.Descriptor instead. +func (*ResolveCategoryMetricsRelatedCategoryContext) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{227} } -func (x *RequireStorageTagSummaryByIdResponse) GetResult() []*RequireStorageTagSummaryByIdResult { +func (x *ResolveCategoryMetricsRelatedCategoryContext) GetCategoryId() string { if x != nil { - return x.Result + return x.CategoryId } - return nil + return "" } -type RequireStorageTagSummaryByIdResult struct { - state protoimpl.MessageState `protogen:"open.v1"` - TagSummary string `protobuf:"bytes,1,opt,name=tag_summary,json=tagSummary,proto3" json:"tag_summary,omitempty"` +type ResolveCategoryMetricsRelatedCategoryRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // context provides the resolver context for the field relatedCategory of type CategoryMetrics. + Context []*ResolveCategoryMetricsRelatedCategoryContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` + // field_args provides the arguments for the resolver field relatedCategory of type CategoryMetrics. + FieldArgs *ResolveCategoryMetricsRelatedCategoryArgs `protobuf:"bytes,2,opt,name=field_args,json=fieldArgs,proto3" json:"field_args,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageTagSummaryByIdResult) Reset() { - *x = RequireStorageTagSummaryByIdResult{} +func (x *ResolveCategoryMetricsRelatedCategoryRequest) Reset() { + *x = ResolveCategoryMetricsRelatedCategoryRequest{} mi := &file_product_proto_msgTypes[228] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageTagSummaryByIdResult) String() string { +func (x *ResolveCategoryMetricsRelatedCategoryRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageTagSummaryByIdResult) ProtoMessage() {} +func (*ResolveCategoryMetricsRelatedCategoryRequest) ProtoMessage() {} -func (x *RequireStorageTagSummaryByIdResult) ProtoReflect() protoreflect.Message { +func (x *ResolveCategoryMetricsRelatedCategoryRequest) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[228] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -10677,39 +10636,46 @@ func (x *RequireStorageTagSummaryByIdResult) ProtoReflect() protoreflect.Message return mi.MessageOf(x) } -// Deprecated: Use RequireStorageTagSummaryByIdResult.ProtoReflect.Descriptor instead. -func (*RequireStorageTagSummaryByIdResult) Descriptor() ([]byte, []int) { +// Deprecated: Use ResolveCategoryMetricsRelatedCategoryRequest.ProtoReflect.Descriptor instead. +func (*ResolveCategoryMetricsRelatedCategoryRequest) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{228} } -func (x *RequireStorageTagSummaryByIdResult) GetTagSummary() string { +func (x *ResolveCategoryMetricsRelatedCategoryRequest) GetContext() []*ResolveCategoryMetricsRelatedCategoryContext { if x != nil { - return x.TagSummary + return x.Context } - return "" + return nil } -type RequireStorageTagSummaryByIdFields struct { - state protoimpl.MessageState `protogen:"open.v1"` - Tags []string `protobuf:"bytes,1,rep,name=tags,proto3" json:"tags,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +func (x *ResolveCategoryMetricsRelatedCategoryRequest) GetFieldArgs() *ResolveCategoryMetricsRelatedCategoryArgs { + if x != nil { + return x.FieldArgs + } + return nil } -func (x *RequireStorageTagSummaryByIdFields) Reset() { - *x = RequireStorageTagSummaryByIdFields{} +type ResolveCategoryMetricsRelatedCategoryResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + RelatedCategory *Category `protobuf:"bytes,1,opt,name=related_category,json=relatedCategory,proto3" json:"related_category,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryMetricsRelatedCategoryResult) Reset() { + *x = ResolveCategoryMetricsRelatedCategoryResult{} mi := &file_product_proto_msgTypes[229] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageTagSummaryByIdFields) String() string { +func (x *ResolveCategoryMetricsRelatedCategoryResult) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageTagSummaryByIdFields) ProtoMessage() {} +func (*ResolveCategoryMetricsRelatedCategoryResult) ProtoMessage() {} -func (x *RequireStorageTagSummaryByIdFields) ProtoReflect() protoreflect.Message { +func (x *ResolveCategoryMetricsRelatedCategoryResult) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[229] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -10721,40 +10687,39 @@ func (x *RequireStorageTagSummaryByIdFields) ProtoReflect() protoreflect.Message return mi.MessageOf(x) } -// Deprecated: Use RequireStorageTagSummaryByIdFields.ProtoReflect.Descriptor instead. -func (*RequireStorageTagSummaryByIdFields) Descriptor() ([]byte, []int) { +// Deprecated: Use ResolveCategoryMetricsRelatedCategoryResult.ProtoReflect.Descriptor instead. +func (*ResolveCategoryMetricsRelatedCategoryResult) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{229} } -func (x *RequireStorageTagSummaryByIdFields) GetTags() []string { +func (x *ResolveCategoryMetricsRelatedCategoryResult) GetRelatedCategory() *Category { if x != nil { - return x.Tags + return x.RelatedCategory } return nil } -type RequireStorageOptionalTagSummaryByIdRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - // RequireStorageOptionalTagSummaryByIdContext provides the context for the required fields method RequireStorageOptionalTagSummaryById. - Context []*RequireStorageOptionalTagSummaryByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` +type ResolveCategoryMetricsRelatedCategoryResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Result []*ResolveCategoryMetricsRelatedCategoryResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageOptionalTagSummaryByIdRequest) Reset() { - *x = RequireStorageOptionalTagSummaryByIdRequest{} +func (x *ResolveCategoryMetricsRelatedCategoryResponse) Reset() { + *x = ResolveCategoryMetricsRelatedCategoryResponse{} mi := &file_product_proto_msgTypes[230] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageOptionalTagSummaryByIdRequest) String() string { +func (x *ResolveCategoryMetricsRelatedCategoryResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageOptionalTagSummaryByIdRequest) ProtoMessage() {} +func (*ResolveCategoryMetricsRelatedCategoryResponse) ProtoMessage() {} -func (x *RequireStorageOptionalTagSummaryByIdRequest) ProtoReflect() protoreflect.Message { +func (x *ResolveCategoryMetricsRelatedCategoryResponse) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[230] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -10766,40 +10731,40 @@ func (x *RequireStorageOptionalTagSummaryByIdRequest) ProtoReflect() protoreflec return mi.MessageOf(x) } -// Deprecated: Use RequireStorageOptionalTagSummaryByIdRequest.ProtoReflect.Descriptor instead. -func (*RequireStorageOptionalTagSummaryByIdRequest) Descriptor() ([]byte, []int) { +// Deprecated: Use ResolveCategoryMetricsRelatedCategoryResponse.ProtoReflect.Descriptor instead. +func (*ResolveCategoryMetricsRelatedCategoryResponse) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{230} } -func (x *RequireStorageOptionalTagSummaryByIdRequest) GetContext() []*RequireStorageOptionalTagSummaryByIdContext { +func (x *ResolveCategoryMetricsRelatedCategoryResponse) GetResult() []*ResolveCategoryMetricsRelatedCategoryResult { if x != nil { - return x.Context + return x.Result } return nil } -type RequireStorageOptionalTagSummaryByIdContext struct { - state protoimpl.MessageState `protogen:"open.v1"` - Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` - Fields *RequireStorageOptionalTagSummaryByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` +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 *RequireStorageOptionalTagSummaryByIdContext) Reset() { - *x = RequireStorageOptionalTagSummaryByIdContext{} +func (x *ResolveCategoryMetricsAverageScoreContext) Reset() { + *x = ResolveCategoryMetricsAverageScoreContext{} mi := &file_product_proto_msgTypes[231] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageOptionalTagSummaryByIdContext) String() string { +func (x *ResolveCategoryMetricsAverageScoreContext) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageOptionalTagSummaryByIdContext) ProtoMessage() {} +func (*ResolveCategoryMetricsAverageScoreContext) ProtoMessage() {} -func (x *RequireStorageOptionalTagSummaryByIdContext) ProtoReflect() protoreflect.Message { +func (x *ResolveCategoryMetricsAverageScoreContext) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[231] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -10811,47 +10776,47 @@ func (x *RequireStorageOptionalTagSummaryByIdContext) ProtoReflect() protoreflec return mi.MessageOf(x) } -// Deprecated: Use RequireStorageOptionalTagSummaryByIdContext.ProtoReflect.Descriptor instead. -func (*RequireStorageOptionalTagSummaryByIdContext) Descriptor() ([]byte, []int) { +// Deprecated: Use ResolveCategoryMetricsAverageScoreContext.ProtoReflect.Descriptor instead. +func (*ResolveCategoryMetricsAverageScoreContext) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{231} } -func (x *RequireStorageOptionalTagSummaryByIdContext) GetKey() *LookupStorageByIdRequestKey { +func (x *ResolveCategoryMetricsAverageScoreContext) GetId() string { if x != nil { - return x.Key + return x.Id } - return nil + return "" } -func (x *RequireStorageOptionalTagSummaryByIdContext) GetFields() *RequireStorageOptionalTagSummaryByIdFields { +func (x *ResolveCategoryMetricsAverageScoreContext) GetMetricType() string { if x != nil { - return x.Fields + return x.MetricType } - return nil + return "" } -type RequireStorageOptionalTagSummaryByIdResponse struct { +type ResolveCategoryMetricsAverageScoreRequest struct { state protoimpl.MessageState `protogen:"open.v1"` - // RequireStorageOptionalTagSummaryByIdResult provides the result for the required fields method RequireStorageOptionalTagSummaryById. - Result []*RequireStorageOptionalTagSummaryByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` + // 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 *RequireStorageOptionalTagSummaryByIdResponse) Reset() { - *x = RequireStorageOptionalTagSummaryByIdResponse{} +func (x *ResolveCategoryMetricsAverageScoreRequest) Reset() { + *x = ResolveCategoryMetricsAverageScoreRequest{} mi := &file_product_proto_msgTypes[232] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageOptionalTagSummaryByIdResponse) String() string { +func (x *ResolveCategoryMetricsAverageScoreRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageOptionalTagSummaryByIdResponse) ProtoMessage() {} +func (*ResolveCategoryMetricsAverageScoreRequest) ProtoMessage() {} -func (x *RequireStorageOptionalTagSummaryByIdResponse) ProtoReflect() protoreflect.Message { +func (x *ResolveCategoryMetricsAverageScoreRequest) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[232] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -10863,39 +10828,39 @@ func (x *RequireStorageOptionalTagSummaryByIdResponse) ProtoReflect() protorefle return mi.MessageOf(x) } -// Deprecated: Use RequireStorageOptionalTagSummaryByIdResponse.ProtoReflect.Descriptor instead. -func (*RequireStorageOptionalTagSummaryByIdResponse) Descriptor() ([]byte, []int) { +// Deprecated: Use ResolveCategoryMetricsAverageScoreRequest.ProtoReflect.Descriptor instead. +func (*ResolveCategoryMetricsAverageScoreRequest) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{232} } -func (x *RequireStorageOptionalTagSummaryByIdResponse) GetResult() []*RequireStorageOptionalTagSummaryByIdResult { +func (x *ResolveCategoryMetricsAverageScoreRequest) GetContext() []*ResolveCategoryMetricsAverageScoreContext { if x != nil { - return x.Result + return x.Context } return nil } -type RequireStorageOptionalTagSummaryByIdResult struct { - state protoimpl.MessageState `protogen:"open.v1"` - OptionalTagSummary *wrapperspb.StringValue `protobuf:"bytes,1,opt,name=optional_tag_summary,json=optionalTagSummary,proto3" json:"optional_tag_summary,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +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 *RequireStorageOptionalTagSummaryByIdResult) Reset() { - *x = RequireStorageOptionalTagSummaryByIdResult{} +func (x *ResolveCategoryMetricsAverageScoreResult) Reset() { + *x = ResolveCategoryMetricsAverageScoreResult{} mi := &file_product_proto_msgTypes[233] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageOptionalTagSummaryByIdResult) String() string { +func (x *ResolveCategoryMetricsAverageScoreResult) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageOptionalTagSummaryByIdResult) ProtoMessage() {} +func (*ResolveCategoryMetricsAverageScoreResult) ProtoMessage() {} -func (x *RequireStorageOptionalTagSummaryByIdResult) ProtoReflect() protoreflect.Message { +func (x *ResolveCategoryMetricsAverageScoreResult) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[233] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -10907,39 +10872,39 @@ func (x *RequireStorageOptionalTagSummaryByIdResult) ProtoReflect() protoreflect return mi.MessageOf(x) } -// Deprecated: Use RequireStorageOptionalTagSummaryByIdResult.ProtoReflect.Descriptor instead. -func (*RequireStorageOptionalTagSummaryByIdResult) Descriptor() ([]byte, []int) { +// Deprecated: Use ResolveCategoryMetricsAverageScoreResult.ProtoReflect.Descriptor instead. +func (*ResolveCategoryMetricsAverageScoreResult) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{233} } -func (x *RequireStorageOptionalTagSummaryByIdResult) GetOptionalTagSummary() *wrapperspb.StringValue { +func (x *ResolveCategoryMetricsAverageScoreResult) GetAverageScore() float64 { if x != nil { - return x.OptionalTagSummary + return x.AverageScore } - return nil + return 0 } -type RequireStorageOptionalTagSummaryByIdFields struct { - state protoimpl.MessageState `protogen:"open.v1"` - OptionalTags *ListOfString `protobuf:"bytes,1,opt,name=optional_tags,json=optionalTags,proto3" json:"optional_tags,omitempty"` +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 *RequireStorageOptionalTagSummaryByIdFields) Reset() { - *x = RequireStorageOptionalTagSummaryByIdFields{} +func (x *ResolveCategoryMetricsAverageScoreResponse) Reset() { + *x = ResolveCategoryMetricsAverageScoreResponse{} mi := &file_product_proto_msgTypes[234] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageOptionalTagSummaryByIdFields) String() string { +func (x *ResolveCategoryMetricsAverageScoreResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageOptionalTagSummaryByIdFields) ProtoMessage() {} +func (*ResolveCategoryMetricsAverageScoreResponse) ProtoMessage() {} -func (x *RequireStorageOptionalTagSummaryByIdFields) ProtoReflect() protoreflect.Message { +func (x *ResolveCategoryMetricsAverageScoreResponse) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[234] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -10951,40 +10916,39 @@ func (x *RequireStorageOptionalTagSummaryByIdFields) ProtoReflect() protoreflect return mi.MessageOf(x) } -// Deprecated: Use RequireStorageOptionalTagSummaryByIdFields.ProtoReflect.Descriptor instead. -func (*RequireStorageOptionalTagSummaryByIdFields) Descriptor() ([]byte, []int) { +// Deprecated: Use ResolveCategoryMetricsAverageScoreResponse.ProtoReflect.Descriptor instead. +func (*ResolveCategoryMetricsAverageScoreResponse) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{234} } -func (x *RequireStorageOptionalTagSummaryByIdFields) GetOptionalTags() *ListOfString { +func (x *ResolveCategoryMetricsAverageScoreResponse) GetResult() []*ResolveCategoryMetricsAverageScoreResult { if x != nil { - return x.OptionalTags + return x.Result } return nil } -type RequireStorageMetadataScoreByIdRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - // RequireStorageMetadataScoreByIdContext provides the context for the required fields method RequireStorageMetadataScoreById. - Context []*RequireStorageMetadataScoreByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +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"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *RequireStorageMetadataScoreByIdRequest) Reset() { - *x = RequireStorageMetadataScoreByIdRequest{} +func (x *ResolveTestContainerDetailsArgs) Reset() { + *x = ResolveTestContainerDetailsArgs{} mi := &file_product_proto_msgTypes[235] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageMetadataScoreByIdRequest) String() string { +func (x *ResolveTestContainerDetailsArgs) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageMetadataScoreByIdRequest) ProtoMessage() {} +func (*ResolveTestContainerDetailsArgs) ProtoMessage() {} -func (x *RequireStorageMetadataScoreByIdRequest) ProtoReflect() protoreflect.Message { +func (x *ResolveTestContainerDetailsArgs) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[235] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -10996,40 +10960,40 @@ func (x *RequireStorageMetadataScoreByIdRequest) ProtoReflect() protoreflect.Mes return mi.MessageOf(x) } -// Deprecated: Use RequireStorageMetadataScoreByIdRequest.ProtoReflect.Descriptor instead. -func (*RequireStorageMetadataScoreByIdRequest) Descriptor() ([]byte, []int) { +// Deprecated: Use ResolveTestContainerDetailsArgs.ProtoReflect.Descriptor instead. +func (*ResolveTestContainerDetailsArgs) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{235} } -func (x *RequireStorageMetadataScoreByIdRequest) GetContext() []*RequireStorageMetadataScoreByIdContext { +func (x *ResolveTestContainerDetailsArgs) GetIncludeExtended() bool { if x != nil { - return x.Context + return x.IncludeExtended } - return nil + return false } -type RequireStorageMetadataScoreByIdContext struct { - state protoimpl.MessageState `protogen:"open.v1"` - Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` - Fields *RequireStorageMetadataScoreByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` +type ResolveTestContainerDetailsContext 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 *RequireStorageMetadataScoreByIdContext) Reset() { - *x = RequireStorageMetadataScoreByIdContext{} +func (x *ResolveTestContainerDetailsContext) Reset() { + *x = ResolveTestContainerDetailsContext{} mi := &file_product_proto_msgTypes[236] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageMetadataScoreByIdContext) String() string { +func (x *ResolveTestContainerDetailsContext) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageMetadataScoreByIdContext) ProtoMessage() {} +func (*ResolveTestContainerDetailsContext) ProtoMessage() {} -func (x *RequireStorageMetadataScoreByIdContext) ProtoReflect() protoreflect.Message { +func (x *ResolveTestContainerDetailsContext) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[236] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11041,47 +11005,49 @@ func (x *RequireStorageMetadataScoreByIdContext) ProtoReflect() protoreflect.Mes return mi.MessageOf(x) } -// Deprecated: Use RequireStorageMetadataScoreByIdContext.ProtoReflect.Descriptor instead. -func (*RequireStorageMetadataScoreByIdContext) Descriptor() ([]byte, []int) { +// Deprecated: Use ResolveTestContainerDetailsContext.ProtoReflect.Descriptor instead. +func (*ResolveTestContainerDetailsContext) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{236} } -func (x *RequireStorageMetadataScoreByIdContext) GetKey() *LookupStorageByIdRequestKey { +func (x *ResolveTestContainerDetailsContext) GetId() string { if x != nil { - return x.Key + return x.Id } - return nil + return "" } -func (x *RequireStorageMetadataScoreByIdContext) GetFields() *RequireStorageMetadataScoreByIdFields { +func (x *ResolveTestContainerDetailsContext) GetName() string { if x != nil { - return x.Fields + return x.Name } - return nil + return "" } -type RequireStorageMetadataScoreByIdResponse struct { +type ResolveTestContainerDetailsRequest struct { state protoimpl.MessageState `protogen:"open.v1"` - // RequireStorageMetadataScoreByIdResult provides the result for the required fields method RequireStorageMetadataScoreById. - Result []*RequireStorageMetadataScoreByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` + // context provides the resolver context for the field details of type TestContainer. + Context []*ResolveTestContainerDetailsContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` + // field_args provides the arguments for the resolver field details of type TestContainer. + FieldArgs *ResolveTestContainerDetailsArgs `protobuf:"bytes,2,opt,name=field_args,json=fieldArgs,proto3" json:"field_args,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageMetadataScoreByIdResponse) Reset() { - *x = RequireStorageMetadataScoreByIdResponse{} +func (x *ResolveTestContainerDetailsRequest) Reset() { + *x = ResolveTestContainerDetailsRequest{} mi := &file_product_proto_msgTypes[237] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageMetadataScoreByIdResponse) String() string { +func (x *ResolveTestContainerDetailsRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageMetadataScoreByIdResponse) ProtoMessage() {} +func (*ResolveTestContainerDetailsRequest) ProtoMessage() {} -func (x *RequireStorageMetadataScoreByIdResponse) ProtoReflect() protoreflect.Message { +func (x *ResolveTestContainerDetailsRequest) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[237] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11093,39 +11059,46 @@ func (x *RequireStorageMetadataScoreByIdResponse) ProtoReflect() protoreflect.Me return mi.MessageOf(x) } -// Deprecated: Use RequireStorageMetadataScoreByIdResponse.ProtoReflect.Descriptor instead. -func (*RequireStorageMetadataScoreByIdResponse) Descriptor() ([]byte, []int) { +// Deprecated: Use ResolveTestContainerDetailsRequest.ProtoReflect.Descriptor instead. +func (*ResolveTestContainerDetailsRequest) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{237} } -func (x *RequireStorageMetadataScoreByIdResponse) GetResult() []*RequireStorageMetadataScoreByIdResult { +func (x *ResolveTestContainerDetailsRequest) GetContext() []*ResolveTestContainerDetailsContext { if x != nil { - return x.Result + return x.Context } return nil } -type RequireStorageMetadataScoreByIdResult struct { +func (x *ResolveTestContainerDetailsRequest) GetFieldArgs() *ResolveTestContainerDetailsArgs { + if x != nil { + return x.FieldArgs + } + return nil +} + +type ResolveTestContainerDetailsResult struct { state protoimpl.MessageState `protogen:"open.v1"` - MetadataScore float64 `protobuf:"fixed64,1,opt,name=metadata_score,json=metadataScore,proto3" json:"metadata_score,omitempty"` + Details *TestDetails `protobuf:"bytes,1,opt,name=details,proto3" json:"details,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageMetadataScoreByIdResult) Reset() { - *x = RequireStorageMetadataScoreByIdResult{} +func (x *ResolveTestContainerDetailsResult) Reset() { + *x = ResolveTestContainerDetailsResult{} mi := &file_product_proto_msgTypes[238] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageMetadataScoreByIdResult) String() string { +func (x *ResolveTestContainerDetailsResult) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageMetadataScoreByIdResult) ProtoMessage() {} +func (*ResolveTestContainerDetailsResult) ProtoMessage() {} -func (x *RequireStorageMetadataScoreByIdResult) ProtoReflect() protoreflect.Message { +func (x *ResolveTestContainerDetailsResult) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[238] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11137,39 +11110,39 @@ func (x *RequireStorageMetadataScoreByIdResult) ProtoReflect() protoreflect.Mess return mi.MessageOf(x) } -// Deprecated: Use RequireStorageMetadataScoreByIdResult.ProtoReflect.Descriptor instead. -func (*RequireStorageMetadataScoreByIdResult) Descriptor() ([]byte, []int) { +// Deprecated: Use ResolveTestContainerDetailsResult.ProtoReflect.Descriptor instead. +func (*ResolveTestContainerDetailsResult) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{238} } -func (x *RequireStorageMetadataScoreByIdResult) GetMetadataScore() float64 { +func (x *ResolveTestContainerDetailsResult) GetDetails() *TestDetails { if x != nil { - return x.MetadataScore + return x.Details } - return 0 + return nil } -type RequireStorageMetadataScoreByIdFields struct { - state protoimpl.MessageState `protogen:"open.v1"` - Metadata *RequireStorageMetadataScoreByIdFields_StorageMetadata `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"` +type ResolveTestContainerDetailsResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Result []*ResolveTestContainerDetailsResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageMetadataScoreByIdFields) Reset() { - *x = RequireStorageMetadataScoreByIdFields{} +func (x *ResolveTestContainerDetailsResponse) Reset() { + *x = ResolveTestContainerDetailsResponse{} mi := &file_product_proto_msgTypes[239] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageMetadataScoreByIdFields) String() string { +func (x *ResolveTestContainerDetailsResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageMetadataScoreByIdFields) ProtoMessage() {} +func (*ResolveTestContainerDetailsResponse) ProtoMessage() {} -func (x *RequireStorageMetadataScoreByIdFields) ProtoReflect() protoreflect.Message { +func (x *ResolveTestContainerDetailsResponse) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[239] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11181,40 +11154,40 @@ func (x *RequireStorageMetadataScoreByIdFields) ProtoReflect() protoreflect.Mess return mi.MessageOf(x) } -// Deprecated: Use RequireStorageMetadataScoreByIdFields.ProtoReflect.Descriptor instead. -func (*RequireStorageMetadataScoreByIdFields) Descriptor() ([]byte, []int) { +// Deprecated: Use ResolveTestContainerDetailsResponse.ProtoReflect.Descriptor instead. +func (*ResolveTestContainerDetailsResponse) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{239} } -func (x *RequireStorageMetadataScoreByIdFields) GetMetadata() *RequireStorageMetadataScoreByIdFields_StorageMetadata { +func (x *ResolveTestContainerDetailsResponse) GetResult() []*ResolveTestContainerDetailsResult { if x != nil { - return x.Metadata + return x.Result } return nil } -type RequireStorageProcessedMetadataByIdRequest struct { +type RequireStorageStockHealthScoreByIdRequest struct { state protoimpl.MessageState `protogen:"open.v1"` - // RequireStorageProcessedMetadataByIdContext provides the context for the required fields method RequireStorageProcessedMetadataById. - Context []*RequireStorageProcessedMetadataByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` + // RequireStorageStockHealthScoreByIdContext provides the context for the required fields method RequireStorageStockHealthScoreById. + Context []*RequireStorageStockHealthScoreByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageProcessedMetadataByIdRequest) Reset() { - *x = RequireStorageProcessedMetadataByIdRequest{} +func (x *RequireStorageStockHealthScoreByIdRequest) Reset() { + *x = RequireStorageStockHealthScoreByIdRequest{} mi := &file_product_proto_msgTypes[240] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageProcessedMetadataByIdRequest) String() string { +func (x *RequireStorageStockHealthScoreByIdRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageProcessedMetadataByIdRequest) ProtoMessage() {} +func (*RequireStorageStockHealthScoreByIdRequest) ProtoMessage() {} -func (x *RequireStorageProcessedMetadataByIdRequest) ProtoReflect() protoreflect.Message { +func (x *RequireStorageStockHealthScoreByIdRequest) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[240] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11226,40 +11199,40 @@ func (x *RequireStorageProcessedMetadataByIdRequest) ProtoReflect() protoreflect return mi.MessageOf(x) } -// Deprecated: Use RequireStorageProcessedMetadataByIdRequest.ProtoReflect.Descriptor instead. -func (*RequireStorageProcessedMetadataByIdRequest) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageStockHealthScoreByIdRequest.ProtoReflect.Descriptor instead. +func (*RequireStorageStockHealthScoreByIdRequest) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{240} } -func (x *RequireStorageProcessedMetadataByIdRequest) GetContext() []*RequireStorageProcessedMetadataByIdContext { +func (x *RequireStorageStockHealthScoreByIdRequest) GetContext() []*RequireStorageStockHealthScoreByIdContext { if x != nil { return x.Context } return nil } -type RequireStorageProcessedMetadataByIdContext struct { - state protoimpl.MessageState `protogen:"open.v1"` - Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` - Fields *RequireStorageProcessedMetadataByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` +type RequireStorageStockHealthScoreByIdContext struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Fields *RequireStorageStockHealthScoreByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageProcessedMetadataByIdContext) Reset() { - *x = RequireStorageProcessedMetadataByIdContext{} +func (x *RequireStorageStockHealthScoreByIdContext) Reset() { + *x = RequireStorageStockHealthScoreByIdContext{} mi := &file_product_proto_msgTypes[241] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageProcessedMetadataByIdContext) String() string { +func (x *RequireStorageStockHealthScoreByIdContext) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageProcessedMetadataByIdContext) ProtoMessage() {} +func (*RequireStorageStockHealthScoreByIdContext) ProtoMessage() {} -func (x *RequireStorageProcessedMetadataByIdContext) ProtoReflect() protoreflect.Message { +func (x *RequireStorageStockHealthScoreByIdContext) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[241] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11271,47 +11244,47 @@ func (x *RequireStorageProcessedMetadataByIdContext) ProtoReflect() protoreflect return mi.MessageOf(x) } -// Deprecated: Use RequireStorageProcessedMetadataByIdContext.ProtoReflect.Descriptor instead. -func (*RequireStorageProcessedMetadataByIdContext) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageStockHealthScoreByIdContext.ProtoReflect.Descriptor instead. +func (*RequireStorageStockHealthScoreByIdContext) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{241} } -func (x *RequireStorageProcessedMetadataByIdContext) GetKey() *LookupStorageByIdRequestKey { +func (x *RequireStorageStockHealthScoreByIdContext) GetKey() *LookupStorageByIdRequestKey { if x != nil { return x.Key } return nil } -func (x *RequireStorageProcessedMetadataByIdContext) GetFields() *RequireStorageProcessedMetadataByIdFields { +func (x *RequireStorageStockHealthScoreByIdContext) GetFields() *RequireStorageStockHealthScoreByIdFields { if x != nil { return x.Fields } return nil } -type RequireStorageProcessedMetadataByIdResponse struct { +type RequireStorageStockHealthScoreByIdResponse struct { state protoimpl.MessageState `protogen:"open.v1"` - // RequireStorageProcessedMetadataByIdResult provides the result for the required fields method RequireStorageProcessedMetadataById. - Result []*RequireStorageProcessedMetadataByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` + // RequireStorageStockHealthScoreByIdResult provides the result for the required fields method RequireStorageStockHealthScoreById. + Result []*RequireStorageStockHealthScoreByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageProcessedMetadataByIdResponse) Reset() { - *x = RequireStorageProcessedMetadataByIdResponse{} +func (x *RequireStorageStockHealthScoreByIdResponse) Reset() { + *x = RequireStorageStockHealthScoreByIdResponse{} mi := &file_product_proto_msgTypes[242] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageProcessedMetadataByIdResponse) String() string { +func (x *RequireStorageStockHealthScoreByIdResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageProcessedMetadataByIdResponse) ProtoMessage() {} +func (*RequireStorageStockHealthScoreByIdResponse) ProtoMessage() {} -func (x *RequireStorageProcessedMetadataByIdResponse) ProtoReflect() protoreflect.Message { +func (x *RequireStorageStockHealthScoreByIdResponse) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[242] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11323,39 +11296,39 @@ func (x *RequireStorageProcessedMetadataByIdResponse) ProtoReflect() protoreflec return mi.MessageOf(x) } -// Deprecated: Use RequireStorageProcessedMetadataByIdResponse.ProtoReflect.Descriptor instead. -func (*RequireStorageProcessedMetadataByIdResponse) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageStockHealthScoreByIdResponse.ProtoReflect.Descriptor instead. +func (*RequireStorageStockHealthScoreByIdResponse) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{242} } -func (x *RequireStorageProcessedMetadataByIdResponse) GetResult() []*RequireStorageProcessedMetadataByIdResult { +func (x *RequireStorageStockHealthScoreByIdResponse) GetResult() []*RequireStorageStockHealthScoreByIdResult { if x != nil { return x.Result } return nil } -type RequireStorageProcessedMetadataByIdResult struct { - state protoimpl.MessageState `protogen:"open.v1"` - ProcessedMetadata *StorageMetadata `protobuf:"bytes,1,opt,name=processed_metadata,json=processedMetadata,proto3" json:"processed_metadata,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type RequireStorageStockHealthScoreByIdResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + StockHealthScore float64 `protobuf:"fixed64,1,opt,name=stock_health_score,json=stockHealthScore,proto3" json:"stock_health_score,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *RequireStorageProcessedMetadataByIdResult) Reset() { - *x = RequireStorageProcessedMetadataByIdResult{} +func (x *RequireStorageStockHealthScoreByIdResult) Reset() { + *x = RequireStorageStockHealthScoreByIdResult{} mi := &file_product_proto_msgTypes[243] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageProcessedMetadataByIdResult) String() string { +func (x *RequireStorageStockHealthScoreByIdResult) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageProcessedMetadataByIdResult) ProtoMessage() {} +func (*RequireStorageStockHealthScoreByIdResult) ProtoMessage() {} -func (x *RequireStorageProcessedMetadataByIdResult) ProtoReflect() protoreflect.Message { +func (x *RequireStorageStockHealthScoreByIdResult) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[243] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11367,39 +11340,40 @@ func (x *RequireStorageProcessedMetadataByIdResult) ProtoReflect() protoreflect. return mi.MessageOf(x) } -// Deprecated: Use RequireStorageProcessedMetadataByIdResult.ProtoReflect.Descriptor instead. -func (*RequireStorageProcessedMetadataByIdResult) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageStockHealthScoreByIdResult.ProtoReflect.Descriptor instead. +func (*RequireStorageStockHealthScoreByIdResult) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{243} } -func (x *RequireStorageProcessedMetadataByIdResult) GetProcessedMetadata() *StorageMetadata { +func (x *RequireStorageStockHealthScoreByIdResult) GetStockHealthScore() float64 { if x != nil { - return x.ProcessedMetadata + return x.StockHealthScore } - return nil + return 0 } -type RequireStorageProcessedMetadataByIdFields struct { - state protoimpl.MessageState `protogen:"open.v1"` - Metadata *RequireStorageProcessedMetadataByIdFields_StorageMetadata `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"` +type RequireStorageStockHealthScoreByIdFields struct { + state protoimpl.MessageState `protogen:"open.v1"` + ItemCount int32 `protobuf:"varint,1,opt,name=item_count,json=itemCount,proto3" json:"item_count,omitempty"` + RestockData *RequireStorageStockHealthScoreByIdFields_RestockData `protobuf:"bytes,2,opt,name=restock_data,json=restockData,proto3" json:"restock_data,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageProcessedMetadataByIdFields) Reset() { - *x = RequireStorageProcessedMetadataByIdFields{} +func (x *RequireStorageStockHealthScoreByIdFields) Reset() { + *x = RequireStorageStockHealthScoreByIdFields{} mi := &file_product_proto_msgTypes[244] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageProcessedMetadataByIdFields) String() string { +func (x *RequireStorageStockHealthScoreByIdFields) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageProcessedMetadataByIdFields) ProtoMessage() {} +func (*RequireStorageStockHealthScoreByIdFields) ProtoMessage() {} -func (x *RequireStorageProcessedMetadataByIdFields) ProtoReflect() protoreflect.Message { +func (x *RequireStorageStockHealthScoreByIdFields) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[244] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11411,40 +11385,47 @@ func (x *RequireStorageProcessedMetadataByIdFields) ProtoReflect() protoreflect. return mi.MessageOf(x) } -// Deprecated: Use RequireStorageProcessedMetadataByIdFields.ProtoReflect.Descriptor instead. -func (*RequireStorageProcessedMetadataByIdFields) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageStockHealthScoreByIdFields.ProtoReflect.Descriptor instead. +func (*RequireStorageStockHealthScoreByIdFields) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{244} } -func (x *RequireStorageProcessedMetadataByIdFields) GetMetadata() *RequireStorageProcessedMetadataByIdFields_StorageMetadata { +func (x *RequireStorageStockHealthScoreByIdFields) GetItemCount() int32 { if x != nil { - return x.Metadata + return x.ItemCount + } + return 0 +} + +func (x *RequireStorageStockHealthScoreByIdFields) GetRestockData() *RequireStorageStockHealthScoreByIdFields_RestockData { + if x != nil { + return x.RestockData } return nil } -type RequireStorageOptionalProcessedMetadataByIdRequest struct { +type RequireStorageTagSummaryByIdRequest struct { state protoimpl.MessageState `protogen:"open.v1"` - // RequireStorageOptionalProcessedMetadataByIdContext provides the context for the required fields method RequireStorageOptionalProcessedMetadataById. - Context []*RequireStorageOptionalProcessedMetadataByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` + // RequireStorageTagSummaryByIdContext provides the context for the required fields method RequireStorageTagSummaryById. + Context []*RequireStorageTagSummaryByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageOptionalProcessedMetadataByIdRequest) Reset() { - *x = RequireStorageOptionalProcessedMetadataByIdRequest{} +func (x *RequireStorageTagSummaryByIdRequest) Reset() { + *x = RequireStorageTagSummaryByIdRequest{} mi := &file_product_proto_msgTypes[245] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageOptionalProcessedMetadataByIdRequest) String() string { +func (x *RequireStorageTagSummaryByIdRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageOptionalProcessedMetadataByIdRequest) ProtoMessage() {} +func (*RequireStorageTagSummaryByIdRequest) ProtoMessage() {} -func (x *RequireStorageOptionalProcessedMetadataByIdRequest) ProtoReflect() protoreflect.Message { +func (x *RequireStorageTagSummaryByIdRequest) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[245] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11456,40 +11437,40 @@ func (x *RequireStorageOptionalProcessedMetadataByIdRequest) ProtoReflect() prot return mi.MessageOf(x) } -// Deprecated: Use RequireStorageOptionalProcessedMetadataByIdRequest.ProtoReflect.Descriptor instead. -func (*RequireStorageOptionalProcessedMetadataByIdRequest) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageTagSummaryByIdRequest.ProtoReflect.Descriptor instead. +func (*RequireStorageTagSummaryByIdRequest) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{245} } -func (x *RequireStorageOptionalProcessedMetadataByIdRequest) GetContext() []*RequireStorageOptionalProcessedMetadataByIdContext { +func (x *RequireStorageTagSummaryByIdRequest) GetContext() []*RequireStorageTagSummaryByIdContext { if x != nil { return x.Context } return nil } -type RequireStorageOptionalProcessedMetadataByIdContext struct { - state protoimpl.MessageState `protogen:"open.v1"` - Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` - Fields *RequireStorageOptionalProcessedMetadataByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` +type RequireStorageTagSummaryByIdContext struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Fields *RequireStorageTagSummaryByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageOptionalProcessedMetadataByIdContext) Reset() { - *x = RequireStorageOptionalProcessedMetadataByIdContext{} +func (x *RequireStorageTagSummaryByIdContext) Reset() { + *x = RequireStorageTagSummaryByIdContext{} mi := &file_product_proto_msgTypes[246] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageOptionalProcessedMetadataByIdContext) String() string { +func (x *RequireStorageTagSummaryByIdContext) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageOptionalProcessedMetadataByIdContext) ProtoMessage() {} +func (*RequireStorageTagSummaryByIdContext) ProtoMessage() {} -func (x *RequireStorageOptionalProcessedMetadataByIdContext) ProtoReflect() protoreflect.Message { +func (x *RequireStorageTagSummaryByIdContext) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[246] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11501,47 +11482,47 @@ func (x *RequireStorageOptionalProcessedMetadataByIdContext) ProtoReflect() prot return mi.MessageOf(x) } -// Deprecated: Use RequireStorageOptionalProcessedMetadataByIdContext.ProtoReflect.Descriptor instead. -func (*RequireStorageOptionalProcessedMetadataByIdContext) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageTagSummaryByIdContext.ProtoReflect.Descriptor instead. +func (*RequireStorageTagSummaryByIdContext) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{246} } -func (x *RequireStorageOptionalProcessedMetadataByIdContext) GetKey() *LookupStorageByIdRequestKey { +func (x *RequireStorageTagSummaryByIdContext) GetKey() *LookupStorageByIdRequestKey { if x != nil { return x.Key } return nil } -func (x *RequireStorageOptionalProcessedMetadataByIdContext) GetFields() *RequireStorageOptionalProcessedMetadataByIdFields { +func (x *RequireStorageTagSummaryByIdContext) GetFields() *RequireStorageTagSummaryByIdFields { if x != nil { return x.Fields } return nil } -type RequireStorageOptionalProcessedMetadataByIdResponse struct { +type RequireStorageTagSummaryByIdResponse struct { state protoimpl.MessageState `protogen:"open.v1"` - // RequireStorageOptionalProcessedMetadataByIdResult provides the result for the required fields method RequireStorageOptionalProcessedMetadataById. - Result []*RequireStorageOptionalProcessedMetadataByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` + // RequireStorageTagSummaryByIdResult provides the result for the required fields method RequireStorageTagSummaryById. + Result []*RequireStorageTagSummaryByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageOptionalProcessedMetadataByIdResponse) Reset() { - *x = RequireStorageOptionalProcessedMetadataByIdResponse{} +func (x *RequireStorageTagSummaryByIdResponse) Reset() { + *x = RequireStorageTagSummaryByIdResponse{} mi := &file_product_proto_msgTypes[247] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageOptionalProcessedMetadataByIdResponse) String() string { +func (x *RequireStorageTagSummaryByIdResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageOptionalProcessedMetadataByIdResponse) ProtoMessage() {} +func (*RequireStorageTagSummaryByIdResponse) ProtoMessage() {} -func (x *RequireStorageOptionalProcessedMetadataByIdResponse) ProtoReflect() protoreflect.Message { +func (x *RequireStorageTagSummaryByIdResponse) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[247] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11553,39 +11534,39 @@ func (x *RequireStorageOptionalProcessedMetadataByIdResponse) ProtoReflect() pro return mi.MessageOf(x) } -// Deprecated: Use RequireStorageOptionalProcessedMetadataByIdResponse.ProtoReflect.Descriptor instead. -func (*RequireStorageOptionalProcessedMetadataByIdResponse) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageTagSummaryByIdResponse.ProtoReflect.Descriptor instead. +func (*RequireStorageTagSummaryByIdResponse) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{247} } -func (x *RequireStorageOptionalProcessedMetadataByIdResponse) GetResult() []*RequireStorageOptionalProcessedMetadataByIdResult { +func (x *RequireStorageTagSummaryByIdResponse) GetResult() []*RequireStorageTagSummaryByIdResult { if x != nil { return x.Result } return nil } -type RequireStorageOptionalProcessedMetadataByIdResult struct { - state protoimpl.MessageState `protogen:"open.v1"` - OptionalProcessedMetadata *StorageMetadata `protobuf:"bytes,1,opt,name=optional_processed_metadata,json=optionalProcessedMetadata,proto3" json:"optional_processed_metadata,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type RequireStorageTagSummaryByIdResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + TagSummary string `protobuf:"bytes,1,opt,name=tag_summary,json=tagSummary,proto3" json:"tag_summary,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *RequireStorageOptionalProcessedMetadataByIdResult) Reset() { - *x = RequireStorageOptionalProcessedMetadataByIdResult{} +func (x *RequireStorageTagSummaryByIdResult) Reset() { + *x = RequireStorageTagSummaryByIdResult{} mi := &file_product_proto_msgTypes[248] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageOptionalProcessedMetadataByIdResult) String() string { +func (x *RequireStorageTagSummaryByIdResult) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageOptionalProcessedMetadataByIdResult) ProtoMessage() {} +func (*RequireStorageTagSummaryByIdResult) ProtoMessage() {} -func (x *RequireStorageOptionalProcessedMetadataByIdResult) ProtoReflect() protoreflect.Message { +func (x *RequireStorageTagSummaryByIdResult) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[248] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11597,39 +11578,39 @@ func (x *RequireStorageOptionalProcessedMetadataByIdResult) ProtoReflect() proto return mi.MessageOf(x) } -// Deprecated: Use RequireStorageOptionalProcessedMetadataByIdResult.ProtoReflect.Descriptor instead. -func (*RequireStorageOptionalProcessedMetadataByIdResult) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageTagSummaryByIdResult.ProtoReflect.Descriptor instead. +func (*RequireStorageTagSummaryByIdResult) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{248} } -func (x *RequireStorageOptionalProcessedMetadataByIdResult) GetOptionalProcessedMetadata() *StorageMetadata { +func (x *RequireStorageTagSummaryByIdResult) GetTagSummary() string { if x != nil { - return x.OptionalProcessedMetadata + return x.TagSummary } - return nil + return "" } -type RequireStorageOptionalProcessedMetadataByIdFields struct { - state protoimpl.MessageState `protogen:"open.v1"` - Metadata *RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"` +type RequireStorageTagSummaryByIdFields struct { + state protoimpl.MessageState `protogen:"open.v1"` + Tags []string `protobuf:"bytes,1,rep,name=tags,proto3" json:"tags,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageOptionalProcessedMetadataByIdFields) Reset() { - *x = RequireStorageOptionalProcessedMetadataByIdFields{} +func (x *RequireStorageTagSummaryByIdFields) Reset() { + *x = RequireStorageTagSummaryByIdFields{} mi := &file_product_proto_msgTypes[249] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageOptionalProcessedMetadataByIdFields) String() string { +func (x *RequireStorageTagSummaryByIdFields) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageOptionalProcessedMetadataByIdFields) ProtoMessage() {} +func (*RequireStorageTagSummaryByIdFields) ProtoMessage() {} -func (x *RequireStorageOptionalProcessedMetadataByIdFields) ProtoReflect() protoreflect.Message { +func (x *RequireStorageTagSummaryByIdFields) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[249] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11641,40 +11622,40 @@ func (x *RequireStorageOptionalProcessedMetadataByIdFields) ProtoReflect() proto return mi.MessageOf(x) } -// Deprecated: Use RequireStorageOptionalProcessedMetadataByIdFields.ProtoReflect.Descriptor instead. -func (*RequireStorageOptionalProcessedMetadataByIdFields) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageTagSummaryByIdFields.ProtoReflect.Descriptor instead. +func (*RequireStorageTagSummaryByIdFields) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{249} } -func (x *RequireStorageOptionalProcessedMetadataByIdFields) GetMetadata() *RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata { +func (x *RequireStorageTagSummaryByIdFields) GetTags() []string { if x != nil { - return x.Metadata + return x.Tags } return nil } -type RequireStorageProcessedTagsByIdRequest struct { +type RequireStorageOptionalTagSummaryByIdRequest struct { state protoimpl.MessageState `protogen:"open.v1"` - // RequireStorageProcessedTagsByIdContext provides the context for the required fields method RequireStorageProcessedTagsById. - Context []*RequireStorageProcessedTagsByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` + // RequireStorageOptionalTagSummaryByIdContext provides the context for the required fields method RequireStorageOptionalTagSummaryById. + Context []*RequireStorageOptionalTagSummaryByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageProcessedTagsByIdRequest) Reset() { - *x = RequireStorageProcessedTagsByIdRequest{} +func (x *RequireStorageOptionalTagSummaryByIdRequest) Reset() { + *x = RequireStorageOptionalTagSummaryByIdRequest{} mi := &file_product_proto_msgTypes[250] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageProcessedTagsByIdRequest) String() string { +func (x *RequireStorageOptionalTagSummaryByIdRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageProcessedTagsByIdRequest) ProtoMessage() {} +func (*RequireStorageOptionalTagSummaryByIdRequest) ProtoMessage() {} -func (x *RequireStorageProcessedTagsByIdRequest) ProtoReflect() protoreflect.Message { +func (x *RequireStorageOptionalTagSummaryByIdRequest) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[250] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11686,40 +11667,40 @@ func (x *RequireStorageProcessedTagsByIdRequest) ProtoReflect() protoreflect.Mes return mi.MessageOf(x) } -// Deprecated: Use RequireStorageProcessedTagsByIdRequest.ProtoReflect.Descriptor instead. -func (*RequireStorageProcessedTagsByIdRequest) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageOptionalTagSummaryByIdRequest.ProtoReflect.Descriptor instead. +func (*RequireStorageOptionalTagSummaryByIdRequest) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{250} } -func (x *RequireStorageProcessedTagsByIdRequest) GetContext() []*RequireStorageProcessedTagsByIdContext { +func (x *RequireStorageOptionalTagSummaryByIdRequest) GetContext() []*RequireStorageOptionalTagSummaryByIdContext { if x != nil { return x.Context } return nil } -type RequireStorageProcessedTagsByIdContext struct { - state protoimpl.MessageState `protogen:"open.v1"` - Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` - Fields *RequireStorageProcessedTagsByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` +type RequireStorageOptionalTagSummaryByIdContext struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Fields *RequireStorageOptionalTagSummaryByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageProcessedTagsByIdContext) Reset() { - *x = RequireStorageProcessedTagsByIdContext{} +func (x *RequireStorageOptionalTagSummaryByIdContext) Reset() { + *x = RequireStorageOptionalTagSummaryByIdContext{} mi := &file_product_proto_msgTypes[251] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageProcessedTagsByIdContext) String() string { +func (x *RequireStorageOptionalTagSummaryByIdContext) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageProcessedTagsByIdContext) ProtoMessage() {} +func (*RequireStorageOptionalTagSummaryByIdContext) ProtoMessage() {} -func (x *RequireStorageProcessedTagsByIdContext) ProtoReflect() protoreflect.Message { +func (x *RequireStorageOptionalTagSummaryByIdContext) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[251] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11731,47 +11712,47 @@ func (x *RequireStorageProcessedTagsByIdContext) ProtoReflect() protoreflect.Mes return mi.MessageOf(x) } -// Deprecated: Use RequireStorageProcessedTagsByIdContext.ProtoReflect.Descriptor instead. -func (*RequireStorageProcessedTagsByIdContext) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageOptionalTagSummaryByIdContext.ProtoReflect.Descriptor instead. +func (*RequireStorageOptionalTagSummaryByIdContext) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{251} } -func (x *RequireStorageProcessedTagsByIdContext) GetKey() *LookupStorageByIdRequestKey { +func (x *RequireStorageOptionalTagSummaryByIdContext) GetKey() *LookupStorageByIdRequestKey { if x != nil { return x.Key } return nil } -func (x *RequireStorageProcessedTagsByIdContext) GetFields() *RequireStorageProcessedTagsByIdFields { +func (x *RequireStorageOptionalTagSummaryByIdContext) GetFields() *RequireStorageOptionalTagSummaryByIdFields { if x != nil { return x.Fields } return nil } -type RequireStorageProcessedTagsByIdResponse struct { +type RequireStorageOptionalTagSummaryByIdResponse struct { state protoimpl.MessageState `protogen:"open.v1"` - // RequireStorageProcessedTagsByIdResult provides the result for the required fields method RequireStorageProcessedTagsById. - Result []*RequireStorageProcessedTagsByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` + // RequireStorageOptionalTagSummaryByIdResult provides the result for the required fields method RequireStorageOptionalTagSummaryById. + Result []*RequireStorageOptionalTagSummaryByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageProcessedTagsByIdResponse) Reset() { - *x = RequireStorageProcessedTagsByIdResponse{} +func (x *RequireStorageOptionalTagSummaryByIdResponse) Reset() { + *x = RequireStorageOptionalTagSummaryByIdResponse{} mi := &file_product_proto_msgTypes[252] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageProcessedTagsByIdResponse) String() string { +func (x *RequireStorageOptionalTagSummaryByIdResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageProcessedTagsByIdResponse) ProtoMessage() {} +func (*RequireStorageOptionalTagSummaryByIdResponse) ProtoMessage() {} -func (x *RequireStorageProcessedTagsByIdResponse) ProtoReflect() protoreflect.Message { +func (x *RequireStorageOptionalTagSummaryByIdResponse) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[252] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11783,39 +11764,39 @@ func (x *RequireStorageProcessedTagsByIdResponse) ProtoReflect() protoreflect.Me return mi.MessageOf(x) } -// Deprecated: Use RequireStorageProcessedTagsByIdResponse.ProtoReflect.Descriptor instead. -func (*RequireStorageProcessedTagsByIdResponse) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageOptionalTagSummaryByIdResponse.ProtoReflect.Descriptor instead. +func (*RequireStorageOptionalTagSummaryByIdResponse) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{252} } -func (x *RequireStorageProcessedTagsByIdResponse) GetResult() []*RequireStorageProcessedTagsByIdResult { +func (x *RequireStorageOptionalTagSummaryByIdResponse) GetResult() []*RequireStorageOptionalTagSummaryByIdResult { if x != nil { return x.Result } return nil } -type RequireStorageProcessedTagsByIdResult struct { - state protoimpl.MessageState `protogen:"open.v1"` - ProcessedTags []string `protobuf:"bytes,1,rep,name=processed_tags,json=processedTags,proto3" json:"processed_tags,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type RequireStorageOptionalTagSummaryByIdResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + OptionalTagSummary *wrapperspb.StringValue `protobuf:"bytes,1,opt,name=optional_tag_summary,json=optionalTagSummary,proto3" json:"optional_tag_summary,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *RequireStorageProcessedTagsByIdResult) Reset() { - *x = RequireStorageProcessedTagsByIdResult{} +func (x *RequireStorageOptionalTagSummaryByIdResult) Reset() { + *x = RequireStorageOptionalTagSummaryByIdResult{} mi := &file_product_proto_msgTypes[253] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageProcessedTagsByIdResult) String() string { +func (x *RequireStorageOptionalTagSummaryByIdResult) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageProcessedTagsByIdResult) ProtoMessage() {} +func (*RequireStorageOptionalTagSummaryByIdResult) ProtoMessage() {} -func (x *RequireStorageProcessedTagsByIdResult) ProtoReflect() protoreflect.Message { +func (x *RequireStorageOptionalTagSummaryByIdResult) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[253] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11827,39 +11808,39 @@ func (x *RequireStorageProcessedTagsByIdResult) ProtoReflect() protoreflect.Mess return mi.MessageOf(x) } -// Deprecated: Use RequireStorageProcessedTagsByIdResult.ProtoReflect.Descriptor instead. -func (*RequireStorageProcessedTagsByIdResult) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageOptionalTagSummaryByIdResult.ProtoReflect.Descriptor instead. +func (*RequireStorageOptionalTagSummaryByIdResult) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{253} } -func (x *RequireStorageProcessedTagsByIdResult) GetProcessedTags() []string { +func (x *RequireStorageOptionalTagSummaryByIdResult) GetOptionalTagSummary() *wrapperspb.StringValue { if x != nil { - return x.ProcessedTags + return x.OptionalTagSummary } return nil } -type RequireStorageProcessedTagsByIdFields struct { +type RequireStorageOptionalTagSummaryByIdFields struct { state protoimpl.MessageState `protogen:"open.v1"` - Tags []string `protobuf:"bytes,1,rep,name=tags,proto3" json:"tags,omitempty"` + OptionalTags *ListOfString `protobuf:"bytes,1,opt,name=optional_tags,json=optionalTags,proto3" json:"optional_tags,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageProcessedTagsByIdFields) Reset() { - *x = RequireStorageProcessedTagsByIdFields{} +func (x *RequireStorageOptionalTagSummaryByIdFields) Reset() { + *x = RequireStorageOptionalTagSummaryByIdFields{} mi := &file_product_proto_msgTypes[254] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageProcessedTagsByIdFields) String() string { +func (x *RequireStorageOptionalTagSummaryByIdFields) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageProcessedTagsByIdFields) ProtoMessage() {} +func (*RequireStorageOptionalTagSummaryByIdFields) ProtoMessage() {} -func (x *RequireStorageProcessedTagsByIdFields) ProtoReflect() protoreflect.Message { +func (x *RequireStorageOptionalTagSummaryByIdFields) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[254] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11871,40 +11852,40 @@ func (x *RequireStorageProcessedTagsByIdFields) ProtoReflect() protoreflect.Mess return mi.MessageOf(x) } -// Deprecated: Use RequireStorageProcessedTagsByIdFields.ProtoReflect.Descriptor instead. -func (*RequireStorageProcessedTagsByIdFields) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageOptionalTagSummaryByIdFields.ProtoReflect.Descriptor instead. +func (*RequireStorageOptionalTagSummaryByIdFields) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{254} } -func (x *RequireStorageProcessedTagsByIdFields) GetTags() []string { +func (x *RequireStorageOptionalTagSummaryByIdFields) GetOptionalTags() *ListOfString { if x != nil { - return x.Tags + return x.OptionalTags } return nil } -type RequireStorageOptionalProcessedTagsByIdRequest struct { +type RequireStorageMetadataScoreByIdRequest struct { state protoimpl.MessageState `protogen:"open.v1"` - // RequireStorageOptionalProcessedTagsByIdContext provides the context for the required fields method RequireStorageOptionalProcessedTagsById. - Context []*RequireStorageOptionalProcessedTagsByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` + // RequireStorageMetadataScoreByIdContext provides the context for the required fields method RequireStorageMetadataScoreById. + Context []*RequireStorageMetadataScoreByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageOptionalProcessedTagsByIdRequest) Reset() { - *x = RequireStorageOptionalProcessedTagsByIdRequest{} +func (x *RequireStorageMetadataScoreByIdRequest) Reset() { + *x = RequireStorageMetadataScoreByIdRequest{} mi := &file_product_proto_msgTypes[255] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageOptionalProcessedTagsByIdRequest) String() string { +func (x *RequireStorageMetadataScoreByIdRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageOptionalProcessedTagsByIdRequest) ProtoMessage() {} +func (*RequireStorageMetadataScoreByIdRequest) ProtoMessage() {} -func (x *RequireStorageOptionalProcessedTagsByIdRequest) ProtoReflect() protoreflect.Message { +func (x *RequireStorageMetadataScoreByIdRequest) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[255] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11916,40 +11897,40 @@ func (x *RequireStorageOptionalProcessedTagsByIdRequest) ProtoReflect() protoref return mi.MessageOf(x) } -// Deprecated: Use RequireStorageOptionalProcessedTagsByIdRequest.ProtoReflect.Descriptor instead. -func (*RequireStorageOptionalProcessedTagsByIdRequest) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageMetadataScoreByIdRequest.ProtoReflect.Descriptor instead. +func (*RequireStorageMetadataScoreByIdRequest) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{255} } -func (x *RequireStorageOptionalProcessedTagsByIdRequest) GetContext() []*RequireStorageOptionalProcessedTagsByIdContext { +func (x *RequireStorageMetadataScoreByIdRequest) GetContext() []*RequireStorageMetadataScoreByIdContext { if x != nil { return x.Context } return nil } -type RequireStorageOptionalProcessedTagsByIdContext struct { - state protoimpl.MessageState `protogen:"open.v1"` - Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` - Fields *RequireStorageOptionalProcessedTagsByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` +type RequireStorageMetadataScoreByIdContext struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Fields *RequireStorageMetadataScoreByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageOptionalProcessedTagsByIdContext) Reset() { - *x = RequireStorageOptionalProcessedTagsByIdContext{} +func (x *RequireStorageMetadataScoreByIdContext) Reset() { + *x = RequireStorageMetadataScoreByIdContext{} mi := &file_product_proto_msgTypes[256] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageOptionalProcessedTagsByIdContext) String() string { +func (x *RequireStorageMetadataScoreByIdContext) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageOptionalProcessedTagsByIdContext) ProtoMessage() {} +func (*RequireStorageMetadataScoreByIdContext) ProtoMessage() {} -func (x *RequireStorageOptionalProcessedTagsByIdContext) ProtoReflect() protoreflect.Message { +func (x *RequireStorageMetadataScoreByIdContext) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[256] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11961,47 +11942,47 @@ func (x *RequireStorageOptionalProcessedTagsByIdContext) ProtoReflect() protoref return mi.MessageOf(x) } -// Deprecated: Use RequireStorageOptionalProcessedTagsByIdContext.ProtoReflect.Descriptor instead. -func (*RequireStorageOptionalProcessedTagsByIdContext) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageMetadataScoreByIdContext.ProtoReflect.Descriptor instead. +func (*RequireStorageMetadataScoreByIdContext) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{256} } -func (x *RequireStorageOptionalProcessedTagsByIdContext) GetKey() *LookupStorageByIdRequestKey { +func (x *RequireStorageMetadataScoreByIdContext) GetKey() *LookupStorageByIdRequestKey { if x != nil { return x.Key } return nil } -func (x *RequireStorageOptionalProcessedTagsByIdContext) GetFields() *RequireStorageOptionalProcessedTagsByIdFields { +func (x *RequireStorageMetadataScoreByIdContext) GetFields() *RequireStorageMetadataScoreByIdFields { if x != nil { return x.Fields } return nil } -type RequireStorageOptionalProcessedTagsByIdResponse struct { +type RequireStorageMetadataScoreByIdResponse struct { state protoimpl.MessageState `protogen:"open.v1"` - // RequireStorageOptionalProcessedTagsByIdResult provides the result for the required fields method RequireStorageOptionalProcessedTagsById. - Result []*RequireStorageOptionalProcessedTagsByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` + // RequireStorageMetadataScoreByIdResult provides the result for the required fields method RequireStorageMetadataScoreById. + Result []*RequireStorageMetadataScoreByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageOptionalProcessedTagsByIdResponse) Reset() { - *x = RequireStorageOptionalProcessedTagsByIdResponse{} +func (x *RequireStorageMetadataScoreByIdResponse) Reset() { + *x = RequireStorageMetadataScoreByIdResponse{} mi := &file_product_proto_msgTypes[257] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageOptionalProcessedTagsByIdResponse) String() string { +func (x *RequireStorageMetadataScoreByIdResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageOptionalProcessedTagsByIdResponse) ProtoMessage() {} +func (*RequireStorageMetadataScoreByIdResponse) ProtoMessage() {} -func (x *RequireStorageOptionalProcessedTagsByIdResponse) ProtoReflect() protoreflect.Message { +func (x *RequireStorageMetadataScoreByIdResponse) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[257] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12013,39 +11994,39 @@ func (x *RequireStorageOptionalProcessedTagsByIdResponse) ProtoReflect() protore return mi.MessageOf(x) } -// Deprecated: Use RequireStorageOptionalProcessedTagsByIdResponse.ProtoReflect.Descriptor instead. -func (*RequireStorageOptionalProcessedTagsByIdResponse) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageMetadataScoreByIdResponse.ProtoReflect.Descriptor instead. +func (*RequireStorageMetadataScoreByIdResponse) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{257} } -func (x *RequireStorageOptionalProcessedTagsByIdResponse) GetResult() []*RequireStorageOptionalProcessedTagsByIdResult { +func (x *RequireStorageMetadataScoreByIdResponse) GetResult() []*RequireStorageMetadataScoreByIdResult { if x != nil { return x.Result } return nil } -type RequireStorageOptionalProcessedTagsByIdResult struct { - state protoimpl.MessageState `protogen:"open.v1"` - OptionalProcessedTags *ListOfString `protobuf:"bytes,1,opt,name=optional_processed_tags,json=optionalProcessedTags,proto3" json:"optional_processed_tags,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type RequireStorageMetadataScoreByIdResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + MetadataScore float64 `protobuf:"fixed64,1,opt,name=metadata_score,json=metadataScore,proto3" json:"metadata_score,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *RequireStorageOptionalProcessedTagsByIdResult) Reset() { - *x = RequireStorageOptionalProcessedTagsByIdResult{} +func (x *RequireStorageMetadataScoreByIdResult) Reset() { + *x = RequireStorageMetadataScoreByIdResult{} mi := &file_product_proto_msgTypes[258] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageOptionalProcessedTagsByIdResult) String() string { +func (x *RequireStorageMetadataScoreByIdResult) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageOptionalProcessedTagsByIdResult) ProtoMessage() {} +func (*RequireStorageMetadataScoreByIdResult) ProtoMessage() {} -func (x *RequireStorageOptionalProcessedTagsByIdResult) ProtoReflect() protoreflect.Message { +func (x *RequireStorageMetadataScoreByIdResult) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[258] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12057,39 +12038,39 @@ func (x *RequireStorageOptionalProcessedTagsByIdResult) ProtoReflect() protorefl return mi.MessageOf(x) } -// Deprecated: Use RequireStorageOptionalProcessedTagsByIdResult.ProtoReflect.Descriptor instead. -func (*RequireStorageOptionalProcessedTagsByIdResult) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageMetadataScoreByIdResult.ProtoReflect.Descriptor instead. +func (*RequireStorageMetadataScoreByIdResult) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{258} } -func (x *RequireStorageOptionalProcessedTagsByIdResult) GetOptionalProcessedTags() *ListOfString { +func (x *RequireStorageMetadataScoreByIdResult) GetMetadataScore() float64 { if x != nil { - return x.OptionalProcessedTags + return x.MetadataScore } - return nil + return 0 } -type RequireStorageOptionalProcessedTagsByIdFields struct { - state protoimpl.MessageState `protogen:"open.v1"` - OptionalTags *ListOfString `protobuf:"bytes,1,opt,name=optional_tags,json=optionalTags,proto3" json:"optional_tags,omitempty"` +type RequireStorageMetadataScoreByIdFields struct { + state protoimpl.MessageState `protogen:"open.v1"` + Metadata *RequireStorageMetadataScoreByIdFields_StorageMetadata `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageOptionalProcessedTagsByIdFields) Reset() { - *x = RequireStorageOptionalProcessedTagsByIdFields{} +func (x *RequireStorageMetadataScoreByIdFields) Reset() { + *x = RequireStorageMetadataScoreByIdFields{} mi := &file_product_proto_msgTypes[259] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageOptionalProcessedTagsByIdFields) String() string { +func (x *RequireStorageMetadataScoreByIdFields) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageOptionalProcessedTagsByIdFields) ProtoMessage() {} +func (*RequireStorageMetadataScoreByIdFields) ProtoMessage() {} -func (x *RequireStorageOptionalProcessedTagsByIdFields) ProtoReflect() protoreflect.Message { +func (x *RequireStorageMetadataScoreByIdFields) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[259] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12101,40 +12082,40 @@ func (x *RequireStorageOptionalProcessedTagsByIdFields) ProtoReflect() protorefl return mi.MessageOf(x) } -// Deprecated: Use RequireStorageOptionalProcessedTagsByIdFields.ProtoReflect.Descriptor instead. -func (*RequireStorageOptionalProcessedTagsByIdFields) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageMetadataScoreByIdFields.ProtoReflect.Descriptor instead. +func (*RequireStorageMetadataScoreByIdFields) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{259} } -func (x *RequireStorageOptionalProcessedTagsByIdFields) GetOptionalTags() *ListOfString { +func (x *RequireStorageMetadataScoreByIdFields) GetMetadata() *RequireStorageMetadataScoreByIdFields_StorageMetadata { if x != nil { - return x.OptionalTags + return x.Metadata } return nil } -type RequireStorageProcessedMetadataHistoryByIdRequest struct { +type RequireStorageProcessedMetadataByIdRequest struct { state protoimpl.MessageState `protogen:"open.v1"` - // RequireStorageProcessedMetadataHistoryByIdContext provides the context for the required fields method RequireStorageProcessedMetadataHistoryById. - Context []*RequireStorageProcessedMetadataHistoryByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` + // RequireStorageProcessedMetadataByIdContext provides the context for the required fields method RequireStorageProcessedMetadataById. + Context []*RequireStorageProcessedMetadataByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageProcessedMetadataHistoryByIdRequest) Reset() { - *x = RequireStorageProcessedMetadataHistoryByIdRequest{} +func (x *RequireStorageProcessedMetadataByIdRequest) Reset() { + *x = RequireStorageProcessedMetadataByIdRequest{} mi := &file_product_proto_msgTypes[260] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageProcessedMetadataHistoryByIdRequest) String() string { +func (x *RequireStorageProcessedMetadataByIdRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageProcessedMetadataHistoryByIdRequest) ProtoMessage() {} +func (*RequireStorageProcessedMetadataByIdRequest) ProtoMessage() {} -func (x *RequireStorageProcessedMetadataHistoryByIdRequest) ProtoReflect() protoreflect.Message { +func (x *RequireStorageProcessedMetadataByIdRequest) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[260] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12146,40 +12127,40 @@ func (x *RequireStorageProcessedMetadataHistoryByIdRequest) ProtoReflect() proto return mi.MessageOf(x) } -// Deprecated: Use RequireStorageProcessedMetadataHistoryByIdRequest.ProtoReflect.Descriptor instead. -func (*RequireStorageProcessedMetadataHistoryByIdRequest) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageProcessedMetadataByIdRequest.ProtoReflect.Descriptor instead. +func (*RequireStorageProcessedMetadataByIdRequest) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{260} } -func (x *RequireStorageProcessedMetadataHistoryByIdRequest) GetContext() []*RequireStorageProcessedMetadataHistoryByIdContext { +func (x *RequireStorageProcessedMetadataByIdRequest) GetContext() []*RequireStorageProcessedMetadataByIdContext { if x != nil { return x.Context } return nil } -type RequireStorageProcessedMetadataHistoryByIdContext struct { - state protoimpl.MessageState `protogen:"open.v1"` - Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` - Fields *RequireStorageProcessedMetadataHistoryByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` +type RequireStorageProcessedMetadataByIdContext struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Fields *RequireStorageProcessedMetadataByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageProcessedMetadataHistoryByIdContext) Reset() { - *x = RequireStorageProcessedMetadataHistoryByIdContext{} +func (x *RequireStorageProcessedMetadataByIdContext) Reset() { + *x = RequireStorageProcessedMetadataByIdContext{} mi := &file_product_proto_msgTypes[261] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageProcessedMetadataHistoryByIdContext) String() string { +func (x *RequireStorageProcessedMetadataByIdContext) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageProcessedMetadataHistoryByIdContext) ProtoMessage() {} +func (*RequireStorageProcessedMetadataByIdContext) ProtoMessage() {} -func (x *RequireStorageProcessedMetadataHistoryByIdContext) ProtoReflect() protoreflect.Message { +func (x *RequireStorageProcessedMetadataByIdContext) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[261] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12191,47 +12172,47 @@ func (x *RequireStorageProcessedMetadataHistoryByIdContext) ProtoReflect() proto return mi.MessageOf(x) } -// Deprecated: Use RequireStorageProcessedMetadataHistoryByIdContext.ProtoReflect.Descriptor instead. -func (*RequireStorageProcessedMetadataHistoryByIdContext) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageProcessedMetadataByIdContext.ProtoReflect.Descriptor instead. +func (*RequireStorageProcessedMetadataByIdContext) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{261} } -func (x *RequireStorageProcessedMetadataHistoryByIdContext) GetKey() *LookupStorageByIdRequestKey { +func (x *RequireStorageProcessedMetadataByIdContext) GetKey() *LookupStorageByIdRequestKey { if x != nil { return x.Key } return nil } -func (x *RequireStorageProcessedMetadataHistoryByIdContext) GetFields() *RequireStorageProcessedMetadataHistoryByIdFields { +func (x *RequireStorageProcessedMetadataByIdContext) GetFields() *RequireStorageProcessedMetadataByIdFields { if x != nil { return x.Fields } return nil } -type RequireStorageProcessedMetadataHistoryByIdResponse struct { +type RequireStorageProcessedMetadataByIdResponse struct { state protoimpl.MessageState `protogen:"open.v1"` - // RequireStorageProcessedMetadataHistoryByIdResult provides the result for the required fields method RequireStorageProcessedMetadataHistoryById. - Result []*RequireStorageProcessedMetadataHistoryByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` + // RequireStorageProcessedMetadataByIdResult provides the result for the required fields method RequireStorageProcessedMetadataById. + Result []*RequireStorageProcessedMetadataByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageProcessedMetadataHistoryByIdResponse) Reset() { - *x = RequireStorageProcessedMetadataHistoryByIdResponse{} +func (x *RequireStorageProcessedMetadataByIdResponse) Reset() { + *x = RequireStorageProcessedMetadataByIdResponse{} mi := &file_product_proto_msgTypes[262] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageProcessedMetadataHistoryByIdResponse) String() string { +func (x *RequireStorageProcessedMetadataByIdResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageProcessedMetadataHistoryByIdResponse) ProtoMessage() {} +func (*RequireStorageProcessedMetadataByIdResponse) ProtoMessage() {} -func (x *RequireStorageProcessedMetadataHistoryByIdResponse) ProtoReflect() protoreflect.Message { +func (x *RequireStorageProcessedMetadataByIdResponse) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[262] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12243,39 +12224,39 @@ func (x *RequireStorageProcessedMetadataHistoryByIdResponse) ProtoReflect() prot return mi.MessageOf(x) } -// Deprecated: Use RequireStorageProcessedMetadataHistoryByIdResponse.ProtoReflect.Descriptor instead. -func (*RequireStorageProcessedMetadataHistoryByIdResponse) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageProcessedMetadataByIdResponse.ProtoReflect.Descriptor instead. +func (*RequireStorageProcessedMetadataByIdResponse) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{262} } -func (x *RequireStorageProcessedMetadataHistoryByIdResponse) GetResult() []*RequireStorageProcessedMetadataHistoryByIdResult { +func (x *RequireStorageProcessedMetadataByIdResponse) GetResult() []*RequireStorageProcessedMetadataByIdResult { if x != nil { return x.Result } return nil } -type RequireStorageProcessedMetadataHistoryByIdResult struct { - state protoimpl.MessageState `protogen:"open.v1"` - ProcessedMetadataHistory []*StorageMetadata `protobuf:"bytes,1,rep,name=processed_metadata_history,json=processedMetadataHistory,proto3" json:"processed_metadata_history,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type RequireStorageProcessedMetadataByIdResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + ProcessedMetadata *StorageMetadata `protobuf:"bytes,1,opt,name=processed_metadata,json=processedMetadata,proto3" json:"processed_metadata,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *RequireStorageProcessedMetadataHistoryByIdResult) Reset() { - *x = RequireStorageProcessedMetadataHistoryByIdResult{} +func (x *RequireStorageProcessedMetadataByIdResult) Reset() { + *x = RequireStorageProcessedMetadataByIdResult{} mi := &file_product_proto_msgTypes[263] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageProcessedMetadataHistoryByIdResult) String() string { +func (x *RequireStorageProcessedMetadataByIdResult) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageProcessedMetadataHistoryByIdResult) ProtoMessage() {} +func (*RequireStorageProcessedMetadataByIdResult) ProtoMessage() {} -func (x *RequireStorageProcessedMetadataHistoryByIdResult) ProtoReflect() protoreflect.Message { +func (x *RequireStorageProcessedMetadataByIdResult) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[263] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12287,39 +12268,39 @@ func (x *RequireStorageProcessedMetadataHistoryByIdResult) ProtoReflect() protor return mi.MessageOf(x) } -// Deprecated: Use RequireStorageProcessedMetadataHistoryByIdResult.ProtoReflect.Descriptor instead. -func (*RequireStorageProcessedMetadataHistoryByIdResult) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageProcessedMetadataByIdResult.ProtoReflect.Descriptor instead. +func (*RequireStorageProcessedMetadataByIdResult) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{263} } -func (x *RequireStorageProcessedMetadataHistoryByIdResult) GetProcessedMetadataHistory() []*StorageMetadata { +func (x *RequireStorageProcessedMetadataByIdResult) GetProcessedMetadata() *StorageMetadata { if x != nil { - return x.ProcessedMetadataHistory + return x.ProcessedMetadata } return nil } -type RequireStorageProcessedMetadataHistoryByIdFields struct { - state protoimpl.MessageState `protogen:"open.v1"` - MetadataHistory []*RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata `protobuf:"bytes,1,rep,name=metadata_history,json=metadataHistory,proto3" json:"metadata_history,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type RequireStorageProcessedMetadataByIdFields struct { + state protoimpl.MessageState `protogen:"open.v1"` + Metadata *RequireStorageProcessedMetadataByIdFields_StorageMetadata `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *RequireStorageProcessedMetadataHistoryByIdFields) Reset() { - *x = RequireStorageProcessedMetadataHistoryByIdFields{} +func (x *RequireStorageProcessedMetadataByIdFields) Reset() { + *x = RequireStorageProcessedMetadataByIdFields{} mi := &file_product_proto_msgTypes[264] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageProcessedMetadataHistoryByIdFields) String() string { +func (x *RequireStorageProcessedMetadataByIdFields) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageProcessedMetadataHistoryByIdFields) ProtoMessage() {} +func (*RequireStorageProcessedMetadataByIdFields) ProtoMessage() {} -func (x *RequireStorageProcessedMetadataHistoryByIdFields) ProtoReflect() protoreflect.Message { +func (x *RequireStorageProcessedMetadataByIdFields) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[264] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12331,40 +12312,40 @@ func (x *RequireStorageProcessedMetadataHistoryByIdFields) ProtoReflect() protor return mi.MessageOf(x) } -// Deprecated: Use RequireStorageProcessedMetadataHistoryByIdFields.ProtoReflect.Descriptor instead. -func (*RequireStorageProcessedMetadataHistoryByIdFields) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageProcessedMetadataByIdFields.ProtoReflect.Descriptor instead. +func (*RequireStorageProcessedMetadataByIdFields) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{264} } -func (x *RequireStorageProcessedMetadataHistoryByIdFields) GetMetadataHistory() []*RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata { +func (x *RequireStorageProcessedMetadataByIdFields) GetMetadata() *RequireStorageProcessedMetadataByIdFields_StorageMetadata { if x != nil { - return x.MetadataHistory + return x.Metadata } return nil } -type RequireStorageKindSummaryByIdRequest struct { +type RequireStorageOptionalProcessedMetadataByIdRequest struct { state protoimpl.MessageState `protogen:"open.v1"` - // RequireStorageKindSummaryByIdContext provides the context for the required fields method RequireStorageKindSummaryById. - Context []*RequireStorageKindSummaryByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` + // RequireStorageOptionalProcessedMetadataByIdContext provides the context for the required fields method RequireStorageOptionalProcessedMetadataById. + Context []*RequireStorageOptionalProcessedMetadataByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageKindSummaryByIdRequest) Reset() { - *x = RequireStorageKindSummaryByIdRequest{} +func (x *RequireStorageOptionalProcessedMetadataByIdRequest) Reset() { + *x = RequireStorageOptionalProcessedMetadataByIdRequest{} mi := &file_product_proto_msgTypes[265] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageKindSummaryByIdRequest) String() string { +func (x *RequireStorageOptionalProcessedMetadataByIdRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageKindSummaryByIdRequest) ProtoMessage() {} +func (*RequireStorageOptionalProcessedMetadataByIdRequest) ProtoMessage() {} -func (x *RequireStorageKindSummaryByIdRequest) ProtoReflect() protoreflect.Message { +func (x *RequireStorageOptionalProcessedMetadataByIdRequest) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[265] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12376,40 +12357,40 @@ func (x *RequireStorageKindSummaryByIdRequest) ProtoReflect() protoreflect.Messa return mi.MessageOf(x) } -// Deprecated: Use RequireStorageKindSummaryByIdRequest.ProtoReflect.Descriptor instead. -func (*RequireStorageKindSummaryByIdRequest) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageOptionalProcessedMetadataByIdRequest.ProtoReflect.Descriptor instead. +func (*RequireStorageOptionalProcessedMetadataByIdRequest) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{265} } -func (x *RequireStorageKindSummaryByIdRequest) GetContext() []*RequireStorageKindSummaryByIdContext { +func (x *RequireStorageOptionalProcessedMetadataByIdRequest) GetContext() []*RequireStorageOptionalProcessedMetadataByIdContext { if x != nil { return x.Context } return nil } -type RequireStorageKindSummaryByIdContext struct { - state protoimpl.MessageState `protogen:"open.v1"` - Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` - Fields *RequireStorageKindSummaryByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` +type RequireStorageOptionalProcessedMetadataByIdContext struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Fields *RequireStorageOptionalProcessedMetadataByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageKindSummaryByIdContext) Reset() { - *x = RequireStorageKindSummaryByIdContext{} +func (x *RequireStorageOptionalProcessedMetadataByIdContext) Reset() { + *x = RequireStorageOptionalProcessedMetadataByIdContext{} mi := &file_product_proto_msgTypes[266] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageKindSummaryByIdContext) String() string { +func (x *RequireStorageOptionalProcessedMetadataByIdContext) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageKindSummaryByIdContext) ProtoMessage() {} +func (*RequireStorageOptionalProcessedMetadataByIdContext) ProtoMessage() {} -func (x *RequireStorageKindSummaryByIdContext) ProtoReflect() protoreflect.Message { +func (x *RequireStorageOptionalProcessedMetadataByIdContext) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[266] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12421,47 +12402,47 @@ func (x *RequireStorageKindSummaryByIdContext) ProtoReflect() protoreflect.Messa return mi.MessageOf(x) } -// Deprecated: Use RequireStorageKindSummaryByIdContext.ProtoReflect.Descriptor instead. -func (*RequireStorageKindSummaryByIdContext) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageOptionalProcessedMetadataByIdContext.ProtoReflect.Descriptor instead. +func (*RequireStorageOptionalProcessedMetadataByIdContext) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{266} } -func (x *RequireStorageKindSummaryByIdContext) GetKey() *LookupStorageByIdRequestKey { +func (x *RequireStorageOptionalProcessedMetadataByIdContext) GetKey() *LookupStorageByIdRequestKey { if x != nil { return x.Key } return nil } -func (x *RequireStorageKindSummaryByIdContext) GetFields() *RequireStorageKindSummaryByIdFields { +func (x *RequireStorageOptionalProcessedMetadataByIdContext) GetFields() *RequireStorageOptionalProcessedMetadataByIdFields { if x != nil { return x.Fields } return nil } -type RequireStorageKindSummaryByIdResponse struct { +type RequireStorageOptionalProcessedMetadataByIdResponse struct { state protoimpl.MessageState `protogen:"open.v1"` - // RequireStorageKindSummaryByIdResult provides the result for the required fields method RequireStorageKindSummaryById. - Result []*RequireStorageKindSummaryByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` + // RequireStorageOptionalProcessedMetadataByIdResult provides the result for the required fields method RequireStorageOptionalProcessedMetadataById. + Result []*RequireStorageOptionalProcessedMetadataByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageKindSummaryByIdResponse) Reset() { - *x = RequireStorageKindSummaryByIdResponse{} +func (x *RequireStorageOptionalProcessedMetadataByIdResponse) Reset() { + *x = RequireStorageOptionalProcessedMetadataByIdResponse{} mi := &file_product_proto_msgTypes[267] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageKindSummaryByIdResponse) String() string { +func (x *RequireStorageOptionalProcessedMetadataByIdResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageKindSummaryByIdResponse) ProtoMessage() {} +func (*RequireStorageOptionalProcessedMetadataByIdResponse) ProtoMessage() {} -func (x *RequireStorageKindSummaryByIdResponse) ProtoReflect() protoreflect.Message { +func (x *RequireStorageOptionalProcessedMetadataByIdResponse) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[267] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12473,39 +12454,39 @@ func (x *RequireStorageKindSummaryByIdResponse) ProtoReflect() protoreflect.Mess return mi.MessageOf(x) } -// Deprecated: Use RequireStorageKindSummaryByIdResponse.ProtoReflect.Descriptor instead. -func (*RequireStorageKindSummaryByIdResponse) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageOptionalProcessedMetadataByIdResponse.ProtoReflect.Descriptor instead. +func (*RequireStorageOptionalProcessedMetadataByIdResponse) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{267} } -func (x *RequireStorageKindSummaryByIdResponse) GetResult() []*RequireStorageKindSummaryByIdResult { +func (x *RequireStorageOptionalProcessedMetadataByIdResponse) GetResult() []*RequireStorageOptionalProcessedMetadataByIdResult { if x != nil { return x.Result } return nil } -type RequireStorageKindSummaryByIdResult struct { - state protoimpl.MessageState `protogen:"open.v1"` - KindSummary string `protobuf:"bytes,1,opt,name=kind_summary,json=kindSummary,proto3" json:"kind_summary,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type RequireStorageOptionalProcessedMetadataByIdResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + OptionalProcessedMetadata *StorageMetadata `protobuf:"bytes,1,opt,name=optional_processed_metadata,json=optionalProcessedMetadata,proto3" json:"optional_processed_metadata,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *RequireStorageKindSummaryByIdResult) Reset() { - *x = RequireStorageKindSummaryByIdResult{} +func (x *RequireStorageOptionalProcessedMetadataByIdResult) Reset() { + *x = RequireStorageOptionalProcessedMetadataByIdResult{} mi := &file_product_proto_msgTypes[268] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageKindSummaryByIdResult) String() string { +func (x *RequireStorageOptionalProcessedMetadataByIdResult) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageKindSummaryByIdResult) ProtoMessage() {} +func (*RequireStorageOptionalProcessedMetadataByIdResult) ProtoMessage() {} -func (x *RequireStorageKindSummaryByIdResult) ProtoReflect() protoreflect.Message { +func (x *RequireStorageOptionalProcessedMetadataByIdResult) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[268] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12517,39 +12498,39 @@ func (x *RequireStorageKindSummaryByIdResult) ProtoReflect() protoreflect.Messag return mi.MessageOf(x) } -// Deprecated: Use RequireStorageKindSummaryByIdResult.ProtoReflect.Descriptor instead. -func (*RequireStorageKindSummaryByIdResult) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageOptionalProcessedMetadataByIdResult.ProtoReflect.Descriptor instead. +func (*RequireStorageOptionalProcessedMetadataByIdResult) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{268} } -func (x *RequireStorageKindSummaryByIdResult) GetKindSummary() string { +func (x *RequireStorageOptionalProcessedMetadataByIdResult) GetOptionalProcessedMetadata() *StorageMetadata { if x != nil { - return x.KindSummary + return x.OptionalProcessedMetadata } - return "" + return nil } -type RequireStorageKindSummaryByIdFields struct { - state protoimpl.MessageState `protogen:"open.v1"` - StorageKind CategoryKind `protobuf:"varint,1,opt,name=storage_kind,json=storageKind,proto3,enum=productv1.CategoryKind" json:"storage_kind,omitempty"` +type RequireStorageOptionalProcessedMetadataByIdFields struct { + state protoimpl.MessageState `protogen:"open.v1"` + Metadata *RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageKindSummaryByIdFields) Reset() { - *x = RequireStorageKindSummaryByIdFields{} +func (x *RequireStorageOptionalProcessedMetadataByIdFields) Reset() { + *x = RequireStorageOptionalProcessedMetadataByIdFields{} mi := &file_product_proto_msgTypes[269] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageKindSummaryByIdFields) String() string { +func (x *RequireStorageOptionalProcessedMetadataByIdFields) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageKindSummaryByIdFields) ProtoMessage() {} +func (*RequireStorageOptionalProcessedMetadataByIdFields) ProtoMessage() {} -func (x *RequireStorageKindSummaryByIdFields) ProtoReflect() protoreflect.Message { +func (x *RequireStorageOptionalProcessedMetadataByIdFields) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[269] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12561,40 +12542,40 @@ func (x *RequireStorageKindSummaryByIdFields) ProtoReflect() protoreflect.Messag return mi.MessageOf(x) } -// Deprecated: Use RequireStorageKindSummaryByIdFields.ProtoReflect.Descriptor instead. -func (*RequireStorageKindSummaryByIdFields) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageOptionalProcessedMetadataByIdFields.ProtoReflect.Descriptor instead. +func (*RequireStorageOptionalProcessedMetadataByIdFields) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{269} } -func (x *RequireStorageKindSummaryByIdFields) GetStorageKind() CategoryKind { +func (x *RequireStorageOptionalProcessedMetadataByIdFields) GetMetadata() *RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata { if x != nil { - return x.StorageKind + return x.Metadata } - return CategoryKind_CATEGORY_KIND_UNSPECIFIED + return nil } -type RequireStorageCategoryInfoSummaryByIdRequest struct { +type RequireStorageProcessedTagsByIdRequest struct { state protoimpl.MessageState `protogen:"open.v1"` - // RequireStorageCategoryInfoSummaryByIdContext provides the context for the required fields method RequireStorageCategoryInfoSummaryById. - Context []*RequireStorageCategoryInfoSummaryByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` + // RequireStorageProcessedTagsByIdContext provides the context for the required fields method RequireStorageProcessedTagsById. + Context []*RequireStorageProcessedTagsByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageCategoryInfoSummaryByIdRequest) Reset() { - *x = RequireStorageCategoryInfoSummaryByIdRequest{} +func (x *RequireStorageProcessedTagsByIdRequest) Reset() { + *x = RequireStorageProcessedTagsByIdRequest{} mi := &file_product_proto_msgTypes[270] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageCategoryInfoSummaryByIdRequest) String() string { +func (x *RequireStorageProcessedTagsByIdRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageCategoryInfoSummaryByIdRequest) ProtoMessage() {} +func (*RequireStorageProcessedTagsByIdRequest) ProtoMessage() {} -func (x *RequireStorageCategoryInfoSummaryByIdRequest) ProtoReflect() protoreflect.Message { +func (x *RequireStorageProcessedTagsByIdRequest) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[270] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12606,40 +12587,40 @@ func (x *RequireStorageCategoryInfoSummaryByIdRequest) ProtoReflect() protorefle return mi.MessageOf(x) } -// Deprecated: Use RequireStorageCategoryInfoSummaryByIdRequest.ProtoReflect.Descriptor instead. -func (*RequireStorageCategoryInfoSummaryByIdRequest) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageProcessedTagsByIdRequest.ProtoReflect.Descriptor instead. +func (*RequireStorageProcessedTagsByIdRequest) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{270} } -func (x *RequireStorageCategoryInfoSummaryByIdRequest) GetContext() []*RequireStorageCategoryInfoSummaryByIdContext { +func (x *RequireStorageProcessedTagsByIdRequest) GetContext() []*RequireStorageProcessedTagsByIdContext { if x != nil { return x.Context } return nil } -type RequireStorageCategoryInfoSummaryByIdContext struct { - state protoimpl.MessageState `protogen:"open.v1"` - Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` - Fields *RequireStorageCategoryInfoSummaryByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` +type RequireStorageProcessedTagsByIdContext struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Fields *RequireStorageProcessedTagsByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageCategoryInfoSummaryByIdContext) Reset() { - *x = RequireStorageCategoryInfoSummaryByIdContext{} +func (x *RequireStorageProcessedTagsByIdContext) Reset() { + *x = RequireStorageProcessedTagsByIdContext{} mi := &file_product_proto_msgTypes[271] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageCategoryInfoSummaryByIdContext) String() string { +func (x *RequireStorageProcessedTagsByIdContext) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageCategoryInfoSummaryByIdContext) ProtoMessage() {} +func (*RequireStorageProcessedTagsByIdContext) ProtoMessage() {} -func (x *RequireStorageCategoryInfoSummaryByIdContext) ProtoReflect() protoreflect.Message { +func (x *RequireStorageProcessedTagsByIdContext) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[271] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12651,47 +12632,47 @@ func (x *RequireStorageCategoryInfoSummaryByIdContext) ProtoReflect() protorefle return mi.MessageOf(x) } -// Deprecated: Use RequireStorageCategoryInfoSummaryByIdContext.ProtoReflect.Descriptor instead. -func (*RequireStorageCategoryInfoSummaryByIdContext) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageProcessedTagsByIdContext.ProtoReflect.Descriptor instead. +func (*RequireStorageProcessedTagsByIdContext) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{271} } -func (x *RequireStorageCategoryInfoSummaryByIdContext) GetKey() *LookupStorageByIdRequestKey { +func (x *RequireStorageProcessedTagsByIdContext) GetKey() *LookupStorageByIdRequestKey { if x != nil { return x.Key } return nil } -func (x *RequireStorageCategoryInfoSummaryByIdContext) GetFields() *RequireStorageCategoryInfoSummaryByIdFields { +func (x *RequireStorageProcessedTagsByIdContext) GetFields() *RequireStorageProcessedTagsByIdFields { if x != nil { return x.Fields } return nil } -type RequireStorageCategoryInfoSummaryByIdResponse struct { +type RequireStorageProcessedTagsByIdResponse struct { state protoimpl.MessageState `protogen:"open.v1"` - // RequireStorageCategoryInfoSummaryByIdResult provides the result for the required fields method RequireStorageCategoryInfoSummaryById. - Result []*RequireStorageCategoryInfoSummaryByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` + // RequireStorageProcessedTagsByIdResult provides the result for the required fields method RequireStorageProcessedTagsById. + Result []*RequireStorageProcessedTagsByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageCategoryInfoSummaryByIdResponse) Reset() { - *x = RequireStorageCategoryInfoSummaryByIdResponse{} +func (x *RequireStorageProcessedTagsByIdResponse) Reset() { + *x = RequireStorageProcessedTagsByIdResponse{} mi := &file_product_proto_msgTypes[272] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageCategoryInfoSummaryByIdResponse) String() string { +func (x *RequireStorageProcessedTagsByIdResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageCategoryInfoSummaryByIdResponse) ProtoMessage() {} +func (*RequireStorageProcessedTagsByIdResponse) ProtoMessage() {} -func (x *RequireStorageCategoryInfoSummaryByIdResponse) ProtoReflect() protoreflect.Message { +func (x *RequireStorageProcessedTagsByIdResponse) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[272] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12703,39 +12684,39 @@ func (x *RequireStorageCategoryInfoSummaryByIdResponse) ProtoReflect() protorefl return mi.MessageOf(x) } -// Deprecated: Use RequireStorageCategoryInfoSummaryByIdResponse.ProtoReflect.Descriptor instead. -func (*RequireStorageCategoryInfoSummaryByIdResponse) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageProcessedTagsByIdResponse.ProtoReflect.Descriptor instead. +func (*RequireStorageProcessedTagsByIdResponse) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{272} } -func (x *RequireStorageCategoryInfoSummaryByIdResponse) GetResult() []*RequireStorageCategoryInfoSummaryByIdResult { +func (x *RequireStorageProcessedTagsByIdResponse) GetResult() []*RequireStorageProcessedTagsByIdResult { if x != nil { return x.Result } return nil } -type RequireStorageCategoryInfoSummaryByIdResult struct { - state protoimpl.MessageState `protogen:"open.v1"` - CategoryInfoSummary string `protobuf:"bytes,1,opt,name=category_info_summary,json=categoryInfoSummary,proto3" json:"category_info_summary,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type RequireStorageProcessedTagsByIdResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + ProcessedTags []string `protobuf:"bytes,1,rep,name=processed_tags,json=processedTags,proto3" json:"processed_tags,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *RequireStorageCategoryInfoSummaryByIdResult) Reset() { - *x = RequireStorageCategoryInfoSummaryByIdResult{} +func (x *RequireStorageProcessedTagsByIdResult) Reset() { + *x = RequireStorageProcessedTagsByIdResult{} mi := &file_product_proto_msgTypes[273] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageCategoryInfoSummaryByIdResult) String() string { +func (x *RequireStorageProcessedTagsByIdResult) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageCategoryInfoSummaryByIdResult) ProtoMessage() {} +func (*RequireStorageProcessedTagsByIdResult) ProtoMessage() {} -func (x *RequireStorageCategoryInfoSummaryByIdResult) ProtoReflect() protoreflect.Message { +func (x *RequireStorageProcessedTagsByIdResult) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[273] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12747,39 +12728,39 @@ func (x *RequireStorageCategoryInfoSummaryByIdResult) ProtoReflect() protoreflec return mi.MessageOf(x) } -// Deprecated: Use RequireStorageCategoryInfoSummaryByIdResult.ProtoReflect.Descriptor instead. -func (*RequireStorageCategoryInfoSummaryByIdResult) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageProcessedTagsByIdResult.ProtoReflect.Descriptor instead. +func (*RequireStorageProcessedTagsByIdResult) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{273} } -func (x *RequireStorageCategoryInfoSummaryByIdResult) GetCategoryInfoSummary() string { +func (x *RequireStorageProcessedTagsByIdResult) GetProcessedTags() []string { if x != nil { - return x.CategoryInfoSummary + return x.ProcessedTags } - return "" + return nil } -type RequireStorageCategoryInfoSummaryByIdFields struct { - state protoimpl.MessageState `protogen:"open.v1"` - CategoryInfo *RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo `protobuf:"bytes,1,opt,name=category_info,json=categoryInfo,proto3" json:"category_info,omitempty"` +type RequireStorageProcessedTagsByIdFields struct { + state protoimpl.MessageState `protogen:"open.v1"` + Tags []string `protobuf:"bytes,1,rep,name=tags,proto3" json:"tags,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageCategoryInfoSummaryByIdFields) Reset() { - *x = RequireStorageCategoryInfoSummaryByIdFields{} +func (x *RequireStorageProcessedTagsByIdFields) Reset() { + *x = RequireStorageProcessedTagsByIdFields{} mi := &file_product_proto_msgTypes[274] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageCategoryInfoSummaryByIdFields) String() string { +func (x *RequireStorageProcessedTagsByIdFields) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageCategoryInfoSummaryByIdFields) ProtoMessage() {} +func (*RequireStorageProcessedTagsByIdFields) ProtoMessage() {} -func (x *RequireStorageCategoryInfoSummaryByIdFields) ProtoReflect() protoreflect.Message { +func (x *RequireStorageProcessedTagsByIdFields) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[274] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12791,40 +12772,40 @@ func (x *RequireStorageCategoryInfoSummaryByIdFields) ProtoReflect() protoreflec return mi.MessageOf(x) } -// Deprecated: Use RequireStorageCategoryInfoSummaryByIdFields.ProtoReflect.Descriptor instead. -func (*RequireStorageCategoryInfoSummaryByIdFields) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageProcessedTagsByIdFields.ProtoReflect.Descriptor instead. +func (*RequireStorageProcessedTagsByIdFields) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{274} } -func (x *RequireStorageCategoryInfoSummaryByIdFields) GetCategoryInfo() *RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo { +func (x *RequireStorageProcessedTagsByIdFields) GetTags() []string { if x != nil { - return x.CategoryInfo + return x.Tags } return nil } -type RequireWarehouseStockHealthScoreByIdRequest struct { +type RequireStorageOptionalProcessedTagsByIdRequest struct { state protoimpl.MessageState `protogen:"open.v1"` - // RequireWarehouseStockHealthScoreByIdContext provides the context for the required fields method RequireWarehouseStockHealthScoreById. - Context []*RequireWarehouseStockHealthScoreByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` + // RequireStorageOptionalProcessedTagsByIdContext provides the context for the required fields method RequireStorageOptionalProcessedTagsById. + Context []*RequireStorageOptionalProcessedTagsByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireWarehouseStockHealthScoreByIdRequest) Reset() { - *x = RequireWarehouseStockHealthScoreByIdRequest{} +func (x *RequireStorageOptionalProcessedTagsByIdRequest) Reset() { + *x = RequireStorageOptionalProcessedTagsByIdRequest{} mi := &file_product_proto_msgTypes[275] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireWarehouseStockHealthScoreByIdRequest) String() string { +func (x *RequireStorageOptionalProcessedTagsByIdRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireWarehouseStockHealthScoreByIdRequest) ProtoMessage() {} +func (*RequireStorageOptionalProcessedTagsByIdRequest) ProtoMessage() {} -func (x *RequireWarehouseStockHealthScoreByIdRequest) ProtoReflect() protoreflect.Message { +func (x *RequireStorageOptionalProcessedTagsByIdRequest) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[275] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12836,40 +12817,40 @@ func (x *RequireWarehouseStockHealthScoreByIdRequest) ProtoReflect() protoreflec return mi.MessageOf(x) } -// Deprecated: Use RequireWarehouseStockHealthScoreByIdRequest.ProtoReflect.Descriptor instead. -func (*RequireWarehouseStockHealthScoreByIdRequest) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageOptionalProcessedTagsByIdRequest.ProtoReflect.Descriptor instead. +func (*RequireStorageOptionalProcessedTagsByIdRequest) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{275} } -func (x *RequireWarehouseStockHealthScoreByIdRequest) GetContext() []*RequireWarehouseStockHealthScoreByIdContext { +func (x *RequireStorageOptionalProcessedTagsByIdRequest) GetContext() []*RequireStorageOptionalProcessedTagsByIdContext { if x != nil { return x.Context } return nil } -type RequireWarehouseStockHealthScoreByIdContext struct { - state protoimpl.MessageState `protogen:"open.v1"` - Key *LookupWarehouseByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` - Fields *RequireWarehouseStockHealthScoreByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` +type RequireStorageOptionalProcessedTagsByIdContext struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Fields *RequireStorageOptionalProcessedTagsByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireWarehouseStockHealthScoreByIdContext) Reset() { - *x = RequireWarehouseStockHealthScoreByIdContext{} +func (x *RequireStorageOptionalProcessedTagsByIdContext) Reset() { + *x = RequireStorageOptionalProcessedTagsByIdContext{} mi := &file_product_proto_msgTypes[276] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireWarehouseStockHealthScoreByIdContext) String() string { +func (x *RequireStorageOptionalProcessedTagsByIdContext) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireWarehouseStockHealthScoreByIdContext) ProtoMessage() {} +func (*RequireStorageOptionalProcessedTagsByIdContext) ProtoMessage() {} -func (x *RequireWarehouseStockHealthScoreByIdContext) ProtoReflect() protoreflect.Message { +func (x *RequireStorageOptionalProcessedTagsByIdContext) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[276] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12881,47 +12862,47 @@ func (x *RequireWarehouseStockHealthScoreByIdContext) ProtoReflect() protoreflec return mi.MessageOf(x) } -// Deprecated: Use RequireWarehouseStockHealthScoreByIdContext.ProtoReflect.Descriptor instead. -func (*RequireWarehouseStockHealthScoreByIdContext) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageOptionalProcessedTagsByIdContext.ProtoReflect.Descriptor instead. +func (*RequireStorageOptionalProcessedTagsByIdContext) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{276} } -func (x *RequireWarehouseStockHealthScoreByIdContext) GetKey() *LookupWarehouseByIdRequestKey { +func (x *RequireStorageOptionalProcessedTagsByIdContext) GetKey() *LookupStorageByIdRequestKey { if x != nil { return x.Key } return nil } -func (x *RequireWarehouseStockHealthScoreByIdContext) GetFields() *RequireWarehouseStockHealthScoreByIdFields { +func (x *RequireStorageOptionalProcessedTagsByIdContext) GetFields() *RequireStorageOptionalProcessedTagsByIdFields { if x != nil { return x.Fields } return nil } -type RequireWarehouseStockHealthScoreByIdResponse struct { +type RequireStorageOptionalProcessedTagsByIdResponse struct { state protoimpl.MessageState `protogen:"open.v1"` - // RequireWarehouseStockHealthScoreByIdResult provides the result for the required fields method RequireWarehouseStockHealthScoreById. - Result []*RequireWarehouseStockHealthScoreByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` + // RequireStorageOptionalProcessedTagsByIdResult provides the result for the required fields method RequireStorageOptionalProcessedTagsById. + Result []*RequireStorageOptionalProcessedTagsByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireWarehouseStockHealthScoreByIdResponse) Reset() { - *x = RequireWarehouseStockHealthScoreByIdResponse{} +func (x *RequireStorageOptionalProcessedTagsByIdResponse) Reset() { + *x = RequireStorageOptionalProcessedTagsByIdResponse{} mi := &file_product_proto_msgTypes[277] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireWarehouseStockHealthScoreByIdResponse) String() string { +func (x *RequireStorageOptionalProcessedTagsByIdResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireWarehouseStockHealthScoreByIdResponse) ProtoMessage() {} +func (*RequireStorageOptionalProcessedTagsByIdResponse) ProtoMessage() {} -func (x *RequireWarehouseStockHealthScoreByIdResponse) ProtoReflect() protoreflect.Message { +func (x *RequireStorageOptionalProcessedTagsByIdResponse) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[277] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12933,39 +12914,39 @@ func (x *RequireWarehouseStockHealthScoreByIdResponse) ProtoReflect() protorefle return mi.MessageOf(x) } -// Deprecated: Use RequireWarehouseStockHealthScoreByIdResponse.ProtoReflect.Descriptor instead. -func (*RequireWarehouseStockHealthScoreByIdResponse) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageOptionalProcessedTagsByIdResponse.ProtoReflect.Descriptor instead. +func (*RequireStorageOptionalProcessedTagsByIdResponse) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{277} } -func (x *RequireWarehouseStockHealthScoreByIdResponse) GetResult() []*RequireWarehouseStockHealthScoreByIdResult { +func (x *RequireStorageOptionalProcessedTagsByIdResponse) GetResult() []*RequireStorageOptionalProcessedTagsByIdResult { if x != nil { return x.Result } return nil } -type RequireWarehouseStockHealthScoreByIdResult struct { - state protoimpl.MessageState `protogen:"open.v1"` - StockHealthScore float64 `protobuf:"fixed64,1,opt,name=stock_health_score,json=stockHealthScore,proto3" json:"stock_health_score,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type RequireStorageOptionalProcessedTagsByIdResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + OptionalProcessedTags *ListOfString `protobuf:"bytes,1,opt,name=optional_processed_tags,json=optionalProcessedTags,proto3" json:"optional_processed_tags,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *RequireWarehouseStockHealthScoreByIdResult) Reset() { - *x = RequireWarehouseStockHealthScoreByIdResult{} +func (x *RequireStorageOptionalProcessedTagsByIdResult) Reset() { + *x = RequireStorageOptionalProcessedTagsByIdResult{} mi := &file_product_proto_msgTypes[278] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireWarehouseStockHealthScoreByIdResult) String() string { +func (x *RequireStorageOptionalProcessedTagsByIdResult) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireWarehouseStockHealthScoreByIdResult) ProtoMessage() {} +func (*RequireStorageOptionalProcessedTagsByIdResult) ProtoMessage() {} -func (x *RequireWarehouseStockHealthScoreByIdResult) ProtoReflect() protoreflect.Message { +func (x *RequireStorageOptionalProcessedTagsByIdResult) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[278] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12977,40 +12958,39 @@ func (x *RequireWarehouseStockHealthScoreByIdResult) ProtoReflect() protoreflect return mi.MessageOf(x) } -// Deprecated: Use RequireWarehouseStockHealthScoreByIdResult.ProtoReflect.Descriptor instead. -func (*RequireWarehouseStockHealthScoreByIdResult) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageOptionalProcessedTagsByIdResult.ProtoReflect.Descriptor instead. +func (*RequireStorageOptionalProcessedTagsByIdResult) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{278} } -func (x *RequireWarehouseStockHealthScoreByIdResult) GetStockHealthScore() float64 { +func (x *RequireStorageOptionalProcessedTagsByIdResult) GetOptionalProcessedTags() *ListOfString { if x != nil { - return x.StockHealthScore + return x.OptionalProcessedTags } - return 0 + return nil } -type RequireWarehouseStockHealthScoreByIdFields struct { - state protoimpl.MessageState `protogen:"open.v1"` - InventoryCount int32 `protobuf:"varint,1,opt,name=inventory_count,json=inventoryCount,proto3" json:"inventory_count,omitempty"` - RestockData *RequireWarehouseStockHealthScoreByIdFields_RestockData `protobuf:"bytes,2,opt,name=restock_data,json=restockData,proto3" json:"restock_data,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type RequireStorageOptionalProcessedTagsByIdFields struct { + state protoimpl.MessageState `protogen:"open.v1"` + OptionalTags *ListOfString `protobuf:"bytes,1,opt,name=optional_tags,json=optionalTags,proto3" json:"optional_tags,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *RequireWarehouseStockHealthScoreByIdFields) Reset() { - *x = RequireWarehouseStockHealthScoreByIdFields{} +func (x *RequireStorageOptionalProcessedTagsByIdFields) Reset() { + *x = RequireStorageOptionalProcessedTagsByIdFields{} mi := &file_product_proto_msgTypes[279] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireWarehouseStockHealthScoreByIdFields) String() string { +func (x *RequireStorageOptionalProcessedTagsByIdFields) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireWarehouseStockHealthScoreByIdFields) ProtoMessage() {} +func (*RequireStorageOptionalProcessedTagsByIdFields) ProtoMessage() {} -func (x *RequireWarehouseStockHealthScoreByIdFields) ProtoReflect() protoreflect.Message { +func (x *RequireStorageOptionalProcessedTagsByIdFields) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[279] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -13022,48 +13002,40 @@ func (x *RequireWarehouseStockHealthScoreByIdFields) ProtoReflect() protoreflect return mi.MessageOf(x) } -// Deprecated: Use RequireWarehouseStockHealthScoreByIdFields.ProtoReflect.Descriptor instead. -func (*RequireWarehouseStockHealthScoreByIdFields) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageOptionalProcessedTagsByIdFields.ProtoReflect.Descriptor instead. +func (*RequireStorageOptionalProcessedTagsByIdFields) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{279} } -func (x *RequireWarehouseStockHealthScoreByIdFields) GetInventoryCount() int32 { - if x != nil { - return x.InventoryCount - } - return 0 -} - -func (x *RequireWarehouseStockHealthScoreByIdFields) GetRestockData() *RequireWarehouseStockHealthScoreByIdFields_RestockData { +func (x *RequireStorageOptionalProcessedTagsByIdFields) GetOptionalTags() *ListOfString { if x != nil { - return x.RestockData + return x.OptionalTags } return nil } -type Product struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` - Price float64 `protobuf:"fixed64,3,opt,name=price,proto3" json:"price,omitempty"` +type RequireStorageProcessedMetadataHistoryByIdRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // RequireStorageProcessedMetadataHistoryByIdContext provides the context for the required fields method RequireStorageProcessedMetadataHistoryById. + Context []*RequireStorageProcessedMetadataHistoryByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *Product) Reset() { - *x = Product{} +func (x *RequireStorageProcessedMetadataHistoryByIdRequest) Reset() { + *x = RequireStorageProcessedMetadataHistoryByIdRequest{} mi := &file_product_proto_msgTypes[280] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *Product) String() string { +func (x *RequireStorageProcessedMetadataHistoryByIdRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*Product) ProtoMessage() {} +func (*RequireStorageProcessedMetadataHistoryByIdRequest) ProtoMessage() {} -func (x *Product) ProtoReflect() protoreflect.Message { +func (x *RequireStorageProcessedMetadataHistoryByIdRequest) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[280] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -13075,55 +13047,40 @@ func (x *Product) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use Product.ProtoReflect.Descriptor instead. -func (*Product) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageProcessedMetadataHistoryByIdRequest.ProtoReflect.Descriptor instead. +func (*RequireStorageProcessedMetadataHistoryByIdRequest) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{280} } -func (x *Product) GetId() string { - if x != nil { - return x.Id - } - return "" -} - -func (x *Product) GetName() string { - if x != nil { - return x.Name - } - return "" -} - -func (x *Product) GetPrice() float64 { +func (x *RequireStorageProcessedMetadataHistoryByIdRequest) GetContext() []*RequireStorageProcessedMetadataHistoryByIdContext { if x != nil { - return x.Price + return x.Context } - return 0 + return nil } -type Storage struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` - Location string `protobuf:"bytes,3,opt,name=location,proto3" json:"location,omitempty"` +type RequireStorageProcessedMetadataHistoryByIdContext struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Fields *RequireStorageProcessedMetadataHistoryByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *Storage) Reset() { - *x = Storage{} +func (x *RequireStorageProcessedMetadataHistoryByIdContext) Reset() { + *x = RequireStorageProcessedMetadataHistoryByIdContext{} mi := &file_product_proto_msgTypes[281] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *Storage) String() string { +func (x *RequireStorageProcessedMetadataHistoryByIdContext) String() string { return protoimpl.X.MessageStringOf(x) } -func (*Storage) ProtoMessage() {} +func (*RequireStorageProcessedMetadataHistoryByIdContext) ProtoMessage() {} -func (x *Storage) ProtoReflect() protoreflect.Message { +func (x *RequireStorageProcessedMetadataHistoryByIdContext) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[281] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -13135,55 +13092,47 @@ func (x *Storage) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use Storage.ProtoReflect.Descriptor instead. -func (*Storage) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageProcessedMetadataHistoryByIdContext.ProtoReflect.Descriptor instead. +func (*RequireStorageProcessedMetadataHistoryByIdContext) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{281} } -func (x *Storage) GetId() string { - if x != nil { - return x.Id - } - return "" -} - -func (x *Storage) GetName() string { +func (x *RequireStorageProcessedMetadataHistoryByIdContext) GetKey() *LookupStorageByIdRequestKey { if x != nil { - return x.Name + return x.Key } - return "" + return nil } -func (x *Storage) GetLocation() string { +func (x *RequireStorageProcessedMetadataHistoryByIdContext) GetFields() *RequireStorageProcessedMetadataHistoryByIdFields { if x != nil { - return x.Location + return x.Fields } - return "" + return nil } -type Warehouse struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` - Location string `protobuf:"bytes,3,opt,name=location,proto3" json:"location,omitempty"` +type RequireStorageProcessedMetadataHistoryByIdResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // RequireStorageProcessedMetadataHistoryByIdResult provides the result for the required fields method RequireStorageProcessedMetadataHistoryById. + Result []*RequireStorageProcessedMetadataHistoryByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *Warehouse) Reset() { - *x = Warehouse{} +func (x *RequireStorageProcessedMetadataHistoryByIdResponse) Reset() { + *x = RequireStorageProcessedMetadataHistoryByIdResponse{} mi := &file_product_proto_msgTypes[282] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *Warehouse) String() string { +func (x *RequireStorageProcessedMetadataHistoryByIdResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*Warehouse) ProtoMessage() {} +func (*RequireStorageProcessedMetadataHistoryByIdResponse) ProtoMessage() {} -func (x *Warehouse) ProtoReflect() protoreflect.Message { +func (x *RequireStorageProcessedMetadataHistoryByIdResponse) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[282] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -13195,54 +13144,39 @@ func (x *Warehouse) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use Warehouse.ProtoReflect.Descriptor instead. -func (*Warehouse) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageProcessedMetadataHistoryByIdResponse.ProtoReflect.Descriptor instead. +func (*RequireStorageProcessedMetadataHistoryByIdResponse) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{282} } -func (x *Warehouse) GetId() string { - if x != nil { - return x.Id - } - return "" -} - -func (x *Warehouse) GetName() string { - if x != nil { - return x.Name - } - return "" -} - -func (x *Warehouse) GetLocation() string { +func (x *RequireStorageProcessedMetadataHistoryByIdResponse) GetResult() []*RequireStorageProcessedMetadataHistoryByIdResult { if x != nil { - return x.Location + return x.Result } - return "" + return nil } -type User struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type RequireStorageProcessedMetadataHistoryByIdResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + ProcessedMetadataHistory []*StorageMetadata `protobuf:"bytes,1,rep,name=processed_metadata_history,json=processedMetadataHistory,proto3" json:"processed_metadata_history,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *User) Reset() { - *x = User{} +func (x *RequireStorageProcessedMetadataHistoryByIdResult) Reset() { + *x = RequireStorageProcessedMetadataHistoryByIdResult{} mi := &file_product_proto_msgTypes[283] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *User) String() string { +func (x *RequireStorageProcessedMetadataHistoryByIdResult) String() string { return protoimpl.X.MessageStringOf(x) } -func (*User) ProtoMessage() {} +func (*RequireStorageProcessedMetadataHistoryByIdResult) ProtoMessage() {} -func (x *User) ProtoReflect() protoreflect.Message { +func (x *RequireStorageProcessedMetadataHistoryByIdResult) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[283] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -13254,48 +13188,39 @@ func (x *User) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use User.ProtoReflect.Descriptor instead. -func (*User) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageProcessedMetadataHistoryByIdResult.ProtoReflect.Descriptor instead. +func (*RequireStorageProcessedMetadataHistoryByIdResult) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{283} } -func (x *User) GetId() string { +func (x *RequireStorageProcessedMetadataHistoryByIdResult) GetProcessedMetadataHistory() []*StorageMetadata { if x != nil { - return x.Id + return x.ProcessedMetadataHistory } - return "" + return nil } -func (x *User) GetName() string { - if x != nil { - return x.Name - } - return "" +type RequireStorageProcessedMetadataHistoryByIdFields struct { + state protoimpl.MessageState `protogen:"open.v1"` + MetadataHistory []*RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata `protobuf:"bytes,1,rep,name=metadata_history,json=metadataHistory,proto3" json:"metadata_history,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -type NestedTypeA struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` - B *NestedTypeB `protobuf:"bytes,3,opt,name=b,proto3" json:"b,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *NestedTypeA) Reset() { - *x = NestedTypeA{} +func (x *RequireStorageProcessedMetadataHistoryByIdFields) Reset() { + *x = RequireStorageProcessedMetadataHistoryByIdFields{} mi := &file_product_proto_msgTypes[284] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *NestedTypeA) String() string { +func (x *RequireStorageProcessedMetadataHistoryByIdFields) String() string { return protoimpl.X.MessageStringOf(x) } -func (*NestedTypeA) ProtoMessage() {} +func (*RequireStorageProcessedMetadataHistoryByIdFields) ProtoMessage() {} -func (x *NestedTypeA) ProtoReflect() protoreflect.Message { +func (x *RequireStorageProcessedMetadataHistoryByIdFields) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[284] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -13307,55 +13232,40 @@ func (x *NestedTypeA) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use NestedTypeA.ProtoReflect.Descriptor instead. -func (*NestedTypeA) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageProcessedMetadataHistoryByIdFields.ProtoReflect.Descriptor instead. +func (*RequireStorageProcessedMetadataHistoryByIdFields) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{284} } -func (x *NestedTypeA) GetId() string { - if x != nil { - return x.Id - } - return "" -} - -func (x *NestedTypeA) GetName() string { - if x != nil { - return x.Name - } - return "" -} - -func (x *NestedTypeA) GetB() *NestedTypeB { +func (x *RequireStorageProcessedMetadataHistoryByIdFields) GetMetadataHistory() []*RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata { if x != nil { - return x.B + return x.MetadataHistory } return nil } -type RecursiveType struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` - RecursiveType *RecursiveType `protobuf:"bytes,3,opt,name=recursive_type,json=recursiveType,proto3" json:"recursive_type,omitempty"` +type RequireStorageKindSummaryByIdRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // RequireStorageKindSummaryByIdContext provides the context for the required fields method RequireStorageKindSummaryById. + Context []*RequireStorageKindSummaryByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RecursiveType) Reset() { - *x = RecursiveType{} +func (x *RequireStorageKindSummaryByIdRequest) Reset() { + *x = RequireStorageKindSummaryByIdRequest{} mi := &file_product_proto_msgTypes[285] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RecursiveType) String() string { +func (x *RequireStorageKindSummaryByIdRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RecursiveType) ProtoMessage() {} +func (*RequireStorageKindSummaryByIdRequest) ProtoMessage() {} -func (x *RecursiveType) ProtoReflect() protoreflect.Message { +func (x *RequireStorageKindSummaryByIdRequest) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[285] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -13367,56 +13277,40 @@ func (x *RecursiveType) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use RecursiveType.ProtoReflect.Descriptor instead. -func (*RecursiveType) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageKindSummaryByIdRequest.ProtoReflect.Descriptor instead. +func (*RequireStorageKindSummaryByIdRequest) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{285} } -func (x *RecursiveType) GetId() string { - if x != nil { - return x.Id - } - return "" -} - -func (x *RecursiveType) GetName() string { - if x != nil { - return x.Name - } - return "" -} - -func (x *RecursiveType) GetRecursiveType() *RecursiveType { +func (x *RequireStorageKindSummaryByIdRequest) GetContext() []*RequireStorageKindSummaryByIdContext { if x != nil { - return x.RecursiveType + return x.Context } return nil } -type TypeWithMultipleFilterFields struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` - FilterField_1 string `protobuf:"bytes,3,opt,name=filter_field_1,json=filterField1,proto3" json:"filter_field_1,omitempty"` - FilterField_2 string `protobuf:"bytes,4,opt,name=filter_field_2,json=filterField2,proto3" json:"filter_field_2,omitempty"` +type RequireStorageKindSummaryByIdContext struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Fields *RequireStorageKindSummaryByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *TypeWithMultipleFilterFields) Reset() { - *x = TypeWithMultipleFilterFields{} +func (x *RequireStorageKindSummaryByIdContext) Reset() { + *x = RequireStorageKindSummaryByIdContext{} mi := &file_product_proto_msgTypes[286] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *TypeWithMultipleFilterFields) String() string { +func (x *RequireStorageKindSummaryByIdContext) String() string { return protoimpl.X.MessageStringOf(x) } -func (*TypeWithMultipleFilterFields) ProtoMessage() {} +func (*RequireStorageKindSummaryByIdContext) ProtoMessage() {} -func (x *TypeWithMultipleFilterFields) ProtoReflect() protoreflect.Message { +func (x *RequireStorageKindSummaryByIdContext) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[286] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -13428,61 +13322,47 @@ func (x *TypeWithMultipleFilterFields) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use TypeWithMultipleFilterFields.ProtoReflect.Descriptor instead. -func (*TypeWithMultipleFilterFields) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageKindSummaryByIdContext.ProtoReflect.Descriptor instead. +func (*RequireStorageKindSummaryByIdContext) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{286} } -func (x *TypeWithMultipleFilterFields) GetId() string { - if x != nil { - return x.Id - } - return "" -} - -func (x *TypeWithMultipleFilterFields) GetName() string { - if x != nil { - return x.Name - } - return "" -} - -func (x *TypeWithMultipleFilterFields) GetFilterField_1() string { +func (x *RequireStorageKindSummaryByIdContext) GetKey() *LookupStorageByIdRequestKey { if x != nil { - return x.FilterField_1 + return x.Key } - return "" + return nil } -func (x *TypeWithMultipleFilterFields) GetFilterField_2() string { +func (x *RequireStorageKindSummaryByIdContext) GetFields() *RequireStorageKindSummaryByIdFields { if x != nil { - return x.FilterField_2 + return x.Fields } - return "" + return nil } -type FilterTypeInput struct { - state protoimpl.MessageState `protogen:"open.v1"` - FilterField_1 string `protobuf:"bytes,1,opt,name=filter_field_1,json=filterField1,proto3" json:"filter_field_1,omitempty"` - FilterField_2 string `protobuf:"bytes,2,opt,name=filter_field_2,json=filterField2,proto3" json:"filter_field_2,omitempty"` +type RequireStorageKindSummaryByIdResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // RequireStorageKindSummaryByIdResult provides the result for the required fields method RequireStorageKindSummaryById. + Result []*RequireStorageKindSummaryByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *FilterTypeInput) Reset() { - *x = FilterTypeInput{} +func (x *RequireStorageKindSummaryByIdResponse) Reset() { + *x = RequireStorageKindSummaryByIdResponse{} mi := &file_product_proto_msgTypes[287] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *FilterTypeInput) String() string { +func (x *RequireStorageKindSummaryByIdResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*FilterTypeInput) ProtoMessage() {} +func (*RequireStorageKindSummaryByIdResponse) ProtoMessage() {} -func (x *FilterTypeInput) ProtoReflect() protoreflect.Message { +func (x *RequireStorageKindSummaryByIdResponse) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[287] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -13494,46 +13374,39 @@ func (x *FilterTypeInput) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use FilterTypeInput.ProtoReflect.Descriptor instead. -func (*FilterTypeInput) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageKindSummaryByIdResponse.ProtoReflect.Descriptor instead. +func (*RequireStorageKindSummaryByIdResponse) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{287} } -func (x *FilterTypeInput) GetFilterField_1() string { - if x != nil { - return x.FilterField_1 - } - return "" -} - -func (x *FilterTypeInput) GetFilterField_2() string { +func (x *RequireStorageKindSummaryByIdResponse) GetResult() []*RequireStorageKindSummaryByIdResult { if x != nil { - return x.FilterField_2 + return x.Result } - return "" + return nil } -type ComplexFilterTypeInput struct { +type RequireStorageKindSummaryByIdResult struct { state protoimpl.MessageState `protogen:"open.v1"` - Filter *FilterType `protobuf:"bytes,1,opt,name=filter,proto3" json:"filter,omitempty"` + KindSummary string `protobuf:"bytes,1,opt,name=kind_summary,json=kindSummary,proto3" json:"kind_summary,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ComplexFilterTypeInput) Reset() { - *x = ComplexFilterTypeInput{} +func (x *RequireStorageKindSummaryByIdResult) Reset() { + *x = RequireStorageKindSummaryByIdResult{} mi := &file_product_proto_msgTypes[288] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ComplexFilterTypeInput) String() string { +func (x *RequireStorageKindSummaryByIdResult) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ComplexFilterTypeInput) ProtoMessage() {} +func (*RequireStorageKindSummaryByIdResult) ProtoMessage() {} -func (x *ComplexFilterTypeInput) ProtoReflect() protoreflect.Message { +func (x *RequireStorageKindSummaryByIdResult) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[288] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -13545,40 +13418,39 @@ func (x *ComplexFilterTypeInput) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ComplexFilterTypeInput.ProtoReflect.Descriptor instead. -func (*ComplexFilterTypeInput) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageKindSummaryByIdResult.ProtoReflect.Descriptor instead. +func (*RequireStorageKindSummaryByIdResult) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{288} } -func (x *ComplexFilterTypeInput) GetFilter() *FilterType { +func (x *RequireStorageKindSummaryByIdResult) GetKindSummary() string { if x != nil { - return x.Filter + return x.KindSummary } - return nil + return "" } -type TypeWithComplexFilterInput struct { +type RequireStorageKindSummaryByIdFields 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"` + StorageKind CategoryKind `protobuf:"varint,1,opt,name=storage_kind,json=storageKind,proto3,enum=productv1.CategoryKind" json:"storage_kind,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *TypeWithComplexFilterInput) Reset() { - *x = TypeWithComplexFilterInput{} +func (x *RequireStorageKindSummaryByIdFields) Reset() { + *x = RequireStorageKindSummaryByIdFields{} mi := &file_product_proto_msgTypes[289] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *TypeWithComplexFilterInput) String() string { +func (x *RequireStorageKindSummaryByIdFields) String() string { return protoimpl.X.MessageStringOf(x) } -func (*TypeWithComplexFilterInput) ProtoMessage() {} +func (*RequireStorageKindSummaryByIdFields) ProtoMessage() {} -func (x *TypeWithComplexFilterInput) ProtoReflect() protoreflect.Message { +func (x *RequireStorageKindSummaryByIdFields) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[289] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -13590,48 +13462,40 @@ func (x *TypeWithComplexFilterInput) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use TypeWithComplexFilterInput.ProtoReflect.Descriptor instead. -func (*TypeWithComplexFilterInput) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageKindSummaryByIdFields.ProtoReflect.Descriptor instead. +func (*RequireStorageKindSummaryByIdFields) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{289} } -func (x *TypeWithComplexFilterInput) GetId() string { - if x != nil { - return x.Id - } - return "" -} - -func (x *TypeWithComplexFilterInput) GetName() string { +func (x *RequireStorageKindSummaryByIdFields) GetStorageKind() CategoryKind { if x != nil { - return x.Name + return x.StorageKind } - return "" + return CategoryKind_CATEGORY_KIND_UNSPECIFIED } -type OrderInput struct { - state protoimpl.MessageState `protogen:"open.v1"` - OrderId string `protobuf:"bytes,1,opt,name=order_id,json=orderId,proto3" json:"order_id,omitempty"` - CustomerName string `protobuf:"bytes,2,opt,name=customer_name,json=customerName,proto3" json:"customer_name,omitempty"` - Lines []*OrderLineInput `protobuf:"bytes,3,rep,name=lines,proto3" json:"lines,omitempty"` +type RequireStorageCategoryInfoSummaryByIdRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // RequireStorageCategoryInfoSummaryByIdContext provides the context for the required fields method RequireStorageCategoryInfoSummaryById. + Context []*RequireStorageCategoryInfoSummaryByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *OrderInput) Reset() { - *x = OrderInput{} +func (x *RequireStorageCategoryInfoSummaryByIdRequest) Reset() { + *x = RequireStorageCategoryInfoSummaryByIdRequest{} mi := &file_product_proto_msgTypes[290] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *OrderInput) String() string { +func (x *RequireStorageCategoryInfoSummaryByIdRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*OrderInput) ProtoMessage() {} +func (*RequireStorageCategoryInfoSummaryByIdRequest) ProtoMessage() {} -func (x *OrderInput) ProtoReflect() protoreflect.Message { +func (x *RequireStorageCategoryInfoSummaryByIdRequest) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[290] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -13643,56 +13507,40 @@ func (x *OrderInput) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use OrderInput.ProtoReflect.Descriptor instead. -func (*OrderInput) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageCategoryInfoSummaryByIdRequest.ProtoReflect.Descriptor instead. +func (*RequireStorageCategoryInfoSummaryByIdRequest) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{290} } -func (x *OrderInput) GetOrderId() string { +func (x *RequireStorageCategoryInfoSummaryByIdRequest) GetContext() []*RequireStorageCategoryInfoSummaryByIdContext { if x != nil { - return x.OrderId + return x.Context } - return "" + return nil } -func (x *OrderInput) GetCustomerName() string { - if x != nil { - return x.CustomerName - } - return "" -} - -func (x *OrderInput) GetLines() []*OrderLineInput { - if x != nil { - return x.Lines - } - return nil -} - -type Order struct { - state protoimpl.MessageState `protogen:"open.v1"` - OrderId string `protobuf:"bytes,1,opt,name=order_id,json=orderId,proto3" json:"order_id,omitempty"` - CustomerName string `protobuf:"bytes,2,opt,name=customer_name,json=customerName,proto3" json:"customer_name,omitempty"` - TotalItems int32 `protobuf:"varint,3,opt,name=total_items,json=totalItems,proto3" json:"total_items,omitempty"` - OrderLines *ListOfOrderLine `protobuf:"bytes,4,opt,name=order_lines,json=orderLines,proto3" json:"order_lines,omitempty"` +type RequireStorageCategoryInfoSummaryByIdContext struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Fields *RequireStorageCategoryInfoSummaryByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *Order) Reset() { - *x = Order{} +func (x *RequireStorageCategoryInfoSummaryByIdContext) Reset() { + *x = RequireStorageCategoryInfoSummaryByIdContext{} mi := &file_product_proto_msgTypes[291] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *Order) String() string { +func (x *RequireStorageCategoryInfoSummaryByIdContext) String() string { return protoimpl.X.MessageStringOf(x) } -func (*Order) ProtoMessage() {} +func (*RequireStorageCategoryInfoSummaryByIdContext) ProtoMessage() {} -func (x *Order) ProtoReflect() protoreflect.Message { +func (x *RequireStorageCategoryInfoSummaryByIdContext) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[291] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -13704,67 +13552,47 @@ func (x *Order) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use Order.ProtoReflect.Descriptor instead. -func (*Order) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageCategoryInfoSummaryByIdContext.ProtoReflect.Descriptor instead. +func (*RequireStorageCategoryInfoSummaryByIdContext) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{291} } -func (x *Order) GetOrderId() string { - if x != nil { - return x.OrderId - } - return "" -} - -func (x *Order) GetCustomerName() string { - if x != nil { - return x.CustomerName - } - return "" -} - -func (x *Order) GetTotalItems() int32 { +func (x *RequireStorageCategoryInfoSummaryByIdContext) GetKey() *LookupStorageByIdRequestKey { if x != nil { - return x.TotalItems + return x.Key } - return 0 + return nil } -func (x *Order) GetOrderLines() *ListOfOrderLine { +func (x *RequireStorageCategoryInfoSummaryByIdContext) GetFields() *RequireStorageCategoryInfoSummaryByIdFields { if x != nil { - return x.OrderLines + return x.Fields } return nil } -type Category struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` - Kind CategoryKind `protobuf:"varint,3,opt,name=kind,proto3,enum=productv1.CategoryKind" json:"kind,omitempty"` - Subcategories *ListOfSubcategory `protobuf:"bytes,4,opt,name=subcategories,proto3" json:"subcategories,omitempty"` - NullMetrics *CategoryMetrics `protobuf:"bytes,5,opt,name=null_metrics,json=nullMetrics,proto3" json:"null_metrics,omitempty"` - TotalProducts int32 `protobuf:"varint,6,opt,name=total_products,json=totalProducts,proto3" json:"total_products,omitempty"` - TopSubcategory *Subcategory `protobuf:"bytes,7,opt,name=top_subcategory,json=topSubcategory,proto3" json:"top_subcategory,omitempty"` - ActiveSubcategories []*Subcategory `protobuf:"bytes,8,rep,name=active_subcategories,json=activeSubcategories,proto3" json:"active_subcategories,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type RequireStorageCategoryInfoSummaryByIdResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // RequireStorageCategoryInfoSummaryByIdResult provides the result for the required fields method RequireStorageCategoryInfoSummaryById. + Result []*RequireStorageCategoryInfoSummaryByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *Category) Reset() { - *x = Category{} +func (x *RequireStorageCategoryInfoSummaryByIdResponse) Reset() { + *x = RequireStorageCategoryInfoSummaryByIdResponse{} mi := &file_product_proto_msgTypes[292] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *Category) String() string { +func (x *RequireStorageCategoryInfoSummaryByIdResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*Category) ProtoMessage() {} +func (*RequireStorageCategoryInfoSummaryByIdResponse) ProtoMessage() {} -func (x *Category) ProtoReflect() protoreflect.Message { +func (x *RequireStorageCategoryInfoSummaryByIdResponse) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[292] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -13776,89 +13604,39 @@ func (x *Category) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use Category.ProtoReflect.Descriptor instead. -func (*Category) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageCategoryInfoSummaryByIdResponse.ProtoReflect.Descriptor instead. +func (*RequireStorageCategoryInfoSummaryByIdResponse) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{292} } -func (x *Category) GetId() string { - if x != nil { - return x.Id - } - return "" -} - -func (x *Category) GetName() string { - if x != nil { - return x.Name - } - return "" -} - -func (x *Category) GetKind() CategoryKind { - if x != nil { - return x.Kind - } - return CategoryKind_CATEGORY_KIND_UNSPECIFIED -} - -func (x *Category) GetSubcategories() *ListOfSubcategory { - if x != nil { - return x.Subcategories - } - return nil -} - -func (x *Category) GetNullMetrics() *CategoryMetrics { - if x != nil { - return x.NullMetrics - } - return nil -} - -func (x *Category) GetTotalProducts() int32 { - if x != nil { - return x.TotalProducts - } - return 0 -} - -func (x *Category) GetTopSubcategory() *Subcategory { - if x != nil { - return x.TopSubcategory - } - return nil -} - -func (x *Category) GetActiveSubcategories() []*Subcategory { +func (x *RequireStorageCategoryInfoSummaryByIdResponse) GetResult() []*RequireStorageCategoryInfoSummaryByIdResult { if x != nil { - return x.ActiveSubcategories + return x.Result } return nil } -type CategoryFilter struct { - state protoimpl.MessageState `protogen:"open.v1"` - Category CategoryKind `protobuf:"varint,1,opt,name=category,proto3,enum=productv1.CategoryKind" json:"category,omitempty"` - Pagination *Pagination `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type RequireStorageCategoryInfoSummaryByIdResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + CategoryInfoSummary string `protobuf:"bytes,1,opt,name=category_info_summary,json=categoryInfoSummary,proto3" json:"category_info_summary,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *CategoryFilter) Reset() { - *x = CategoryFilter{} +func (x *RequireStorageCategoryInfoSummaryByIdResult) Reset() { + *x = RequireStorageCategoryInfoSummaryByIdResult{} mi := &file_product_proto_msgTypes[293] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *CategoryFilter) String() string { +func (x *RequireStorageCategoryInfoSummaryByIdResult) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CategoryFilter) ProtoMessage() {} +func (*RequireStorageCategoryInfoSummaryByIdResult) ProtoMessage() {} -func (x *CategoryFilter) ProtoReflect() protoreflect.Message { +func (x *RequireStorageCategoryInfoSummaryByIdResult) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[293] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -13870,50 +13648,39 @@ func (x *CategoryFilter) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use CategoryFilter.ProtoReflect.Descriptor instead. -func (*CategoryFilter) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageCategoryInfoSummaryByIdResult.ProtoReflect.Descriptor instead. +func (*RequireStorageCategoryInfoSummaryByIdResult) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{293} } -func (x *CategoryFilter) GetCategory() CategoryKind { - if x != nil { - return x.Category - } - return CategoryKind_CATEGORY_KIND_UNSPECIFIED -} - -func (x *CategoryFilter) GetPagination() *Pagination { +func (x *RequireStorageCategoryInfoSummaryByIdResult) GetCategoryInfoSummary() string { if x != nil { - return x.Pagination + return x.CategoryInfoSummary } - return nil + return "" } -type Animal struct { - state protoimpl.MessageState `protogen:"open.v1"` - // Types that are valid to be assigned to Instance: - // - // *Animal_Cat - // *Animal_Dog - Instance isAnimal_Instance `protobuf_oneof:"instance"` +type RequireStorageCategoryInfoSummaryByIdFields struct { + state protoimpl.MessageState `protogen:"open.v1"` + CategoryInfo *RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo `protobuf:"bytes,1,opt,name=category_info,json=categoryInfo,proto3" json:"category_info,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *Animal) Reset() { - *x = Animal{} +func (x *RequireStorageCategoryInfoSummaryByIdFields) Reset() { + *x = RequireStorageCategoryInfoSummaryByIdFields{} mi := &file_product_proto_msgTypes[294] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *Animal) String() string { +func (x *RequireStorageCategoryInfoSummaryByIdFields) String() string { return protoimpl.X.MessageStringOf(x) } -func (*Animal) ProtoMessage() {} +func (*RequireStorageCategoryInfoSummaryByIdFields) ProtoMessage() {} -func (x *Animal) ProtoReflect() protoreflect.Message { +func (x *RequireStorageCategoryInfoSummaryByIdFields) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[294] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -13925,74 +13692,40 @@ func (x *Animal) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use Animal.ProtoReflect.Descriptor instead. -func (*Animal) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireStorageCategoryInfoSummaryByIdFields.ProtoReflect.Descriptor instead. +func (*RequireStorageCategoryInfoSummaryByIdFields) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{294} } -func (x *Animal) GetInstance() isAnimal_Instance { - if x != nil { - return x.Instance - } - return nil -} - -func (x *Animal) GetCat() *Cat { - if x != nil { - if x, ok := x.Instance.(*Animal_Cat); ok { - return x.Cat - } - } - return nil -} - -func (x *Animal) GetDog() *Dog { +func (x *RequireStorageCategoryInfoSummaryByIdFields) GetCategoryInfo() *RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo { if x != nil { - if x, ok := x.Instance.(*Animal_Dog); ok { - return x.Dog - } + return x.CategoryInfo } return nil } -type isAnimal_Instance interface { - isAnimal_Instance() -} - -type Animal_Cat struct { - Cat *Cat `protobuf:"bytes,1,opt,name=cat,proto3,oneof"` -} - -type Animal_Dog struct { - Dog *Dog `protobuf:"bytes,2,opt,name=dog,proto3,oneof"` -} - -func (*Animal_Cat) isAnimal_Instance() {} - -func (*Animal_Dog) isAnimal_Instance() {} - -type SearchInput struct { - state protoimpl.MessageState `protogen:"open.v1"` - Query string `protobuf:"bytes,1,opt,name=query,proto3" json:"query,omitempty"` - Limit *wrapperspb.Int32Value `protobuf:"bytes,2,opt,name=limit,proto3" json:"limit,omitempty"` +type RequireWarehouseStockHealthScoreByIdRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // RequireWarehouseStockHealthScoreByIdContext provides the context for the required fields method RequireWarehouseStockHealthScoreById. + Context []*RequireWarehouseStockHealthScoreByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *SearchInput) Reset() { - *x = SearchInput{} +func (x *RequireWarehouseStockHealthScoreByIdRequest) Reset() { + *x = RequireWarehouseStockHealthScoreByIdRequest{} mi := &file_product_proto_msgTypes[295] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *SearchInput) String() string { +func (x *RequireWarehouseStockHealthScoreByIdRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*SearchInput) ProtoMessage() {} +func (*RequireWarehouseStockHealthScoreByIdRequest) ProtoMessage() {} -func (x *SearchInput) ProtoReflect() protoreflect.Message { +func (x *RequireWarehouseStockHealthScoreByIdRequest) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[295] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -14004,51 +13737,40 @@ func (x *SearchInput) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use SearchInput.ProtoReflect.Descriptor instead. -func (*SearchInput) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireWarehouseStockHealthScoreByIdRequest.ProtoReflect.Descriptor instead. +func (*RequireWarehouseStockHealthScoreByIdRequest) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{295} } -func (x *SearchInput) GetQuery() string { +func (x *RequireWarehouseStockHealthScoreByIdRequest) GetContext() []*RequireWarehouseStockHealthScoreByIdContext { if x != nil { - return x.Query - } - return "" -} - -func (x *SearchInput) GetLimit() *wrapperspb.Int32Value { - if x != nil { - return x.Limit + return x.Context } return nil } -type SearchResult struct { - state protoimpl.MessageState `protogen:"open.v1"` - // Types that are valid to be assigned to Value: - // - // *SearchResult_Product - // *SearchResult_User - // *SearchResult_Category - Value isSearchResult_Value `protobuf_oneof:"value"` +type RequireWarehouseStockHealthScoreByIdContext struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key *LookupWarehouseByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Fields *RequireWarehouseStockHealthScoreByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *SearchResult) Reset() { - *x = SearchResult{} +func (x *RequireWarehouseStockHealthScoreByIdContext) Reset() { + *x = RequireWarehouseStockHealthScoreByIdContext{} mi := &file_product_proto_msgTypes[296] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *SearchResult) String() string { +func (x *RequireWarehouseStockHealthScoreByIdContext) String() string { return protoimpl.X.MessageStringOf(x) } -func (*SearchResult) ProtoMessage() {} +func (*RequireWarehouseStockHealthScoreByIdContext) ProtoMessage() {} -func (x *SearchResult) ProtoReflect() protoreflect.Message { +func (x *RequireWarehouseStockHealthScoreByIdContext) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[296] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -14060,96 +13782,92 @@ func (x *SearchResult) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use SearchResult.ProtoReflect.Descriptor instead. -func (*SearchResult) Descriptor() ([]byte, []int) { +// Deprecated: Use RequireWarehouseStockHealthScoreByIdContext.ProtoReflect.Descriptor instead. +func (*RequireWarehouseStockHealthScoreByIdContext) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{296} } -func (x *SearchResult) GetValue() isSearchResult_Value { +func (x *RequireWarehouseStockHealthScoreByIdContext) GetKey() *LookupWarehouseByIdRequestKey { if x != nil { - return x.Value + return x.Key } return nil } -func (x *SearchResult) GetProduct() *Product { +func (x *RequireWarehouseStockHealthScoreByIdContext) GetFields() *RequireWarehouseStockHealthScoreByIdFields { if x != nil { - if x, ok := x.Value.(*SearchResult_Product); ok { - return x.Product - } + return x.Fields } return nil } -func (x *SearchResult) GetUser() *User { - if x != nil { - if x, ok := x.Value.(*SearchResult_User); ok { - return x.User - } - } - return nil +type RequireWarehouseStockHealthScoreByIdResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // RequireWarehouseStockHealthScoreByIdResult provides the result for the required fields method RequireWarehouseStockHealthScoreById. + Result []*RequireWarehouseStockHealthScoreByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *SearchResult) GetCategory() *Category { - if x != nil { - if x, ok := x.Value.(*SearchResult_Category); ok { - return x.Category - } - } - return nil +func (x *RequireWarehouseStockHealthScoreByIdResponse) Reset() { + *x = RequireWarehouseStockHealthScoreByIdResponse{} + mi := &file_product_proto_msgTypes[297] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } -type isSearchResult_Value interface { - isSearchResult_Value() +func (x *RequireWarehouseStockHealthScoreByIdResponse) String() string { + return protoimpl.X.MessageStringOf(x) } -type SearchResult_Product struct { - Product *Product `protobuf:"bytes,1,opt,name=product,proto3,oneof"` -} +func (*RequireWarehouseStockHealthScoreByIdResponse) ProtoMessage() {} -type SearchResult_User struct { - User *User `protobuf:"bytes,2,opt,name=user,proto3,oneof"` +func (x *RequireWarehouseStockHealthScoreByIdResponse) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[297] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) } -type SearchResult_Category struct { - Category *Category `protobuf:"bytes,3,opt,name=category,proto3,oneof"` +// Deprecated: Use RequireWarehouseStockHealthScoreByIdResponse.ProtoReflect.Descriptor instead. +func (*RequireWarehouseStockHealthScoreByIdResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{297} } -func (*SearchResult_Product) isSearchResult_Value() {} - -func (*SearchResult_User) isSearchResult_Value() {} - -func (*SearchResult_Category) isSearchResult_Value() {} +func (x *RequireWarehouseStockHealthScoreByIdResponse) GetResult() []*RequireWarehouseStockHealthScoreByIdResult { + if x != nil { + return x.Result + } + return nil +} -type NullableFieldsType struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` - OptionalString *wrapperspb.StringValue `protobuf:"bytes,3,opt,name=optional_string,json=optionalString,proto3" json:"optional_string,omitempty"` - OptionalInt *wrapperspb.Int32Value `protobuf:"bytes,4,opt,name=optional_int,json=optionalInt,proto3" json:"optional_int,omitempty"` - OptionalFloat *wrapperspb.DoubleValue `protobuf:"bytes,5,opt,name=optional_float,json=optionalFloat,proto3" json:"optional_float,omitempty"` - OptionalBoolean *wrapperspb.BoolValue `protobuf:"bytes,6,opt,name=optional_boolean,json=optionalBoolean,proto3" json:"optional_boolean,omitempty"` - RequiredString string `protobuf:"bytes,7,opt,name=required_string,json=requiredString,proto3" json:"required_string,omitempty"` - RequiredInt int32 `protobuf:"varint,8,opt,name=required_int,json=requiredInt,proto3" json:"required_int,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type RequireWarehouseStockHealthScoreByIdResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + StockHealthScore float64 `protobuf:"fixed64,1,opt,name=stock_health_score,json=stockHealthScore,proto3" json:"stock_health_score,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *NullableFieldsType) Reset() { - *x = NullableFieldsType{} - mi := &file_product_proto_msgTypes[297] +func (x *RequireWarehouseStockHealthScoreByIdResult) Reset() { + *x = RequireWarehouseStockHealthScoreByIdResult{} + mi := &file_product_proto_msgTypes[298] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *NullableFieldsType) String() string { +func (x *RequireWarehouseStockHealthScoreByIdResult) String() string { return protoimpl.X.MessageStringOf(x) } -func (*NullableFieldsType) ProtoMessage() {} +func (*RequireWarehouseStockHealthScoreByIdResult) ProtoMessage() {} -func (x *NullableFieldsType) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[297] +func (x *RequireWarehouseStockHealthScoreByIdResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[298] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14160,91 +13878,94 @@ func (x *NullableFieldsType) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use NullableFieldsType.ProtoReflect.Descriptor instead. -func (*NullableFieldsType) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{297} +// Deprecated: Use RequireWarehouseStockHealthScoreByIdResult.ProtoReflect.Descriptor instead. +func (*RequireWarehouseStockHealthScoreByIdResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{298} } -func (x *NullableFieldsType) GetId() string { +func (x *RequireWarehouseStockHealthScoreByIdResult) GetStockHealthScore() float64 { if x != nil { - return x.Id + return x.StockHealthScore } - return "" + return 0 } -func (x *NullableFieldsType) GetName() string { - if x != nil { - return x.Name - } - return "" +type RequireWarehouseStockHealthScoreByIdFields struct { + state protoimpl.MessageState `protogen:"open.v1"` + InventoryCount int32 `protobuf:"varint,1,opt,name=inventory_count,json=inventoryCount,proto3" json:"inventory_count,omitempty"` + RestockData *RequireWarehouseStockHealthScoreByIdFields_RestockData `protobuf:"bytes,2,opt,name=restock_data,json=restockData,proto3" json:"restock_data,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *NullableFieldsType) GetOptionalString() *wrapperspb.StringValue { - if x != nil { - return x.OptionalString - } - return nil +func (x *RequireWarehouseStockHealthScoreByIdFields) Reset() { + *x = RequireWarehouseStockHealthScoreByIdFields{} + mi := &file_product_proto_msgTypes[299] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } -func (x *NullableFieldsType) GetOptionalInt() *wrapperspb.Int32Value { - if x != nil { - return x.OptionalInt - } - return nil +func (x *RequireWarehouseStockHealthScoreByIdFields) String() string { + return protoimpl.X.MessageStringOf(x) } -func (x *NullableFieldsType) GetOptionalFloat() *wrapperspb.DoubleValue { +func (*RequireWarehouseStockHealthScoreByIdFields) ProtoMessage() {} + +func (x *RequireWarehouseStockHealthScoreByIdFields) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[299] if x != nil { - return x.OptionalFloat + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms } - return nil + return mi.MessageOf(x) } -func (x *NullableFieldsType) GetOptionalBoolean() *wrapperspb.BoolValue { - if x != nil { - return x.OptionalBoolean - } - return nil +// Deprecated: Use RequireWarehouseStockHealthScoreByIdFields.ProtoReflect.Descriptor instead. +func (*RequireWarehouseStockHealthScoreByIdFields) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{299} } -func (x *NullableFieldsType) GetRequiredString() string { +func (x *RequireWarehouseStockHealthScoreByIdFields) GetInventoryCount() int32 { if x != nil { - return x.RequiredString + return x.InventoryCount } - return "" + return 0 } -func (x *NullableFieldsType) GetRequiredInt() int32 { +func (x *RequireWarehouseStockHealthScoreByIdFields) GetRestockData() *RequireWarehouseStockHealthScoreByIdFields_RestockData { if x != nil { - return x.RequiredInt + return x.RestockData } - return 0 + return nil } -type NullableFieldsFilter struct { - state protoimpl.MessageState `protogen:"open.v1"` - Name *wrapperspb.StringValue `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` - OptionalString *wrapperspb.StringValue `protobuf:"bytes,2,opt,name=optional_string,json=optionalString,proto3" json:"optional_string,omitempty"` - IncludeNulls *wrapperspb.BoolValue `protobuf:"bytes,3,opt,name=include_nulls,json=includeNulls,proto3" json:"include_nulls,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type Product struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + Price float64 `protobuf:"fixed64,3,opt,name=price,proto3" json:"price,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *NullableFieldsFilter) Reset() { - *x = NullableFieldsFilter{} - mi := &file_product_proto_msgTypes[298] +func (x *Product) Reset() { + *x = Product{} + mi := &file_product_proto_msgTypes[300] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *NullableFieldsFilter) String() string { +func (x *Product) String() string { return protoimpl.X.MessageStringOf(x) } -func (*NullableFieldsFilter) ProtoMessage() {} +func (*Product) ProtoMessage() {} -func (x *NullableFieldsFilter) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[298] +func (x *Product) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[300] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14255,73 +13976,56 @@ func (x *NullableFieldsFilter) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use NullableFieldsFilter.ProtoReflect.Descriptor instead. -func (*NullableFieldsFilter) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{298} +// Deprecated: Use Product.ProtoReflect.Descriptor instead. +func (*Product) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{300} } -func (x *NullableFieldsFilter) GetName() *wrapperspb.StringValue { +func (x *Product) GetId() string { if x != nil { - return x.Name + return x.Id } - return nil + return "" } -func (x *NullableFieldsFilter) GetOptionalString() *wrapperspb.StringValue { +func (x *Product) GetName() string { if x != nil { - return x.OptionalString + return x.Name } - return nil + return "" } -func (x *NullableFieldsFilter) GetIncludeNulls() *wrapperspb.BoolValue { +func (x *Product) GetPrice() float64 { if x != nil { - return x.IncludeNulls + return x.Price } - return nil + return 0 } -type BlogPost struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Title string `protobuf:"bytes,2,opt,name=title,proto3" json:"title,omitempty"` - Content string `protobuf:"bytes,3,opt,name=content,proto3" json:"content,omitempty"` - Tags []string `protobuf:"bytes,4,rep,name=tags,proto3" json:"tags,omitempty"` - OptionalTags *ListOfString `protobuf:"bytes,5,opt,name=optional_tags,json=optionalTags,proto3" json:"optional_tags,omitempty"` - Categories []string `protobuf:"bytes,6,rep,name=categories,proto3" json:"categories,omitempty"` - Keywords *ListOfString `protobuf:"bytes,7,opt,name=keywords,proto3" json:"keywords,omitempty"` - ViewCounts []int32 `protobuf:"varint,8,rep,packed,name=view_counts,json=viewCounts,proto3" json:"view_counts,omitempty"` - Ratings *ListOfFloat `protobuf:"bytes,9,opt,name=ratings,proto3" json:"ratings,omitempty"` - IsPublished *ListOfBoolean `protobuf:"bytes,10,opt,name=is_published,json=isPublished,proto3" json:"is_published,omitempty"` - TagGroups *ListOfListOfString `protobuf:"bytes,11,opt,name=tag_groups,json=tagGroups,proto3" json:"tag_groups,omitempty"` - RelatedTopics *ListOfListOfString `protobuf:"bytes,12,opt,name=related_topics,json=relatedTopics,proto3" json:"related_topics,omitempty"` - CommentThreads *ListOfListOfString `protobuf:"bytes,13,opt,name=comment_threads,json=commentThreads,proto3" json:"comment_threads,omitempty"` - Suggestions *ListOfListOfString `protobuf:"bytes,14,opt,name=suggestions,proto3" json:"suggestions,omitempty"` - RelatedCategories []*Category `protobuf:"bytes,15,rep,name=related_categories,json=relatedCategories,proto3" json:"related_categories,omitempty"` - Contributors []*User `protobuf:"bytes,16,rep,name=contributors,proto3" json:"contributors,omitempty"` - MentionedProducts *ListOfProduct `protobuf:"bytes,17,opt,name=mentioned_products,json=mentionedProducts,proto3" json:"mentioned_products,omitempty"` - MentionedUsers *ListOfUser `protobuf:"bytes,18,opt,name=mentioned_users,json=mentionedUsers,proto3" json:"mentioned_users,omitempty"` - CategoryGroups *ListOfListOfCategory `protobuf:"bytes,19,opt,name=category_groups,json=categoryGroups,proto3" json:"category_groups,omitempty"` - ContributorTeams *ListOfListOfUser `protobuf:"bytes,20,opt,name=contributor_teams,json=contributorTeams,proto3" json:"contributor_teams,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type Storage struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + Location string `protobuf:"bytes,3,opt,name=location,proto3" json:"location,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *BlogPost) Reset() { - *x = BlogPost{} - mi := &file_product_proto_msgTypes[299] +func (x *Storage) Reset() { + *x = Storage{} + mi := &file_product_proto_msgTypes[301] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *BlogPost) String() string { +func (x *Storage) String() string { return protoimpl.X.MessageStringOf(x) } -func (*BlogPost) ProtoMessage() {} +func (*Storage) ProtoMessage() {} -func (x *BlogPost) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[299] +func (x *Storage) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[301] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14332,175 +14036,168 @@ func (x *BlogPost) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use BlogPost.ProtoReflect.Descriptor instead. -func (*BlogPost) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{299} +// Deprecated: Use Storage.ProtoReflect.Descriptor instead. +func (*Storage) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{301} } -func (x *BlogPost) GetId() string { +func (x *Storage) GetId() string { if x != nil { return x.Id } return "" } -func (x *BlogPost) GetTitle() string { +func (x *Storage) GetName() string { if x != nil { - return x.Title + return x.Name } return "" } -func (x *BlogPost) GetContent() string { +func (x *Storage) GetLocation() string { if x != nil { - return x.Content + return x.Location } return "" } -func (x *BlogPost) GetTags() []string { - if x != nil { - return x.Tags - } - return nil +type Warehouse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + Location string `protobuf:"bytes,3,opt,name=location,proto3" json:"location,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *BlogPost) GetOptionalTags() *ListOfString { - if x != nil { - return x.OptionalTags - } - return nil +func (x *Warehouse) Reset() { + *x = Warehouse{} + mi := &file_product_proto_msgTypes[302] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } -func (x *BlogPost) GetCategories() []string { - if x != nil { - return x.Categories - } - return nil +func (x *Warehouse) String() string { + return protoimpl.X.MessageStringOf(x) } -func (x *BlogPost) GetKeywords() *ListOfString { - if x != nil { - return x.Keywords - } - return nil -} +func (*Warehouse) ProtoMessage() {} -func (x *BlogPost) GetViewCounts() []int32 { +func (x *Warehouse) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[302] if x != nil { - return x.ViewCounts + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms } - return nil + return mi.MessageOf(x) } -func (x *BlogPost) GetRatings() *ListOfFloat { - if x != nil { - return x.Ratings - } - return nil +// Deprecated: Use Warehouse.ProtoReflect.Descriptor instead. +func (*Warehouse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{302} } -func (x *BlogPost) GetIsPublished() *ListOfBoolean { +func (x *Warehouse) GetId() string { if x != nil { - return x.IsPublished + return x.Id } - return nil + return "" } -func (x *BlogPost) GetTagGroups() *ListOfListOfString { +func (x *Warehouse) GetName() string { if x != nil { - return x.TagGroups + return x.Name } - return nil + return "" } -func (x *BlogPost) GetRelatedTopics() *ListOfListOfString { +func (x *Warehouse) GetLocation() string { if x != nil { - return x.RelatedTopics + return x.Location } - return nil + return "" } -func (x *BlogPost) GetCommentThreads() *ListOfListOfString { - if x != nil { - return x.CommentThreads - } - return nil +type User struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *BlogPost) GetSuggestions() *ListOfListOfString { - if x != nil { - return x.Suggestions - } - return nil +func (x *User) Reset() { + *x = User{} + mi := &file_product_proto_msgTypes[303] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } -func (x *BlogPost) GetRelatedCategories() []*Category { - if x != nil { - return x.RelatedCategories - } - return nil +func (x *User) String() string { + return protoimpl.X.MessageStringOf(x) } -func (x *BlogPost) GetContributors() []*User { - if x != nil { - return x.Contributors - } - return nil -} +func (*User) ProtoMessage() {} -func (x *BlogPost) GetMentionedProducts() *ListOfProduct { +func (x *User) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[303] if x != nil { - return x.MentionedProducts + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms } - return nil + return mi.MessageOf(x) } -func (x *BlogPost) GetMentionedUsers() *ListOfUser { - if x != nil { - return x.MentionedUsers - } - return nil +// Deprecated: Use User.ProtoReflect.Descriptor instead. +func (*User) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{303} } -func (x *BlogPost) GetCategoryGroups() *ListOfListOfCategory { +func (x *User) GetId() string { if x != nil { - return x.CategoryGroups + return x.Id } - return nil + return "" } -func (x *BlogPost) GetContributorTeams() *ListOfListOfUser { +func (x *User) GetName() string { if x != nil { - return x.ContributorTeams + return x.Name } - return nil + return "" } -type BlogPostFilter struct { - state protoimpl.MessageState `protogen:"open.v1"` - Title *wrapperspb.StringValue `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"` - HasCategories *wrapperspb.BoolValue `protobuf:"bytes,2,opt,name=has_categories,json=hasCategories,proto3" json:"has_categories,omitempty"` - MinTags *wrapperspb.Int32Value `protobuf:"bytes,3,opt,name=min_tags,json=minTags,proto3" json:"min_tags,omitempty"` +type NestedTypeA struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + B *NestedTypeB `protobuf:"bytes,3,opt,name=b,proto3" json:"b,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *BlogPostFilter) Reset() { - *x = BlogPostFilter{} - mi := &file_product_proto_msgTypes[300] +func (x *NestedTypeA) Reset() { + *x = NestedTypeA{} + mi := &file_product_proto_msgTypes[304] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *BlogPostFilter) String() string { +func (x *NestedTypeA) String() string { return protoimpl.X.MessageStringOf(x) } -func (*BlogPostFilter) ProtoMessage() {} +func (*NestedTypeA) ProtoMessage() {} -func (x *BlogPostFilter) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[300] +func (x *NestedTypeA) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[304] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14511,68 +14208,56 @@ func (x *BlogPostFilter) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use BlogPostFilter.ProtoReflect.Descriptor instead. -func (*BlogPostFilter) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{300} +// Deprecated: Use NestedTypeA.ProtoReflect.Descriptor instead. +func (*NestedTypeA) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{304} } -func (x *BlogPostFilter) GetTitle() *wrapperspb.StringValue { +func (x *NestedTypeA) GetId() string { if x != nil { - return x.Title + return x.Id } - return nil + return "" } -func (x *BlogPostFilter) GetHasCategories() *wrapperspb.BoolValue { +func (x *NestedTypeA) GetName() string { if x != nil { - return x.HasCategories + return x.Name } - return nil + return "" } -func (x *BlogPostFilter) GetMinTags() *wrapperspb.Int32Value { +func (x *NestedTypeA) GetB() *NestedTypeB { if x != nil { - return x.MinTags + return x.B } return nil } -type Author struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` - Email *wrapperspb.StringValue `protobuf:"bytes,3,opt,name=email,proto3" json:"email,omitempty"` - Skills []string `protobuf:"bytes,4,rep,name=skills,proto3" json:"skills,omitempty"` - Languages []string `protobuf:"bytes,5,rep,name=languages,proto3" json:"languages,omitempty"` - SocialLinks *ListOfString `protobuf:"bytes,6,opt,name=social_links,json=socialLinks,proto3" json:"social_links,omitempty"` - TeamsByProject *ListOfListOfString `protobuf:"bytes,7,opt,name=teams_by_project,json=teamsByProject,proto3" json:"teams_by_project,omitempty"` - Collaborations *ListOfListOfString `protobuf:"bytes,8,opt,name=collaborations,proto3" json:"collaborations,omitempty"` - WrittenPosts *ListOfBlogPost `protobuf:"bytes,9,opt,name=written_posts,json=writtenPosts,proto3" json:"written_posts,omitempty"` - FavoriteCategories []*Category `protobuf:"bytes,10,rep,name=favorite_categories,json=favoriteCategories,proto3" json:"favorite_categories,omitempty"` - RelatedAuthors *ListOfUser `protobuf:"bytes,11,opt,name=related_authors,json=relatedAuthors,proto3" json:"related_authors,omitempty"` - ProductReviews *ListOfProduct `protobuf:"bytes,12,opt,name=product_reviews,json=productReviews,proto3" json:"product_reviews,omitempty"` - AuthorGroups *ListOfListOfUser `protobuf:"bytes,13,opt,name=author_groups,json=authorGroups,proto3" json:"author_groups,omitempty"` - CategoryPreferences *ListOfListOfCategory `protobuf:"bytes,14,opt,name=category_preferences,json=categoryPreferences,proto3" json:"category_preferences,omitempty"` - ProjectTeams *ListOfListOfUser `protobuf:"bytes,15,opt,name=project_teams,json=projectTeams,proto3" json:"project_teams,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type RecursiveType struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + RecursiveType *RecursiveType `protobuf:"bytes,3,opt,name=recursive_type,json=recursiveType,proto3" json:"recursive_type,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *Author) Reset() { - *x = Author{} - mi := &file_product_proto_msgTypes[301] +func (x *RecursiveType) Reset() { + *x = RecursiveType{} + mi := &file_product_proto_msgTypes[305] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *Author) String() string { +func (x *RecursiveType) String() string { return protoimpl.X.MessageStringOf(x) } -func (*Author) ProtoMessage() {} +func (*RecursiveType) ProtoMessage() {} -func (x *Author) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[301] +func (x *RecursiveType) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[305] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14583,140 +14268,123 @@ func (x *Author) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use Author.ProtoReflect.Descriptor instead. -func (*Author) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{301} +// Deprecated: Use RecursiveType.ProtoReflect.Descriptor instead. +func (*RecursiveType) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{305} } -func (x *Author) GetId() string { +func (x *RecursiveType) GetId() string { if x != nil { return x.Id } return "" } -func (x *Author) GetName() string { +func (x *RecursiveType) GetName() string { if x != nil { return x.Name } return "" } -func (x *Author) GetEmail() *wrapperspb.StringValue { - if x != nil { - return x.Email - } - return nil -} - -func (x *Author) GetSkills() []string { - if x != nil { - return x.Skills - } - return nil -} - -func (x *Author) GetLanguages() []string { +func (x *RecursiveType) GetRecursiveType() *RecursiveType { if x != nil { - return x.Languages + return x.RecursiveType } return nil } -func (x *Author) GetSocialLinks() *ListOfString { - if x != nil { - return x.SocialLinks - } - return nil +type TypeWithMultipleFilterFields struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + FilterField_1 string `protobuf:"bytes,3,opt,name=filter_field_1,json=filterField1,proto3" json:"filter_field_1,omitempty"` + FilterField_2 string `protobuf:"bytes,4,opt,name=filter_field_2,json=filterField2,proto3" json:"filter_field_2,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *Author) GetTeamsByProject() *ListOfListOfString { - if x != nil { - return x.TeamsByProject - } - return nil +func (x *TypeWithMultipleFilterFields) Reset() { + *x = TypeWithMultipleFilterFields{} + mi := &file_product_proto_msgTypes[306] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } -func (x *Author) GetCollaborations() *ListOfListOfString { - if x != nil { - return x.Collaborations - } - return nil +func (x *TypeWithMultipleFilterFields) String() string { + return protoimpl.X.MessageStringOf(x) } -func (x *Author) GetWrittenPosts() *ListOfBlogPost { - if x != nil { - return x.WrittenPosts - } - return nil -} +func (*TypeWithMultipleFilterFields) ProtoMessage() {} -func (x *Author) GetFavoriteCategories() []*Category { +func (x *TypeWithMultipleFilterFields) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[306] if x != nil { - return x.FavoriteCategories + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms } - return nil + return mi.MessageOf(x) } -func (x *Author) GetRelatedAuthors() *ListOfUser { - if x != nil { - return x.RelatedAuthors - } - return nil +// Deprecated: Use TypeWithMultipleFilterFields.ProtoReflect.Descriptor instead. +func (*TypeWithMultipleFilterFields) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{306} } -func (x *Author) GetProductReviews() *ListOfProduct { +func (x *TypeWithMultipleFilterFields) GetId() string { if x != nil { - return x.ProductReviews + return x.Id } - return nil + return "" } -func (x *Author) GetAuthorGroups() *ListOfListOfUser { +func (x *TypeWithMultipleFilterFields) GetName() string { if x != nil { - return x.AuthorGroups + return x.Name } - return nil + return "" } -func (x *Author) GetCategoryPreferences() *ListOfListOfCategory { +func (x *TypeWithMultipleFilterFields) GetFilterField_1() string { if x != nil { - return x.CategoryPreferences + return x.FilterField_1 } - return nil + return "" } -func (x *Author) GetProjectTeams() *ListOfListOfUser { +func (x *TypeWithMultipleFilterFields) GetFilterField_2() string { if x != nil { - return x.ProjectTeams + return x.FilterField_2 } - return nil + return "" } -type AuthorFilter struct { - state protoimpl.MessageState `protogen:"open.v1"` - Name *wrapperspb.StringValue `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` - HasTeams *wrapperspb.BoolValue `protobuf:"bytes,2,opt,name=has_teams,json=hasTeams,proto3" json:"has_teams,omitempty"` - SkillCount *wrapperspb.Int32Value `protobuf:"bytes,3,opt,name=skill_count,json=skillCount,proto3" json:"skill_count,omitempty"` +type FilterTypeInput struct { + state protoimpl.MessageState `protogen:"open.v1"` + FilterField_1 string `protobuf:"bytes,1,opt,name=filter_field_1,json=filterField1,proto3" json:"filter_field_1,omitempty"` + FilterField_2 string `protobuf:"bytes,2,opt,name=filter_field_2,json=filterField2,proto3" json:"filter_field_2,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *AuthorFilter) Reset() { - *x = AuthorFilter{} - mi := &file_product_proto_msgTypes[302] +func (x *FilterTypeInput) Reset() { + *x = FilterTypeInput{} + mi := &file_product_proto_msgTypes[307] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *AuthorFilter) String() string { +func (x *FilterTypeInput) String() string { return protoimpl.X.MessageStringOf(x) } -func (*AuthorFilter) ProtoMessage() {} +func (*FilterTypeInput) ProtoMessage() {} -func (x *AuthorFilter) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[302] +func (x *FilterTypeInput) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[307] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14727,56 +14395,47 @@ func (x *AuthorFilter) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use AuthorFilter.ProtoReflect.Descriptor instead. -func (*AuthorFilter) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{302} -} - -func (x *AuthorFilter) GetName() *wrapperspb.StringValue { - if x != nil { - return x.Name - } - return nil +// Deprecated: Use FilterTypeInput.ProtoReflect.Descriptor instead. +func (*FilterTypeInput) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{307} } -func (x *AuthorFilter) GetHasTeams() *wrapperspb.BoolValue { +func (x *FilterTypeInput) GetFilterField_1() string { if x != nil { - return x.HasTeams + return x.FilterField_1 } - return nil + return "" } -func (x *AuthorFilter) GetSkillCount() *wrapperspb.Int32Value { +func (x *FilterTypeInput) GetFilterField_2() string { if x != nil { - return x.SkillCount + return x.FilterField_2 } - return nil + return "" } -type TestContainer struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` - Description *wrapperspb.StringValue `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"` +type ComplexFilterTypeInput struct { + state protoimpl.MessageState `protogen:"open.v1"` + Filter *FilterType `protobuf:"bytes,1,opt,name=filter,proto3" json:"filter,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *TestContainer) Reset() { - *x = TestContainer{} - mi := &file_product_proto_msgTypes[303] +func (x *ComplexFilterTypeInput) Reset() { + *x = ComplexFilterTypeInput{} + mi := &file_product_proto_msgTypes[308] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *TestContainer) String() string { +func (x *ComplexFilterTypeInput) String() string { return protoimpl.X.MessageStringOf(x) } -func (*TestContainer) ProtoMessage() {} +func (*ComplexFilterTypeInput) ProtoMessage() {} -func (x *TestContainer) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[303] +func (x *ComplexFilterTypeInput) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[308] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14787,54 +14446,41 @@ func (x *TestContainer) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use TestContainer.ProtoReflect.Descriptor instead. -func (*TestContainer) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{303} -} - -func (x *TestContainer) GetId() string { - if x != nil { - return x.Id - } - return "" -} - -func (x *TestContainer) GetName() string { - if x != nil { - return x.Name - } - return "" +// Deprecated: Use ComplexFilterTypeInput.ProtoReflect.Descriptor instead. +func (*ComplexFilterTypeInput) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{308} } -func (x *TestContainer) GetDescription() *wrapperspb.StringValue { +func (x *ComplexFilterTypeInput) GetFilter() *FilterType { if x != nil { - return x.Description + return x.Filter } return nil } -type UserInput struct { +type TypeWithComplexFilterInput struct { state protoimpl.MessageState `protogen:"open.v1"` - Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + 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 *UserInput) Reset() { - *x = UserInput{} - mi := &file_product_proto_msgTypes[304] +func (x *TypeWithComplexFilterInput) Reset() { + *x = TypeWithComplexFilterInput{} + mi := &file_product_proto_msgTypes[309] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *UserInput) String() string { +func (x *TypeWithComplexFilterInput) String() string { return protoimpl.X.MessageStringOf(x) } -func (*UserInput) ProtoMessage() {} +func (*TypeWithComplexFilterInput) ProtoMessage() {} -func (x *UserInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[304] +func (x *TypeWithComplexFilterInput) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[309] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14845,41 +14491,49 @@ func (x *UserInput) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use UserInput.ProtoReflect.Descriptor instead. -func (*UserInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{304} +// Deprecated: Use TypeWithComplexFilterInput.ProtoReflect.Descriptor instead. +func (*TypeWithComplexFilterInput) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{309} } -func (x *UserInput) GetName() string { +func (x *TypeWithComplexFilterInput) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *TypeWithComplexFilterInput) GetName() string { if x != nil { return x.Name } return "" } -type ActionInput struct { +type OrderInput struct { state protoimpl.MessageState `protogen:"open.v1"` - Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` - Payload string `protobuf:"bytes,2,opt,name=payload,proto3" json:"payload,omitempty"` + OrderId string `protobuf:"bytes,1,opt,name=order_id,json=orderId,proto3" json:"order_id,omitempty"` + CustomerName string `protobuf:"bytes,2,opt,name=customer_name,json=customerName,proto3" json:"customer_name,omitempty"` + Lines []*OrderLineInput `protobuf:"bytes,3,rep,name=lines,proto3" json:"lines,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ActionInput) Reset() { - *x = ActionInput{} - mi := &file_product_proto_msgTypes[305] +func (x *OrderInput) Reset() { + *x = OrderInput{} + mi := &file_product_proto_msgTypes[310] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ActionInput) String() string { +func (x *OrderInput) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ActionInput) ProtoMessage() {} +func (*OrderInput) ProtoMessage() {} -func (x *ActionInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[305] +func (x *OrderInput) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[310] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14890,51 +14544,57 @@ func (x *ActionInput) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ActionInput.ProtoReflect.Descriptor instead. -func (*ActionInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{305} +// Deprecated: Use OrderInput.ProtoReflect.Descriptor instead. +func (*OrderInput) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{310} } -func (x *ActionInput) GetType() string { +func (x *OrderInput) GetOrderId() string { if x != nil { - return x.Type + return x.OrderId } return "" } -func (x *ActionInput) GetPayload() string { +func (x *OrderInput) GetCustomerName() string { if x != nil { - return x.Payload + return x.CustomerName } return "" } -type ActionResult struct { - state protoimpl.MessageState `protogen:"open.v1"` - // Types that are valid to be assigned to Value: - // - // *ActionResult_ActionSuccess - // *ActionResult_ActionError - Value isActionResult_Value `protobuf_oneof:"value"` +func (x *OrderInput) GetLines() []*OrderLineInput { + if x != nil { + return x.Lines + } + return nil +} + +type Order struct { + state protoimpl.MessageState `protogen:"open.v1"` + OrderId string `protobuf:"bytes,1,opt,name=order_id,json=orderId,proto3" json:"order_id,omitempty"` + CustomerName string `protobuf:"bytes,2,opt,name=customer_name,json=customerName,proto3" json:"customer_name,omitempty"` + TotalItems int32 `protobuf:"varint,3,opt,name=total_items,json=totalItems,proto3" json:"total_items,omitempty"` + OrderLines *ListOfOrderLine `protobuf:"bytes,4,opt,name=order_lines,json=orderLines,proto3" json:"order_lines,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ActionResult) Reset() { - *x = ActionResult{} - mi := &file_product_proto_msgTypes[306] +func (x *Order) Reset() { + *x = Order{} + mi := &file_product_proto_msgTypes[311] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ActionResult) String() string { +func (x *Order) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ActionResult) ProtoMessage() {} +func (*Order) ProtoMessage() {} -func (x *ActionResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[306] +func (x *Order) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[311] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14945,80 +14605,65 @@ func (x *ActionResult) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ActionResult.ProtoReflect.Descriptor instead. -func (*ActionResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{306} +// Deprecated: Use Order.ProtoReflect.Descriptor instead. +func (*Order) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{311} } -func (x *ActionResult) GetValue() isActionResult_Value { +func (x *Order) GetOrderId() string { if x != nil { - return x.Value + return x.OrderId } - return nil + return "" } -func (x *ActionResult) GetActionSuccess() *ActionSuccess { +func (x *Order) GetCustomerName() string { if x != nil { - if x, ok := x.Value.(*ActionResult_ActionSuccess); ok { - return x.ActionSuccess - } + return x.CustomerName } - return nil + return "" } -func (x *ActionResult) GetActionError() *ActionError { +func (x *Order) GetTotalItems() int32 { if x != nil { - if x, ok := x.Value.(*ActionResult_ActionError); ok { - return x.ActionError - } + return x.TotalItems } - return nil -} - -type isActionResult_Value interface { - isActionResult_Value() -} - -type ActionResult_ActionSuccess struct { - ActionSuccess *ActionSuccess `protobuf:"bytes,1,opt,name=action_success,json=actionSuccess,proto3,oneof"` + return 0 } -type ActionResult_ActionError struct { - ActionError *ActionError `protobuf:"bytes,2,opt,name=action_error,json=actionError,proto3,oneof"` +func (x *Order) GetOrderLines() *ListOfOrderLine { + if x != nil { + return x.OrderLines + } + return nil } -func (*ActionResult_ActionSuccess) isActionResult_Value() {} - -func (*ActionResult_ActionError) isActionResult_Value() {} - -type NullableFieldsInput struct { - state protoimpl.MessageState `protogen:"open.v1"` - Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` - OptionalString *wrapperspb.StringValue `protobuf:"bytes,2,opt,name=optional_string,json=optionalString,proto3" json:"optional_string,omitempty"` - OptionalInt *wrapperspb.Int32Value `protobuf:"bytes,3,opt,name=optional_int,json=optionalInt,proto3" json:"optional_int,omitempty"` - OptionalFloat *wrapperspb.DoubleValue `protobuf:"bytes,4,opt,name=optional_float,json=optionalFloat,proto3" json:"optional_float,omitempty"` - OptionalBoolean *wrapperspb.BoolValue `protobuf:"bytes,5,opt,name=optional_boolean,json=optionalBoolean,proto3" json:"optional_boolean,omitempty"` - RequiredString string `protobuf:"bytes,6,opt,name=required_string,json=requiredString,proto3" json:"required_string,omitempty"` - RequiredInt int32 `protobuf:"varint,7,opt,name=required_int,json=requiredInt,proto3" json:"required_int,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type Category struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + Kind CategoryKind `protobuf:"varint,3,opt,name=kind,proto3,enum=productv1.CategoryKind" json:"kind,omitempty"` + Subcategories *ListOfSubcategory `protobuf:"bytes,4,opt,name=subcategories,proto3" json:"subcategories,omitempty"` + NullMetrics *CategoryMetrics `protobuf:"bytes,5,opt,name=null_metrics,json=nullMetrics,proto3" json:"null_metrics,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *NullableFieldsInput) Reset() { - *x = NullableFieldsInput{} - mi := &file_product_proto_msgTypes[307] +func (x *Category) Reset() { + *x = Category{} + mi := &file_product_proto_msgTypes[312] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *NullableFieldsInput) String() string { +func (x *Category) String() string { return protoimpl.X.MessageStringOf(x) } -func (*NullableFieldsInput) ProtoMessage() {} +func (*Category) ProtoMessage() {} -func (x *NullableFieldsInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[307] +func (x *Category) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[312] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15029,97 +14674,69 @@ func (x *NullableFieldsInput) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use NullableFieldsInput.ProtoReflect.Descriptor instead. -func (*NullableFieldsInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{307} +// Deprecated: Use Category.ProtoReflect.Descriptor instead. +func (*Category) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{312} } -func (x *NullableFieldsInput) GetName() string { +func (x *Category) GetId() string { if x != nil { - return x.Name + return x.Id } return "" } -func (x *NullableFieldsInput) GetOptionalString() *wrapperspb.StringValue { +func (x *Category) GetName() string { if x != nil { - return x.OptionalString + return x.Name } - return nil + return "" } -func (x *NullableFieldsInput) GetOptionalInt() *wrapperspb.Int32Value { +func (x *Category) GetKind() CategoryKind { if x != nil { - return x.OptionalInt + return x.Kind } - return nil + return CategoryKind_CATEGORY_KIND_UNSPECIFIED } -func (x *NullableFieldsInput) GetOptionalFloat() *wrapperspb.DoubleValue { +func (x *Category) GetSubcategories() *ListOfSubcategory { if x != nil { - return x.OptionalFloat + return x.Subcategories } return nil } -func (x *NullableFieldsInput) GetOptionalBoolean() *wrapperspb.BoolValue { +func (x *Category) GetNullMetrics() *CategoryMetrics { if x != nil { - return x.OptionalBoolean + return x.NullMetrics } return nil } -func (x *NullableFieldsInput) GetRequiredString() string { - if x != nil { - return x.RequiredString - } - return "" -} - -func (x *NullableFieldsInput) GetRequiredInt() int32 { - if x != nil { - return x.RequiredInt - } - return 0 -} - -type BlogPostInput struct { - state protoimpl.MessageState `protogen:"open.v1"` - Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"` - Content string `protobuf:"bytes,2,opt,name=content,proto3" json:"content,omitempty"` - Tags []string `protobuf:"bytes,3,rep,name=tags,proto3" json:"tags,omitempty"` - OptionalTags *ListOfString `protobuf:"bytes,4,opt,name=optional_tags,json=optionalTags,proto3" json:"optional_tags,omitempty"` - Categories []string `protobuf:"bytes,5,rep,name=categories,proto3" json:"categories,omitempty"` - Keywords *ListOfString `protobuf:"bytes,6,opt,name=keywords,proto3" json:"keywords,omitempty"` - ViewCounts []int32 `protobuf:"varint,7,rep,packed,name=view_counts,json=viewCounts,proto3" json:"view_counts,omitempty"` - Ratings *ListOfFloat `protobuf:"bytes,8,opt,name=ratings,proto3" json:"ratings,omitempty"` - IsPublished *ListOfBoolean `protobuf:"bytes,9,opt,name=is_published,json=isPublished,proto3" json:"is_published,omitempty"` - TagGroups *ListOfListOfString `protobuf:"bytes,10,opt,name=tag_groups,json=tagGroups,proto3" json:"tag_groups,omitempty"` - RelatedTopics *ListOfListOfString `protobuf:"bytes,11,opt,name=related_topics,json=relatedTopics,proto3" json:"related_topics,omitempty"` - CommentThreads *ListOfListOfString `protobuf:"bytes,12,opt,name=comment_threads,json=commentThreads,proto3" json:"comment_threads,omitempty"` - Suggestions *ListOfListOfString `protobuf:"bytes,13,opt,name=suggestions,proto3" json:"suggestions,omitempty"` - RelatedCategories *ListOfCategoryInput `protobuf:"bytes,14,opt,name=related_categories,json=relatedCategories,proto3" json:"related_categories,omitempty"` - Contributors *ListOfUserInput `protobuf:"bytes,15,opt,name=contributors,proto3" json:"contributors,omitempty"` - CategoryGroups *ListOfListOfCategoryInput `protobuf:"bytes,16,opt,name=category_groups,json=categoryGroups,proto3" json:"category_groups,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type CategoryFilter struct { + state protoimpl.MessageState `protogen:"open.v1"` + Category CategoryKind `protobuf:"varint,1,opt,name=category,proto3,enum=productv1.CategoryKind" json:"category,omitempty"` + Pagination *Pagination `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *BlogPostInput) Reset() { - *x = BlogPostInput{} - mi := &file_product_proto_msgTypes[308] +func (x *CategoryFilter) Reset() { + *x = CategoryFilter{} + mi := &file_product_proto_msgTypes[313] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *BlogPostInput) String() string { +func (x *CategoryFilter) String() string { return protoimpl.X.MessageStringOf(x) } -func (*BlogPostInput) ProtoMessage() {} +func (*CategoryFilter) ProtoMessage() {} -func (x *BlogPostInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[308] +func (x *CategoryFilter) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[313] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15130,154 +14747,286 @@ func (x *BlogPostInput) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use BlogPostInput.ProtoReflect.Descriptor instead. -func (*BlogPostInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{308} +// Deprecated: Use CategoryFilter.ProtoReflect.Descriptor instead. +func (*CategoryFilter) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{313} } -func (x *BlogPostInput) GetTitle() string { +func (x *CategoryFilter) GetCategory() CategoryKind { if x != nil { - return x.Title + return x.Category } - return "" + return CategoryKind_CATEGORY_KIND_UNSPECIFIED } -func (x *BlogPostInput) GetContent() string { +func (x *CategoryFilter) GetPagination() *Pagination { if x != nil { - return x.Content + return x.Pagination } - return "" + return nil } -func (x *BlogPostInput) GetTags() []string { - if x != nil { - return x.Tags - } - return nil +type Animal struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Types that are valid to be assigned to Instance: + // + // *Animal_Cat + // *Animal_Dog + Instance isAnimal_Instance `protobuf_oneof:"instance"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *BlogPostInput) GetOptionalTags() *ListOfString { - if x != nil { - return x.OptionalTags - } - return nil +func (x *Animal) Reset() { + *x = Animal{} + mi := &file_product_proto_msgTypes[314] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } -func (x *BlogPostInput) GetCategories() []string { +func (x *Animal) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Animal) ProtoMessage() {} + +func (x *Animal) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[314] if x != nil { - return x.Categories + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms } - return nil + return mi.MessageOf(x) } -func (x *BlogPostInput) GetKeywords() *ListOfString { +// Deprecated: Use Animal.ProtoReflect.Descriptor instead. +func (*Animal) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{314} +} + +func (x *Animal) GetInstance() isAnimal_Instance { if x != nil { - return x.Keywords + return x.Instance } return nil } -func (x *BlogPostInput) GetViewCounts() []int32 { +func (x *Animal) GetCat() *Cat { if x != nil { - return x.ViewCounts + if x, ok := x.Instance.(*Animal_Cat); ok { + return x.Cat + } } return nil } -func (x *BlogPostInput) GetRatings() *ListOfFloat { +func (x *Animal) GetDog() *Dog { if x != nil { - return x.Ratings + if x, ok := x.Instance.(*Animal_Dog); ok { + return x.Dog + } } return nil } -func (x *BlogPostInput) GetIsPublished() *ListOfBoolean { +type isAnimal_Instance interface { + isAnimal_Instance() +} + +type Animal_Cat struct { + Cat *Cat `protobuf:"bytes,1,opt,name=cat,proto3,oneof"` +} + +type Animal_Dog struct { + Dog *Dog `protobuf:"bytes,2,opt,name=dog,proto3,oneof"` +} + +func (*Animal_Cat) isAnimal_Instance() {} + +func (*Animal_Dog) isAnimal_Instance() {} + +type SearchInput struct { + state protoimpl.MessageState `protogen:"open.v1"` + Query string `protobuf:"bytes,1,opt,name=query,proto3" json:"query,omitempty"` + Limit *wrapperspb.Int32Value `protobuf:"bytes,2,opt,name=limit,proto3" json:"limit,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SearchInput) Reset() { + *x = SearchInput{} + mi := &file_product_proto_msgTypes[315] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SearchInput) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SearchInput) ProtoMessage() {} + +func (x *SearchInput) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[315] if x != nil { - return x.IsPublished + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms } - return nil + return mi.MessageOf(x) } -func (x *BlogPostInput) GetTagGroups() *ListOfListOfString { +// Deprecated: Use SearchInput.ProtoReflect.Descriptor instead. +func (*SearchInput) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{315} +} + +func (x *SearchInput) GetQuery() string { if x != nil { - return x.TagGroups + return x.Query } - return nil + return "" } -func (x *BlogPostInput) GetRelatedTopics() *ListOfListOfString { +func (x *SearchInput) GetLimit() *wrapperspb.Int32Value { if x != nil { - return x.RelatedTopics + return x.Limit } return nil } -func (x *BlogPostInput) GetCommentThreads() *ListOfListOfString { +type SearchResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Types that are valid to be assigned to Value: + // + // *SearchResult_Product + // *SearchResult_User + // *SearchResult_Category + Value isSearchResult_Value `protobuf_oneof:"value"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SearchResult) Reset() { + *x = SearchResult{} + mi := &file_product_proto_msgTypes[316] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SearchResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SearchResult) ProtoMessage() {} + +func (x *SearchResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[316] if x != nil { - return x.CommentThreads + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms } - return nil + return mi.MessageOf(x) } -func (x *BlogPostInput) GetSuggestions() *ListOfListOfString { +// Deprecated: Use SearchResult.ProtoReflect.Descriptor instead. +func (*SearchResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{316} +} + +func (x *SearchResult) GetValue() isSearchResult_Value { if x != nil { - return x.Suggestions + return x.Value } return nil } -func (x *BlogPostInput) GetRelatedCategories() *ListOfCategoryInput { +func (x *SearchResult) GetProduct() *Product { if x != nil { - return x.RelatedCategories + if x, ok := x.Value.(*SearchResult_Product); ok { + return x.Product + } } return nil } -func (x *BlogPostInput) GetContributors() *ListOfUserInput { +func (x *SearchResult) GetUser() *User { if x != nil { - return x.Contributors + if x, ok := x.Value.(*SearchResult_User); ok { + return x.User + } } return nil } -func (x *BlogPostInput) GetCategoryGroups() *ListOfListOfCategoryInput { +func (x *SearchResult) GetCategory() *Category { if x != nil { - return x.CategoryGroups + if x, ok := x.Value.(*SearchResult_Category); ok { + return x.Category + } } return nil } -type AuthorInput struct { - state protoimpl.MessageState `protogen:"open.v1"` - Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` - Email *wrapperspb.StringValue `protobuf:"bytes,2,opt,name=email,proto3" json:"email,omitempty"` - Skills []string `protobuf:"bytes,3,rep,name=skills,proto3" json:"skills,omitempty"` - Languages []string `protobuf:"bytes,4,rep,name=languages,proto3" json:"languages,omitempty"` - SocialLinks *ListOfString `protobuf:"bytes,5,opt,name=social_links,json=socialLinks,proto3" json:"social_links,omitempty"` - TeamsByProject *ListOfListOfString `protobuf:"bytes,6,opt,name=teams_by_project,json=teamsByProject,proto3" json:"teams_by_project,omitempty"` - Collaborations *ListOfListOfString `protobuf:"bytes,7,opt,name=collaborations,proto3" json:"collaborations,omitempty"` - FavoriteCategories []*CategoryInput `protobuf:"bytes,8,rep,name=favorite_categories,json=favoriteCategories,proto3" json:"favorite_categories,omitempty"` - AuthorGroups *ListOfListOfUserInput `protobuf:"bytes,9,opt,name=author_groups,json=authorGroups,proto3" json:"author_groups,omitempty"` - ProjectTeams *ListOfListOfUserInput `protobuf:"bytes,10,opt,name=project_teams,json=projectTeams,proto3" json:"project_teams,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type isSearchResult_Value interface { + isSearchResult_Value() } -func (x *AuthorInput) Reset() { - *x = AuthorInput{} - mi := &file_product_proto_msgTypes[309] +type SearchResult_Product struct { + Product *Product `protobuf:"bytes,1,opt,name=product,proto3,oneof"` +} + +type SearchResult_User struct { + User *User `protobuf:"bytes,2,opt,name=user,proto3,oneof"` +} + +type SearchResult_Category struct { + Category *Category `protobuf:"bytes,3,opt,name=category,proto3,oneof"` +} + +func (*SearchResult_Product) isSearchResult_Value() {} + +func (*SearchResult_User) isSearchResult_Value() {} + +func (*SearchResult_Category) isSearchResult_Value() {} + +type NullableFieldsType struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + OptionalString *wrapperspb.StringValue `protobuf:"bytes,3,opt,name=optional_string,json=optionalString,proto3" json:"optional_string,omitempty"` + OptionalInt *wrapperspb.Int32Value `protobuf:"bytes,4,opt,name=optional_int,json=optionalInt,proto3" json:"optional_int,omitempty"` + OptionalFloat *wrapperspb.DoubleValue `protobuf:"bytes,5,opt,name=optional_float,json=optionalFloat,proto3" json:"optional_float,omitempty"` + OptionalBoolean *wrapperspb.BoolValue `protobuf:"bytes,6,opt,name=optional_boolean,json=optionalBoolean,proto3" json:"optional_boolean,omitempty"` + RequiredString string `protobuf:"bytes,7,opt,name=required_string,json=requiredString,proto3" json:"required_string,omitempty"` + RequiredInt int32 `protobuf:"varint,8,opt,name=required_int,json=requiredInt,proto3" json:"required_int,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *NullableFieldsType) Reset() { + *x = NullableFieldsType{} + mi := &file_product_proto_msgTypes[317] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *AuthorInput) String() string { +func (x *NullableFieldsType) String() string { return protoimpl.X.MessageStringOf(x) } -func (*AuthorInput) ProtoMessage() {} +func (*NullableFieldsType) ProtoMessage() {} -func (x *AuthorInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[309] +func (x *NullableFieldsType) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[317] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15288,106 +15037,91 @@ func (x *AuthorInput) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use AuthorInput.ProtoReflect.Descriptor instead. -func (*AuthorInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{309} +// Deprecated: Use NullableFieldsType.ProtoReflect.Descriptor instead. +func (*NullableFieldsType) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{317} } -func (x *AuthorInput) GetName() string { +func (x *NullableFieldsType) GetId() string { if x != nil { - return x.Name + return x.Id } return "" } -func (x *AuthorInput) GetEmail() *wrapperspb.StringValue { - if x != nil { - return x.Email - } - return nil -} - -func (x *AuthorInput) GetSkills() []string { - if x != nil { - return x.Skills - } - return nil -} - -func (x *AuthorInput) GetLanguages() []string { +func (x *NullableFieldsType) GetName() string { if x != nil { - return x.Languages + return x.Name } - return nil + return "" } -func (x *AuthorInput) GetSocialLinks() *ListOfString { +func (x *NullableFieldsType) GetOptionalString() *wrapperspb.StringValue { if x != nil { - return x.SocialLinks + return x.OptionalString } return nil } -func (x *AuthorInput) GetTeamsByProject() *ListOfListOfString { +func (x *NullableFieldsType) GetOptionalInt() *wrapperspb.Int32Value { if x != nil { - return x.TeamsByProject + return x.OptionalInt } return nil } -func (x *AuthorInput) GetCollaborations() *ListOfListOfString { +func (x *NullableFieldsType) GetOptionalFloat() *wrapperspb.DoubleValue { if x != nil { - return x.Collaborations + return x.OptionalFloat } return nil } -func (x *AuthorInput) GetFavoriteCategories() []*CategoryInput { +func (x *NullableFieldsType) GetOptionalBoolean() *wrapperspb.BoolValue { if x != nil { - return x.FavoriteCategories + return x.OptionalBoolean } return nil } -func (x *AuthorInput) GetAuthorGroups() *ListOfListOfUserInput { +func (x *NullableFieldsType) GetRequiredString() string { if x != nil { - return x.AuthorGroups + return x.RequiredString } - return nil + return "" } -func (x *AuthorInput) GetProjectTeams() *ListOfListOfUserInput { +func (x *NullableFieldsType) GetRequiredInt() int32 { if x != nil { - return x.ProjectTeams + return x.RequiredInt } - return nil + return 0 } -type ProductDetails struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"` - ReviewSummary *ActionResult `protobuf:"bytes,3,opt,name=review_summary,json=reviewSummary,proto3" json:"review_summary,omitempty"` - RecommendedPet *Animal `protobuf:"bytes,4,opt,name=recommended_pet,json=recommendedPet,proto3" json:"recommended_pet,omitempty"` +type NullableFieldsFilter struct { + state protoimpl.MessageState `protogen:"open.v1"` + Name *wrapperspb.StringValue `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + OptionalString *wrapperspb.StringValue `protobuf:"bytes,2,opt,name=optional_string,json=optionalString,proto3" json:"optional_string,omitempty"` + IncludeNulls *wrapperspb.BoolValue `protobuf:"bytes,3,opt,name=include_nulls,json=includeNulls,proto3" json:"include_nulls,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ProductDetails) Reset() { - *x = ProductDetails{} - mi := &file_product_proto_msgTypes[310] +func (x *NullableFieldsFilter) Reset() { + *x = NullableFieldsFilter{} + mi := &file_product_proto_msgTypes[318] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ProductDetails) String() string { +func (x *NullableFieldsFilter) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ProductDetails) ProtoMessage() {} +func (*NullableFieldsFilter) ProtoMessage() {} -func (x *ProductDetails) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[310] +func (x *NullableFieldsFilter) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[318] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15398,61 +15132,73 @@ func (x *ProductDetails) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ProductDetails.ProtoReflect.Descriptor instead. -func (*ProductDetails) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{310} -} - -func (x *ProductDetails) GetId() string { - if x != nil { - return x.Id - } - return "" +// Deprecated: Use NullableFieldsFilter.ProtoReflect.Descriptor instead. +func (*NullableFieldsFilter) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{318} } -func (x *ProductDetails) GetDescription() string { +func (x *NullableFieldsFilter) GetName() *wrapperspb.StringValue { if x != nil { - return x.Description + return x.Name } - return "" + return nil } -func (x *ProductDetails) GetReviewSummary() *ActionResult { +func (x *NullableFieldsFilter) GetOptionalString() *wrapperspb.StringValue { if x != nil { - return x.ReviewSummary + return x.OptionalString } return nil } -func (x *ProductDetails) GetRecommendedPet() *Animal { +func (x *NullableFieldsFilter) GetIncludeNulls() *wrapperspb.BoolValue { if x != nil { - return x.RecommendedPet + return x.IncludeNulls } return nil } -type RestockData struct { - state protoimpl.MessageState `protogen:"open.v1"` - LastRestockDate string `protobuf:"bytes,1,opt,name=last_restock_date,json=lastRestockDate,proto3" json:"last_restock_date,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type BlogPost struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Title string `protobuf:"bytes,2,opt,name=title,proto3" json:"title,omitempty"` + Content string `protobuf:"bytes,3,opt,name=content,proto3" json:"content,omitempty"` + Tags []string `protobuf:"bytes,4,rep,name=tags,proto3" json:"tags,omitempty"` + OptionalTags *ListOfString `protobuf:"bytes,5,opt,name=optional_tags,json=optionalTags,proto3" json:"optional_tags,omitempty"` + Categories []string `protobuf:"bytes,6,rep,name=categories,proto3" json:"categories,omitempty"` + Keywords *ListOfString `protobuf:"bytes,7,opt,name=keywords,proto3" json:"keywords,omitempty"` + ViewCounts []int32 `protobuf:"varint,8,rep,packed,name=view_counts,json=viewCounts,proto3" json:"view_counts,omitempty"` + Ratings *ListOfFloat `protobuf:"bytes,9,opt,name=ratings,proto3" json:"ratings,omitempty"` + IsPublished *ListOfBoolean `protobuf:"bytes,10,opt,name=is_published,json=isPublished,proto3" json:"is_published,omitempty"` + TagGroups *ListOfListOfString `protobuf:"bytes,11,opt,name=tag_groups,json=tagGroups,proto3" json:"tag_groups,omitempty"` + RelatedTopics *ListOfListOfString `protobuf:"bytes,12,opt,name=related_topics,json=relatedTopics,proto3" json:"related_topics,omitempty"` + CommentThreads *ListOfListOfString `protobuf:"bytes,13,opt,name=comment_threads,json=commentThreads,proto3" json:"comment_threads,omitempty"` + Suggestions *ListOfListOfString `protobuf:"bytes,14,opt,name=suggestions,proto3" json:"suggestions,omitempty"` + RelatedCategories []*Category `protobuf:"bytes,15,rep,name=related_categories,json=relatedCategories,proto3" json:"related_categories,omitempty"` + Contributors []*User `protobuf:"bytes,16,rep,name=contributors,proto3" json:"contributors,omitempty"` + MentionedProducts *ListOfProduct `protobuf:"bytes,17,opt,name=mentioned_products,json=mentionedProducts,proto3" json:"mentioned_products,omitempty"` + MentionedUsers *ListOfUser `protobuf:"bytes,18,opt,name=mentioned_users,json=mentionedUsers,proto3" json:"mentioned_users,omitempty"` + CategoryGroups *ListOfListOfCategory `protobuf:"bytes,19,opt,name=category_groups,json=categoryGroups,proto3" json:"category_groups,omitempty"` + ContributorTeams *ListOfListOfUser `protobuf:"bytes,20,opt,name=contributor_teams,json=contributorTeams,proto3" json:"contributor_teams,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *RestockData) Reset() { - *x = RestockData{} - mi := &file_product_proto_msgTypes[311] +func (x *BlogPost) Reset() { + *x = BlogPost{} + mi := &file_product_proto_msgTypes[319] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RestockData) String() string { +func (x *BlogPost) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RestockData) ProtoMessage() {} +func (*BlogPost) ProtoMessage() {} -func (x *RestockData) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[311] +func (x *BlogPost) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[319] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15463,154 +15209,175 @@ func (x *RestockData) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use RestockData.ProtoReflect.Descriptor instead. -func (*RestockData) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{311} +// Deprecated: Use BlogPost.ProtoReflect.Descriptor instead. +func (*BlogPost) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{319} } -func (x *RestockData) GetLastRestockDate() string { +func (x *BlogPost) GetId() string { if x != nil { - return x.LastRestockDate + return x.Id } return "" } -type StorageMetadata struct { - state protoimpl.MessageState `protogen:"open.v1"` - Capacity int32 `protobuf:"varint,1,opt,name=capacity,proto3" json:"capacity,omitempty"` - Zone string `protobuf:"bytes,2,opt,name=zone,proto3" json:"zone,omitempty"` - Priority int32 `protobuf:"varint,3,opt,name=priority,proto3" json:"priority,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +func (x *BlogPost) GetTitle() string { + if x != nil { + return x.Title + } + return "" } -func (x *StorageMetadata) Reset() { - *x = StorageMetadata{} - mi := &file_product_proto_msgTypes[312] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) +func (x *BlogPost) GetContent() string { + if x != nil { + return x.Content + } + return "" } -func (x *StorageMetadata) String() string { - return protoimpl.X.MessageStringOf(x) +func (x *BlogPost) GetTags() []string { + if x != nil { + return x.Tags + } + return nil } -func (*StorageMetadata) ProtoMessage() {} +func (x *BlogPost) GetOptionalTags() *ListOfString { + if x != nil { + return x.OptionalTags + } + return nil +} -func (x *StorageMetadata) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[312] +func (x *BlogPost) GetCategories() []string { if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms + return x.Categories } - return mi.MessageOf(x) + return nil } -// Deprecated: Use StorageMetadata.ProtoReflect.Descriptor instead. -func (*StorageMetadata) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{312} +func (x *BlogPost) GetKeywords() *ListOfString { + if x != nil { + return x.Keywords + } + return nil } -func (x *StorageMetadata) GetCapacity() int32 { +func (x *BlogPost) GetViewCounts() []int32 { if x != nil { - return x.Capacity + return x.ViewCounts } - return 0 + return nil } -func (x *StorageMetadata) GetZone() string { +func (x *BlogPost) GetRatings() *ListOfFloat { if x != nil { - return x.Zone + return x.Ratings } - return "" + return nil } -func (x *StorageMetadata) GetPriority() int32 { +func (x *BlogPost) GetIsPublished() *ListOfBoolean { if x != nil { - return x.Priority + return x.IsPublished } - return 0 + return nil } -type StorageCategoryInfo struct { - state protoimpl.MessageState `protogen:"open.v1"` - Kind CategoryKind `protobuf:"varint,1,opt,name=kind,proto3,enum=productv1.CategoryKind" json:"kind,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +func (x *BlogPost) GetTagGroups() *ListOfListOfString { + if x != nil { + return x.TagGroups + } + return nil } -func (x *StorageCategoryInfo) Reset() { - *x = StorageCategoryInfo{} - mi := &file_product_proto_msgTypes[313] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) +func (x *BlogPost) GetRelatedTopics() *ListOfListOfString { + if x != nil { + return x.RelatedTopics + } + return nil } -func (x *StorageCategoryInfo) String() string { - return protoimpl.X.MessageStringOf(x) +func (x *BlogPost) GetCommentThreads() *ListOfListOfString { + if x != nil { + return x.CommentThreads + } + return nil } -func (*StorageCategoryInfo) ProtoMessage() {} +func (x *BlogPost) GetSuggestions() *ListOfListOfString { + if x != nil { + return x.Suggestions + } + return nil +} -func (x *StorageCategoryInfo) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[313] +func (x *BlogPost) GetRelatedCategories() []*Category { if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms + return x.RelatedCategories } - return mi.MessageOf(x) + return nil } -// Deprecated: Use StorageCategoryInfo.ProtoReflect.Descriptor instead. -func (*StorageCategoryInfo) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{313} +func (x *BlogPost) GetContributors() []*User { + if x != nil { + return x.Contributors + } + return nil } -func (x *StorageCategoryInfo) GetKind() CategoryKind { +func (x *BlogPost) GetMentionedProducts() *ListOfProduct { + if x != nil { + return x.MentionedProducts + } + return nil +} + +func (x *BlogPost) GetMentionedUsers() *ListOfUser { + if x != nil { + return x.MentionedUsers + } + return nil +} + +func (x *BlogPost) GetCategoryGroups() *ListOfListOfCategory { if x != nil { - return x.Kind + return x.CategoryGroups } - return CategoryKind_CATEGORY_KIND_UNSPECIFIED + return nil } -func (x *StorageCategoryInfo) GetName() string { +func (x *BlogPost) GetContributorTeams() *ListOfListOfUser { if x != nil { - return x.Name + return x.ContributorTeams } - return "" + return nil } -type NestedTypeB struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` - C *NestedTypeC `protobuf:"bytes,3,opt,name=c,proto3" json:"c,omitempty"` +type BlogPostFilter struct { + state protoimpl.MessageState `protogen:"open.v1"` + Title *wrapperspb.StringValue `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"` + HasCategories *wrapperspb.BoolValue `protobuf:"bytes,2,opt,name=has_categories,json=hasCategories,proto3" json:"has_categories,omitempty"` + MinTags *wrapperspb.Int32Value `protobuf:"bytes,3,opt,name=min_tags,json=minTags,proto3" json:"min_tags,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *NestedTypeB) Reset() { - *x = NestedTypeB{} - mi := &file_product_proto_msgTypes[314] +func (x *BlogPostFilter) Reset() { + *x = BlogPostFilter{} + mi := &file_product_proto_msgTypes[320] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *NestedTypeB) String() string { +func (x *BlogPostFilter) String() string { return protoimpl.X.MessageStringOf(x) } -func (*NestedTypeB) ProtoMessage() {} +func (*BlogPostFilter) ProtoMessage() {} -func (x *NestedTypeB) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[314] +func (x *BlogPostFilter) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[320] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15621,55 +15388,68 @@ func (x *NestedTypeB) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use NestedTypeB.ProtoReflect.Descriptor instead. -func (*NestedTypeB) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{314} +// Deprecated: Use BlogPostFilter.ProtoReflect.Descriptor instead. +func (*BlogPostFilter) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{320} } -func (x *NestedTypeB) GetId() string { +func (x *BlogPostFilter) GetTitle() *wrapperspb.StringValue { if x != nil { - return x.Id + return x.Title } - return "" + return nil } -func (x *NestedTypeB) GetName() string { +func (x *BlogPostFilter) GetHasCategories() *wrapperspb.BoolValue { if x != nil { - return x.Name + return x.HasCategories } - return "" + return nil } -func (x *NestedTypeB) GetC() *NestedTypeC { +func (x *BlogPostFilter) GetMinTags() *wrapperspb.Int32Value { if x != nil { - return x.C + return x.MinTags } return nil } -type NestedTypeC struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type Author struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + Email *wrapperspb.StringValue `protobuf:"bytes,3,opt,name=email,proto3" json:"email,omitempty"` + Skills []string `protobuf:"bytes,4,rep,name=skills,proto3" json:"skills,omitempty"` + Languages []string `protobuf:"bytes,5,rep,name=languages,proto3" json:"languages,omitempty"` + SocialLinks *ListOfString `protobuf:"bytes,6,opt,name=social_links,json=socialLinks,proto3" json:"social_links,omitempty"` + TeamsByProject *ListOfListOfString `protobuf:"bytes,7,opt,name=teams_by_project,json=teamsByProject,proto3" json:"teams_by_project,omitempty"` + Collaborations *ListOfListOfString `protobuf:"bytes,8,opt,name=collaborations,proto3" json:"collaborations,omitempty"` + WrittenPosts *ListOfBlogPost `protobuf:"bytes,9,opt,name=written_posts,json=writtenPosts,proto3" json:"written_posts,omitempty"` + FavoriteCategories []*Category `protobuf:"bytes,10,rep,name=favorite_categories,json=favoriteCategories,proto3" json:"favorite_categories,omitempty"` + RelatedAuthors *ListOfUser `protobuf:"bytes,11,opt,name=related_authors,json=relatedAuthors,proto3" json:"related_authors,omitempty"` + ProductReviews *ListOfProduct `protobuf:"bytes,12,opt,name=product_reviews,json=productReviews,proto3" json:"product_reviews,omitempty"` + AuthorGroups *ListOfListOfUser `protobuf:"bytes,13,opt,name=author_groups,json=authorGroups,proto3" json:"author_groups,omitempty"` + CategoryPreferences *ListOfListOfCategory `protobuf:"bytes,14,opt,name=category_preferences,json=categoryPreferences,proto3" json:"category_preferences,omitempty"` + ProjectTeams *ListOfListOfUser `protobuf:"bytes,15,opt,name=project_teams,json=projectTeams,proto3" json:"project_teams,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *NestedTypeC) Reset() { - *x = NestedTypeC{} - mi := &file_product_proto_msgTypes[315] +func (x *Author) Reset() { + *x = Author{} + mi := &file_product_proto_msgTypes[321] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *NestedTypeC) String() string { +func (x *Author) String() string { return protoimpl.X.MessageStringOf(x) } -func (*NestedTypeC) ProtoMessage() {} +func (*Author) ProtoMessage() {} -func (x *NestedTypeC) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[315] +func (x *Author) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[321] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15680,116 +15460,140 @@ func (x *NestedTypeC) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use NestedTypeC.ProtoReflect.Descriptor instead. -func (*NestedTypeC) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{315} +// Deprecated: Use Author.ProtoReflect.Descriptor instead. +func (*Author) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{321} } -func (x *NestedTypeC) GetId() string { +func (x *Author) GetId() string { if x != nil { return x.Id } return "" } -func (x *NestedTypeC) GetName() string { +func (x *Author) GetName() string { if x != nil { return x.Name } return "" } -type FilterType struct { - state protoimpl.MessageState `protogen:"open.v1"` - Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` - FilterField_1 string `protobuf:"bytes,2,opt,name=filter_field_1,json=filterField1,proto3" json:"filter_field_1,omitempty"` - FilterField_2 string `protobuf:"bytes,3,opt,name=filter_field_2,json=filterField2,proto3" json:"filter_field_2,omitempty"` - Pagination *Pagination `protobuf:"bytes,4,opt,name=pagination,proto3" json:"pagination,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +func (x *Author) GetEmail() *wrapperspb.StringValue { + if x != nil { + return x.Email + } + return nil } -func (x *FilterType) Reset() { - *x = FilterType{} - mi := &file_product_proto_msgTypes[316] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) +func (x *Author) GetSkills() []string { + if x != nil { + return x.Skills + } + return nil } -func (x *FilterType) String() string { - return protoimpl.X.MessageStringOf(x) +func (x *Author) GetLanguages() []string { + if x != nil { + return x.Languages + } + return nil } -func (*FilterType) ProtoMessage() {} +func (x *Author) GetSocialLinks() *ListOfString { + if x != nil { + return x.SocialLinks + } + return nil +} -func (x *FilterType) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[316] +func (x *Author) GetTeamsByProject() *ListOfListOfString { if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms + return x.TeamsByProject } - return mi.MessageOf(x) + return nil } -// Deprecated: Use FilterType.ProtoReflect.Descriptor instead. -func (*FilterType) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{316} +func (x *Author) GetCollaborations() *ListOfListOfString { + if x != nil { + return x.Collaborations + } + return nil } -func (x *FilterType) GetName() string { +func (x *Author) GetWrittenPosts() *ListOfBlogPost { if x != nil { - return x.Name + return x.WrittenPosts } - return "" + return nil } -func (x *FilterType) GetFilterField_1() string { +func (x *Author) GetFavoriteCategories() []*Category { if x != nil { - return x.FilterField_1 + return x.FavoriteCategories } - return "" + return nil } -func (x *FilterType) GetFilterField_2() string { +func (x *Author) GetRelatedAuthors() *ListOfUser { if x != nil { - return x.FilterField_2 + return x.RelatedAuthors } - return "" + return nil } -func (x *FilterType) GetPagination() *Pagination { +func (x *Author) GetProductReviews() *ListOfProduct { if x != nil { - return x.Pagination + return x.ProductReviews } return nil } -type Pagination struct { - state protoimpl.MessageState `protogen:"open.v1"` - Page int32 `protobuf:"varint,1,opt,name=page,proto3" json:"page,omitempty"` - PerPage int32 `protobuf:"varint,2,opt,name=per_page,json=perPage,proto3" json:"per_page,omitempty"` +func (x *Author) GetAuthorGroups() *ListOfListOfUser { + if x != nil { + return x.AuthorGroups + } + return nil +} + +func (x *Author) GetCategoryPreferences() *ListOfListOfCategory { + if x != nil { + return x.CategoryPreferences + } + return nil +} + +func (x *Author) GetProjectTeams() *ListOfListOfUser { + if x != nil { + return x.ProjectTeams + } + return nil +} + +type AuthorFilter struct { + state protoimpl.MessageState `protogen:"open.v1"` + Name *wrapperspb.StringValue `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + HasTeams *wrapperspb.BoolValue `protobuf:"bytes,2,opt,name=has_teams,json=hasTeams,proto3" json:"has_teams,omitempty"` + SkillCount *wrapperspb.Int32Value `protobuf:"bytes,3,opt,name=skill_count,json=skillCount,proto3" json:"skill_count,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *Pagination) Reset() { - *x = Pagination{} - mi := &file_product_proto_msgTypes[317] +func (x *AuthorFilter) Reset() { + *x = AuthorFilter{} + mi := &file_product_proto_msgTypes[322] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *Pagination) String() string { +func (x *AuthorFilter) String() string { return protoimpl.X.MessageStringOf(x) } -func (*Pagination) ProtoMessage() {} +func (*AuthorFilter) ProtoMessage() {} -func (x *Pagination) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[317] +func (x *AuthorFilter) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[322] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15800,49 +15604,56 @@ func (x *Pagination) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use Pagination.ProtoReflect.Descriptor instead. -func (*Pagination) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{317} +// Deprecated: Use AuthorFilter.ProtoReflect.Descriptor instead. +func (*AuthorFilter) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{322} } -func (x *Pagination) GetPage() int32 { +func (x *AuthorFilter) GetName() *wrapperspb.StringValue { if x != nil { - return x.Page + return x.Name } - return 0 + return nil } -func (x *Pagination) GetPerPage() int32 { +func (x *AuthorFilter) GetHasTeams() *wrapperspb.BoolValue { if x != nil { - return x.PerPage + return x.HasTeams } - return 0 + return nil } -type OrderLineInput struct { - state protoimpl.MessageState `protogen:"open.v1"` - ProductId string `protobuf:"bytes,1,opt,name=product_id,json=productId,proto3" json:"product_id,omitempty"` - Quantity int32 `protobuf:"varint,2,opt,name=quantity,proto3" json:"quantity,omitempty"` - Modifiers *ListOfString `protobuf:"bytes,3,opt,name=modifiers,proto3" json:"modifiers,omitempty"` +func (x *AuthorFilter) GetSkillCount() *wrapperspb.Int32Value { + if x != nil { + return x.SkillCount + } + return nil +} + +type TestContainer struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + Description *wrapperspb.StringValue `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *OrderLineInput) Reset() { - *x = OrderLineInput{} - mi := &file_product_proto_msgTypes[318] +func (x *TestContainer) Reset() { + *x = TestContainer{} + mi := &file_product_proto_msgTypes[323] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *OrderLineInput) String() string { +func (x *TestContainer) String() string { return protoimpl.X.MessageStringOf(x) } -func (*OrderLineInput) ProtoMessage() {} +func (*TestContainer) ProtoMessage() {} -func (x *OrderLineInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[318] +func (x *TestContainer) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[323] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15853,56 +15664,54 @@ func (x *OrderLineInput) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use OrderLineInput.ProtoReflect.Descriptor instead. -func (*OrderLineInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{318} +// Deprecated: Use TestContainer.ProtoReflect.Descriptor instead. +func (*TestContainer) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{323} } -func (x *OrderLineInput) GetProductId() string { +func (x *TestContainer) GetId() string { if x != nil { - return x.ProductId + return x.Id } return "" } -func (x *OrderLineInput) GetQuantity() int32 { +func (x *TestContainer) GetName() string { if x != nil { - return x.Quantity + return x.Name } - return 0 + return "" } -func (x *OrderLineInput) GetModifiers() *ListOfString { +func (x *TestContainer) GetDescription() *wrapperspb.StringValue { if x != nil { - return x.Modifiers + return x.Description } return nil } -type OrderLine struct { +type UserInput struct { state protoimpl.MessageState `protogen:"open.v1"` - ProductId string `protobuf:"bytes,1,opt,name=product_id,json=productId,proto3" json:"product_id,omitempty"` - Quantity int32 `protobuf:"varint,2,opt,name=quantity,proto3" json:"quantity,omitempty"` - Modifiers *ListOfString `protobuf:"bytes,3,opt,name=modifiers,proto3" json:"modifiers,omitempty"` + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *OrderLine) Reset() { - *x = OrderLine{} - mi := &file_product_proto_msgTypes[319] +func (x *UserInput) Reset() { + *x = UserInput{} + mi := &file_product_proto_msgTypes[324] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *OrderLine) String() string { +func (x *UserInput) String() string { return protoimpl.X.MessageStringOf(x) } -func (*OrderLine) ProtoMessage() {} +func (*UserInput) ProtoMessage() {} -func (x *OrderLine) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[319] +func (x *UserInput) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[324] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15913,58 +15722,41 @@ func (x *OrderLine) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use OrderLine.ProtoReflect.Descriptor instead. -func (*OrderLine) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{319} +// Deprecated: Use UserInput.ProtoReflect.Descriptor instead. +func (*UserInput) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{324} } -func (x *OrderLine) GetProductId() string { +func (x *UserInput) GetName() string { if x != nil { - return x.ProductId + return x.Name } return "" } -func (x *OrderLine) GetQuantity() int32 { - if x != nil { - return x.Quantity - } - return 0 -} - -func (x *OrderLine) GetModifiers() *ListOfString { - if x != nil { - return x.Modifiers - } - return nil -} - -type Subcategory struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` - Description *wrapperspb.StringValue `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"` - IsActive bool `protobuf:"varint,4,opt,name=is_active,json=isActive,proto3" json:"is_active,omitempty"` - ParentCategory *Category `protobuf:"bytes,5,opt,name=parent_category,json=parentCategory,proto3" json:"parent_category,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type ActionInput struct { + state protoimpl.MessageState `protogen:"open.v1"` + Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` + Payload string `protobuf:"bytes,2,opt,name=payload,proto3" json:"payload,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *Subcategory) Reset() { - *x = Subcategory{} - mi := &file_product_proto_msgTypes[320] +func (x *ActionInput) Reset() { + *x = ActionInput{} + mi := &file_product_proto_msgTypes[325] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *Subcategory) String() string { +func (x *ActionInput) String() string { return protoimpl.X.MessageStringOf(x) } -func (*Subcategory) ProtoMessage() {} +func (*ActionInput) ProtoMessage() {} -func (x *Subcategory) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[320] +func (x *ActionInput) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[325] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15975,73 +15767,51 @@ func (x *Subcategory) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use Subcategory.ProtoReflect.Descriptor instead. -func (*Subcategory) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{320} +// Deprecated: Use ActionInput.ProtoReflect.Descriptor instead. +func (*ActionInput) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{325} } -func (x *Subcategory) GetId() string { +func (x *ActionInput) GetType() string { if x != nil { - return x.Id + return x.Type } return "" } -func (x *Subcategory) GetName() string { +func (x *ActionInput) GetPayload() string { if x != nil { - return x.Name + return x.Payload } return "" } -func (x *Subcategory) GetDescription() *wrapperspb.StringValue { - if x != nil { - return x.Description - } - return nil -} - -func (x *Subcategory) GetIsActive() bool { - if x != nil { - return x.IsActive - } - return false -} - -func (x *Subcategory) GetParentCategory() *Category { - if x != nil { - return x.ParentCategory - } - return nil -} - -type CategoryMetrics struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - MetricType string `protobuf:"bytes,2,opt,name=metric_type,json=metricType,proto3" json:"metric_type,omitempty"` - Value float64 `protobuf:"fixed64,3,opt,name=value,proto3" json:"value,omitempty"` - Timestamp string `protobuf:"bytes,4,opt,name=timestamp,proto3" json:"timestamp,omitempty"` - CategoryId string `protobuf:"bytes,5,opt,name=category_id,json=categoryId,proto3" json:"category_id,omitempty"` - AverageScore float64 `protobuf:"fixed64,6,opt,name=average_score,json=averageScore,proto3" json:"average_score,omitempty"` +type ActionResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Types that are valid to be assigned to Value: + // + // *ActionResult_ActionSuccess + // *ActionResult_ActionError + Value isActionResult_Value `protobuf_oneof:"value"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *CategoryMetrics) Reset() { - *x = CategoryMetrics{} - mi := &file_product_proto_msgTypes[321] +func (x *ActionResult) Reset() { + *x = ActionResult{} + mi := &file_product_proto_msgTypes[326] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *CategoryMetrics) String() string { +func (x *ActionResult) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CategoryMetrics) ProtoMessage() {} +func (*ActionResult) ProtoMessage() {} -func (x *CategoryMetrics) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[321] +func (x *ActionResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[326] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16052,80 +15822,80 @@ func (x *CategoryMetrics) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use CategoryMetrics.ProtoReflect.Descriptor instead. -func (*CategoryMetrics) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{321} +// Deprecated: Use ActionResult.ProtoReflect.Descriptor instead. +func (*ActionResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{326} } -func (x *CategoryMetrics) GetId() string { +func (x *ActionResult) GetValue() isActionResult_Value { if x != nil { - return x.Id + return x.Value } - return "" + return nil } -func (x *CategoryMetrics) GetMetricType() string { +func (x *ActionResult) GetActionSuccess() *ActionSuccess { if x != nil { - return x.MetricType + if x, ok := x.Value.(*ActionResult_ActionSuccess); ok { + return x.ActionSuccess + } } - return "" + return nil } -func (x *CategoryMetrics) GetValue() float64 { +func (x *ActionResult) GetActionError() *ActionError { if x != nil { - return x.Value + if x, ok := x.Value.(*ActionResult_ActionError); ok { + return x.ActionError + } } - return 0 + return nil } -func (x *CategoryMetrics) GetTimestamp() string { - if x != nil { - return x.Timestamp - } - return "" +type isActionResult_Value interface { + isActionResult_Value() } -func (x *CategoryMetrics) GetCategoryId() string { - if x != nil { - return x.CategoryId - } - return "" +type ActionResult_ActionSuccess struct { + ActionSuccess *ActionSuccess `protobuf:"bytes,1,opt,name=action_success,json=actionSuccess,proto3,oneof"` } -func (x *CategoryMetrics) GetAverageScore() float64 { - if x != nil { - return x.AverageScore - } - return 0 +type ActionResult_ActionError struct { + ActionError *ActionError `protobuf:"bytes,2,opt,name=action_error,json=actionError,proto3,oneof"` } -type Cat struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` - Kind string `protobuf:"bytes,3,opt,name=kind,proto3" json:"kind,omitempty"` - MeowVolume int32 `protobuf:"varint,4,opt,name=meow_volume,json=meowVolume,proto3" json:"meow_volume,omitempty"` - Owner *Owner `protobuf:"bytes,5,opt,name=owner,proto3" json:"owner,omitempty"` - Breed *CatBreed `protobuf:"bytes,6,opt,name=breed,proto3" json:"breed,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +func (*ActionResult_ActionSuccess) isActionResult_Value() {} + +func (*ActionResult_ActionError) isActionResult_Value() {} + +type NullableFieldsInput struct { + state protoimpl.MessageState `protogen:"open.v1"` + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + OptionalString *wrapperspb.StringValue `protobuf:"bytes,2,opt,name=optional_string,json=optionalString,proto3" json:"optional_string,omitempty"` + OptionalInt *wrapperspb.Int32Value `protobuf:"bytes,3,opt,name=optional_int,json=optionalInt,proto3" json:"optional_int,omitempty"` + OptionalFloat *wrapperspb.DoubleValue `protobuf:"bytes,4,opt,name=optional_float,json=optionalFloat,proto3" json:"optional_float,omitempty"` + OptionalBoolean *wrapperspb.BoolValue `protobuf:"bytes,5,opt,name=optional_boolean,json=optionalBoolean,proto3" json:"optional_boolean,omitempty"` + RequiredString string `protobuf:"bytes,6,opt,name=required_string,json=requiredString,proto3" json:"required_string,omitempty"` + RequiredInt int32 `protobuf:"varint,7,opt,name=required_int,json=requiredInt,proto3" json:"required_int,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *Cat) Reset() { - *x = Cat{} - mi := &file_product_proto_msgTypes[322] +func (x *NullableFieldsInput) Reset() { + *x = NullableFieldsInput{} + mi := &file_product_proto_msgTypes[327] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *Cat) String() string { +func (x *NullableFieldsInput) String() string { return protoimpl.X.MessageStringOf(x) } -func (*Cat) ProtoMessage() {} +func (*NullableFieldsInput) ProtoMessage() {} -func (x *Cat) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[322] +func (x *NullableFieldsInput) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[327] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16136,80 +15906,97 @@ func (x *Cat) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use Cat.ProtoReflect.Descriptor instead. -func (*Cat) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{322} +// Deprecated: Use NullableFieldsInput.ProtoReflect.Descriptor instead. +func (*NullableFieldsInput) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{327} } -func (x *Cat) GetId() string { +func (x *NullableFieldsInput) GetName() string { if x != nil { - return x.Id + return x.Name } return "" } -func (x *Cat) GetName() string { +func (x *NullableFieldsInput) GetOptionalString() *wrapperspb.StringValue { if x != nil { - return x.Name + return x.OptionalString } - return "" + return nil } -func (x *Cat) GetKind() string { +func (x *NullableFieldsInput) GetOptionalInt() *wrapperspb.Int32Value { if x != nil { - return x.Kind + return x.OptionalInt } - return "" + return nil } -func (x *Cat) GetMeowVolume() int32 { +func (x *NullableFieldsInput) GetOptionalFloat() *wrapperspb.DoubleValue { if x != nil { - return x.MeowVolume + return x.OptionalFloat } - return 0 + return nil } -func (x *Cat) GetOwner() *Owner { +func (x *NullableFieldsInput) GetOptionalBoolean() *wrapperspb.BoolValue { if x != nil { - return x.Owner + return x.OptionalBoolean } return nil } -func (x *Cat) GetBreed() *CatBreed { +func (x *NullableFieldsInput) GetRequiredString() string { if x != nil { - return x.Breed + return x.RequiredString } - return nil + return "" } -type Dog struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` - Kind string `protobuf:"bytes,3,opt,name=kind,proto3" json:"kind,omitempty"` - BarkVolume int32 `protobuf:"varint,4,opt,name=bark_volume,json=barkVolume,proto3" json:"bark_volume,omitempty"` - Owner *Owner `protobuf:"bytes,5,opt,name=owner,proto3" json:"owner,omitempty"` - Breed *DogBreed `protobuf:"bytes,6,opt,name=breed,proto3" json:"breed,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +func (x *NullableFieldsInput) GetRequiredInt() int32 { + if x != nil { + return x.RequiredInt + } + return 0 } -func (x *Dog) Reset() { - *x = Dog{} - mi := &file_product_proto_msgTypes[323] +type BlogPostInput struct { + state protoimpl.MessageState `protogen:"open.v1"` + Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"` + Content string `protobuf:"bytes,2,opt,name=content,proto3" json:"content,omitempty"` + Tags []string `protobuf:"bytes,3,rep,name=tags,proto3" json:"tags,omitempty"` + OptionalTags *ListOfString `protobuf:"bytes,4,opt,name=optional_tags,json=optionalTags,proto3" json:"optional_tags,omitempty"` + Categories []string `protobuf:"bytes,5,rep,name=categories,proto3" json:"categories,omitempty"` + Keywords *ListOfString `protobuf:"bytes,6,opt,name=keywords,proto3" json:"keywords,omitempty"` + ViewCounts []int32 `protobuf:"varint,7,rep,packed,name=view_counts,json=viewCounts,proto3" json:"view_counts,omitempty"` + Ratings *ListOfFloat `protobuf:"bytes,8,opt,name=ratings,proto3" json:"ratings,omitempty"` + IsPublished *ListOfBoolean `protobuf:"bytes,9,opt,name=is_published,json=isPublished,proto3" json:"is_published,omitempty"` + TagGroups *ListOfListOfString `protobuf:"bytes,10,opt,name=tag_groups,json=tagGroups,proto3" json:"tag_groups,omitempty"` + RelatedTopics *ListOfListOfString `protobuf:"bytes,11,opt,name=related_topics,json=relatedTopics,proto3" json:"related_topics,omitempty"` + CommentThreads *ListOfListOfString `protobuf:"bytes,12,opt,name=comment_threads,json=commentThreads,proto3" json:"comment_threads,omitempty"` + Suggestions *ListOfListOfString `protobuf:"bytes,13,opt,name=suggestions,proto3" json:"suggestions,omitempty"` + RelatedCategories *ListOfCategoryInput `protobuf:"bytes,14,opt,name=related_categories,json=relatedCategories,proto3" json:"related_categories,omitempty"` + Contributors *ListOfUserInput `protobuf:"bytes,15,opt,name=contributors,proto3" json:"contributors,omitempty"` + CategoryGroups *ListOfListOfCategoryInput `protobuf:"bytes,16,opt,name=category_groups,json=categoryGroups,proto3" json:"category_groups,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *BlogPostInput) Reset() { + *x = BlogPostInput{} + mi := &file_product_proto_msgTypes[328] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *Dog) String() string { +func (x *BlogPostInput) String() string { return protoimpl.X.MessageStringOf(x) } -func (*Dog) ProtoMessage() {} +func (*BlogPostInput) ProtoMessage() {} -func (x *Dog) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[323] +func (x *BlogPostInput) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[328] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16220,206 +16007,154 @@ func (x *Dog) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use Dog.ProtoReflect.Descriptor instead. -func (*Dog) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{323} +// Deprecated: Use BlogPostInput.ProtoReflect.Descriptor instead. +func (*BlogPostInput) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{328} } -func (x *Dog) GetId() string { +func (x *BlogPostInput) GetTitle() string { if x != nil { - return x.Id + return x.Title } return "" } -func (x *Dog) GetName() string { +func (x *BlogPostInput) GetContent() string { if x != nil { - return x.Name + return x.Content } return "" } -func (x *Dog) GetKind() string { +func (x *BlogPostInput) GetTags() []string { if x != nil { - return x.Kind + return x.Tags } - return "" + return nil } -func (x *Dog) GetBarkVolume() int32 { +func (x *BlogPostInput) GetOptionalTags() *ListOfString { if x != nil { - return x.BarkVolume + return x.OptionalTags } - return 0 + return nil } -func (x *Dog) GetOwner() *Owner { +func (x *BlogPostInput) GetCategories() []string { if x != nil { - return x.Owner + return x.Categories } return nil } -func (x *Dog) GetBreed() *DogBreed { +func (x *BlogPostInput) GetKeywords() *ListOfString { if x != nil { - return x.Breed + return x.Keywords } return nil } -type Owner struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` - Contact *ContactInfo `protobuf:"bytes,3,opt,name=contact,proto3" json:"contact,omitempty"` - Pet *Animal `protobuf:"bytes,4,opt,name=pet,proto3" json:"pet,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *Owner) Reset() { - *x = Owner{} - mi := &file_product_proto_msgTypes[324] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *Owner) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*Owner) ProtoMessage() {} - -func (x *Owner) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[324] +func (x *BlogPostInput) GetViewCounts() []int32 { if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms + return x.ViewCounts } - return mi.MessageOf(x) -} - -// Deprecated: Use Owner.ProtoReflect.Descriptor instead. -func (*Owner) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{324} + return nil } -func (x *Owner) GetId() string { +func (x *BlogPostInput) GetRatings() *ListOfFloat { if x != nil { - return x.Id + return x.Ratings } - return "" + return nil } -func (x *Owner) GetName() string { +func (x *BlogPostInput) GetIsPublished() *ListOfBoolean { if x != nil { - return x.Name + return x.IsPublished } - return "" + return nil } -func (x *Owner) GetContact() *ContactInfo { +func (x *BlogPostInput) GetTagGroups() *ListOfListOfString { if x != nil { - return x.Contact + return x.TagGroups } return nil } -func (x *Owner) GetPet() *Animal { +func (x *BlogPostInput) GetRelatedTopics() *ListOfListOfString { if x != nil { - return x.Pet + return x.RelatedTopics } return nil } -type ContactInfo struct { - state protoimpl.MessageState `protogen:"open.v1"` - Email string `protobuf:"bytes,1,opt,name=email,proto3" json:"email,omitempty"` - Phone string `protobuf:"bytes,2,opt,name=phone,proto3" json:"phone,omitempty"` - Address *Address `protobuf:"bytes,3,opt,name=address,proto3" json:"address,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *ContactInfo) Reset() { - *x = ContactInfo{} - mi := &file_product_proto_msgTypes[325] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *ContactInfo) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*ContactInfo) ProtoMessage() {} - -func (x *ContactInfo) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[325] +func (x *BlogPostInput) GetCommentThreads() *ListOfListOfString { if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms + return x.CommentThreads } - return mi.MessageOf(x) + return nil } -// Deprecated: Use ContactInfo.ProtoReflect.Descriptor instead. -func (*ContactInfo) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{325} +func (x *BlogPostInput) GetSuggestions() *ListOfListOfString { + if x != nil { + return x.Suggestions + } + return nil } -func (x *ContactInfo) GetEmail() string { +func (x *BlogPostInput) GetRelatedCategories() *ListOfCategoryInput { if x != nil { - return x.Email + return x.RelatedCategories } - return "" + return nil } -func (x *ContactInfo) GetPhone() string { +func (x *BlogPostInput) GetContributors() *ListOfUserInput { if x != nil { - return x.Phone + return x.Contributors } - return "" + return nil } -func (x *ContactInfo) GetAddress() *Address { +func (x *BlogPostInput) GetCategoryGroups() *ListOfListOfCategoryInput { if x != nil { - return x.Address + return x.CategoryGroups } return nil } -type Address struct { - state protoimpl.MessageState `protogen:"open.v1"` - Street string `protobuf:"bytes,1,opt,name=street,proto3" json:"street,omitempty"` - City string `protobuf:"bytes,2,opt,name=city,proto3" json:"city,omitempty"` - Country string `protobuf:"bytes,3,opt,name=country,proto3" json:"country,omitempty"` - ZipCode string `protobuf:"bytes,4,opt,name=zip_code,json=zipCode,proto3" json:"zip_code,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type AuthorInput struct { + state protoimpl.MessageState `protogen:"open.v1"` + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Email *wrapperspb.StringValue `protobuf:"bytes,2,opt,name=email,proto3" json:"email,omitempty"` + Skills []string `protobuf:"bytes,3,rep,name=skills,proto3" json:"skills,omitempty"` + Languages []string `protobuf:"bytes,4,rep,name=languages,proto3" json:"languages,omitempty"` + SocialLinks *ListOfString `protobuf:"bytes,5,opt,name=social_links,json=socialLinks,proto3" json:"social_links,omitempty"` + TeamsByProject *ListOfListOfString `protobuf:"bytes,6,opt,name=teams_by_project,json=teamsByProject,proto3" json:"teams_by_project,omitempty"` + Collaborations *ListOfListOfString `protobuf:"bytes,7,opt,name=collaborations,proto3" json:"collaborations,omitempty"` + FavoriteCategories []*CategoryInput `protobuf:"bytes,8,rep,name=favorite_categories,json=favoriteCategories,proto3" json:"favorite_categories,omitempty"` + AuthorGroups *ListOfListOfUserInput `protobuf:"bytes,9,opt,name=author_groups,json=authorGroups,proto3" json:"author_groups,omitempty"` + ProjectTeams *ListOfListOfUserInput `protobuf:"bytes,10,opt,name=project_teams,json=projectTeams,proto3" json:"project_teams,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *Address) Reset() { - *x = Address{} - mi := &file_product_proto_msgTypes[326] +func (x *AuthorInput) Reset() { + *x = AuthorInput{} + mi := &file_product_proto_msgTypes[329] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *Address) String() string { +func (x *AuthorInput) String() string { return protoimpl.X.MessageStringOf(x) } -func (*Address) ProtoMessage() {} +func (*AuthorInput) ProtoMessage() {} -func (x *Address) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[326] +func (x *AuthorInput) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[329] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16430,132 +16165,106 @@ func (x *Address) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use Address.ProtoReflect.Descriptor instead. -func (*Address) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{326} +// Deprecated: Use AuthorInput.ProtoReflect.Descriptor instead. +func (*AuthorInput) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{329} } -func (x *Address) GetStreet() string { +func (x *AuthorInput) GetName() string { if x != nil { - return x.Street + return x.Name } return "" } -func (x *Address) GetCity() string { +func (x *AuthorInput) GetEmail() *wrapperspb.StringValue { if x != nil { - return x.City + return x.Email } - return "" + return nil } -func (x *Address) GetCountry() string { +func (x *AuthorInput) GetSkills() []string { if x != nil { - return x.Country + return x.Skills } - return "" + return nil } -func (x *Address) GetZipCode() string { +func (x *AuthorInput) GetLanguages() []string { if x != nil { - return x.ZipCode + return x.Languages } - return "" -} - -type CatBreed struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` - Origin string `protobuf:"bytes,3,opt,name=origin,proto3" json:"origin,omitempty"` - Characteristics *BreedCharacteristics `protobuf:"bytes,4,opt,name=characteristics,proto3" json:"characteristics,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *CatBreed) Reset() { - *x = CatBreed{} - mi := &file_product_proto_msgTypes[327] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *CatBreed) String() string { - return protoimpl.X.MessageStringOf(x) + return nil } -func (*CatBreed) ProtoMessage() {} - -func (x *CatBreed) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[327] +func (x *AuthorInput) GetSocialLinks() *ListOfString { if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms + return x.SocialLinks } - return mi.MessageOf(x) + return nil } -// Deprecated: Use CatBreed.ProtoReflect.Descriptor instead. -func (*CatBreed) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{327} +func (x *AuthorInput) GetTeamsByProject() *ListOfListOfString { + if x != nil { + return x.TeamsByProject + } + return nil } -func (x *CatBreed) GetId() string { +func (x *AuthorInput) GetCollaborations() *ListOfListOfString { if x != nil { - return x.Id + return x.Collaborations } - return "" + return nil } -func (x *CatBreed) GetName() string { +func (x *AuthorInput) GetFavoriteCategories() []*CategoryInput { if x != nil { - return x.Name + return x.FavoriteCategories } - return "" + return nil } -func (x *CatBreed) GetOrigin() string { +func (x *AuthorInput) GetAuthorGroups() *ListOfListOfUserInput { if x != nil { - return x.Origin + return x.AuthorGroups } - return "" + return nil } -func (x *CatBreed) GetCharacteristics() *BreedCharacteristics { +func (x *AuthorInput) GetProjectTeams() *ListOfListOfUserInput { if x != nil { - return x.Characteristics + return x.ProjectTeams } return nil } -type DogBreed struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` - Origin string `protobuf:"bytes,3,opt,name=origin,proto3" json:"origin,omitempty"` - Characteristics *BreedCharacteristics `protobuf:"bytes,4,opt,name=characteristics,proto3" json:"characteristics,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type ProductDetails struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"` + ReviewSummary *ActionResult `protobuf:"bytes,3,opt,name=review_summary,json=reviewSummary,proto3" json:"review_summary,omitempty"` + RecommendedPet *Animal `protobuf:"bytes,4,opt,name=recommended_pet,json=recommendedPet,proto3" json:"recommended_pet,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *DogBreed) Reset() { - *x = DogBreed{} - mi := &file_product_proto_msgTypes[328] +func (x *ProductDetails) Reset() { + *x = ProductDetails{} + mi := &file_product_proto_msgTypes[330] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *DogBreed) String() string { +func (x *ProductDetails) String() string { return protoimpl.X.MessageStringOf(x) } -func (*DogBreed) ProtoMessage() {} +func (*ProductDetails) ProtoMessage() {} -func (x *DogBreed) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[328] +func (x *ProductDetails) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[330] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16566,63 +16275,61 @@ func (x *DogBreed) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use DogBreed.ProtoReflect.Descriptor instead. -func (*DogBreed) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{328} +// Deprecated: Use ProductDetails.ProtoReflect.Descriptor instead. +func (*ProductDetails) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{330} } -func (x *DogBreed) GetId() string { +func (x *ProductDetails) GetId() string { if x != nil { return x.Id } return "" } -func (x *DogBreed) GetName() string { +func (x *ProductDetails) GetDescription() string { if x != nil { - return x.Name + return x.Description } return "" } -func (x *DogBreed) GetOrigin() string { +func (x *ProductDetails) GetReviewSummary() *ActionResult { if x != nil { - return x.Origin + return x.ReviewSummary } - return "" + return nil } -func (x *DogBreed) GetCharacteristics() *BreedCharacteristics { +func (x *ProductDetails) GetRecommendedPet() *Animal { if x != nil { - return x.Characteristics + return x.RecommendedPet } return nil } -type BreedCharacteristics struct { - state protoimpl.MessageState `protogen:"open.v1"` - Size string `protobuf:"bytes,1,opt,name=size,proto3" json:"size,omitempty"` - Temperament string `protobuf:"bytes,2,opt,name=temperament,proto3" json:"temperament,omitempty"` - Lifespan string `protobuf:"bytes,3,opt,name=lifespan,proto3" json:"lifespan,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type RestockData struct { + state protoimpl.MessageState `protogen:"open.v1"` + LastRestockDate string `protobuf:"bytes,1,opt,name=last_restock_date,json=lastRestockDate,proto3" json:"last_restock_date,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *BreedCharacteristics) Reset() { - *x = BreedCharacteristics{} - mi := &file_product_proto_msgTypes[329] +func (x *RestockData) Reset() { + *x = RestockData{} + mi := &file_product_proto_msgTypes[331] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *BreedCharacteristics) String() string { +func (x *RestockData) String() string { return protoimpl.X.MessageStringOf(x) } -func (*BreedCharacteristics) ProtoMessage() {} +func (*RestockData) ProtoMessage() {} -func (x *BreedCharacteristics) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[329] +func (x *RestockData) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[331] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16633,55 +16340,42 @@ func (x *BreedCharacteristics) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use BreedCharacteristics.ProtoReflect.Descriptor instead. -func (*BreedCharacteristics) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{329} -} - -func (x *BreedCharacteristics) GetSize() string { - if x != nil { - return x.Size - } - return "" -} - -func (x *BreedCharacteristics) GetTemperament() string { - if x != nil { - return x.Temperament - } - return "" +// Deprecated: Use RestockData.ProtoReflect.Descriptor instead. +func (*RestockData) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{331} } -func (x *BreedCharacteristics) GetLifespan() string { +func (x *RestockData) GetLastRestockDate() string { if x != nil { - return x.Lifespan + return x.LastRestockDate } return "" } -type ActionSuccess struct { +type StorageMetadata struct { state protoimpl.MessageState `protogen:"open.v1"` - Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"` - Timestamp string `protobuf:"bytes,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"` + Capacity int32 `protobuf:"varint,1,opt,name=capacity,proto3" json:"capacity,omitempty"` + Zone string `protobuf:"bytes,2,opt,name=zone,proto3" json:"zone,omitempty"` + Priority int32 `protobuf:"varint,3,opt,name=priority,proto3" json:"priority,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ActionSuccess) Reset() { - *x = ActionSuccess{} - mi := &file_product_proto_msgTypes[330] +func (x *StorageMetadata) Reset() { + *x = StorageMetadata{} + mi := &file_product_proto_msgTypes[332] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ActionSuccess) String() string { +func (x *StorageMetadata) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ActionSuccess) ProtoMessage() {} +func (*StorageMetadata) ProtoMessage() {} -func (x *ActionSuccess) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[330] +func (x *StorageMetadata) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[332] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16692,48 +16386,55 @@ func (x *ActionSuccess) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ActionSuccess.ProtoReflect.Descriptor instead. -func (*ActionSuccess) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{330} +// Deprecated: Use StorageMetadata.ProtoReflect.Descriptor instead. +func (*StorageMetadata) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{332} } -func (x *ActionSuccess) GetMessage() string { +func (x *StorageMetadata) GetCapacity() int32 { if x != nil { - return x.Message + return x.Capacity + } + return 0 +} + +func (x *StorageMetadata) GetZone() string { + if x != nil { + return x.Zone } return "" } -func (x *ActionSuccess) GetTimestamp() string { +func (x *StorageMetadata) GetPriority() int32 { if x != nil { - return x.Timestamp + return x.Priority } - return "" + return 0 } -type ActionError struct { +type StorageCategoryInfo struct { state protoimpl.MessageState `protogen:"open.v1"` - Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"` - Code string `protobuf:"bytes,2,opt,name=code,proto3" json:"code,omitempty"` + Kind CategoryKind `protobuf:"varint,1,opt,name=kind,proto3,enum=productv1.CategoryKind" json:"kind,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ActionError) Reset() { - *x = ActionError{} - mi := &file_product_proto_msgTypes[331] +func (x *StorageCategoryInfo) Reset() { + *x = StorageCategoryInfo{} + mi := &file_product_proto_msgTypes[333] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ActionError) String() string { +func (x *StorageCategoryInfo) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ActionError) ProtoMessage() {} +func (*StorageCategoryInfo) ProtoMessage() {} -func (x *ActionError) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[331] +func (x *StorageCategoryInfo) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[333] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16744,50 +16445,49 @@ func (x *ActionError) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ActionError.ProtoReflect.Descriptor instead. -func (*ActionError) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{331} +// Deprecated: Use StorageCategoryInfo.ProtoReflect.Descriptor instead. +func (*StorageCategoryInfo) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{333} } -func (x *ActionError) GetMessage() string { +func (x *StorageCategoryInfo) GetKind() CategoryKind { if x != nil { - return x.Message + return x.Kind } - return "" + return CategoryKind_CATEGORY_KIND_UNSPECIFIED } -func (x *ActionError) GetCode() string { +func (x *StorageCategoryInfo) GetName() string { if x != nil { - return x.Code + return x.Name } return "" } -type TestDetails struct { +type NestedTypeB struct { state protoimpl.MessageState `protogen:"open.v1"` Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Summary string `protobuf:"bytes,2,opt,name=summary,proto3" json:"summary,omitempty"` - Pet *Animal `protobuf:"bytes,3,opt,name=pet,proto3" json:"pet,omitempty"` - Status *ActionResult `protobuf:"bytes,4,opt,name=status,proto3" json:"status,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + C *NestedTypeC `protobuf:"bytes,3,opt,name=c,proto3" json:"c,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *TestDetails) Reset() { - *x = TestDetails{} - mi := &file_product_proto_msgTypes[332] +func (x *NestedTypeB) Reset() { + *x = NestedTypeB{} + mi := &file_product_proto_msgTypes[334] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *TestDetails) String() string { +func (x *NestedTypeB) String() string { return protoimpl.X.MessageStringOf(x) } -func (*TestDetails) ProtoMessage() {} +func (*NestedTypeB) ProtoMessage() {} -func (x *TestDetails) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[332] +func (x *NestedTypeB) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[334] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16798,62 +16498,55 @@ func (x *TestDetails) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use TestDetails.ProtoReflect.Descriptor instead. -func (*TestDetails) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{332} +// Deprecated: Use NestedTypeB.ProtoReflect.Descriptor instead. +func (*NestedTypeB) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{334} } -func (x *TestDetails) GetId() string { +func (x *NestedTypeB) GetId() string { if x != nil { return x.Id } return "" } -func (x *TestDetails) GetSummary() string { +func (x *NestedTypeB) GetName() string { if x != nil { - return x.Summary + return x.Name } return "" } -func (x *TestDetails) GetPet() *Animal { - if x != nil { - return x.Pet - } - return nil -} - -func (x *TestDetails) GetStatus() *ActionResult { +func (x *NestedTypeB) GetC() *NestedTypeC { if x != nil { - return x.Status + return x.C } return nil } -type CategoryInput struct { +type NestedTypeC struct { state protoimpl.MessageState `protogen:"open.v1"` - Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` - Kind CategoryKind `protobuf:"varint,2,opt,name=kind,proto3,enum=productv1.CategoryKind" json:"kind,omitempty"` + 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 *CategoryInput) Reset() { - *x = CategoryInput{} - mi := &file_product_proto_msgTypes[333] +func (x *NestedTypeC) Reset() { + *x = NestedTypeC{} + mi := &file_product_proto_msgTypes[335] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *CategoryInput) String() string { +func (x *NestedTypeC) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CategoryInput) ProtoMessage() {} +func (*NestedTypeC) ProtoMessage() {} -func (x *CategoryInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[333] +func (x *NestedTypeC) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[335] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16864,50 +16557,50 @@ func (x *CategoryInput) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use CategoryInput.ProtoReflect.Descriptor instead. -func (*CategoryInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{333} +// Deprecated: Use NestedTypeC.ProtoReflect.Descriptor instead. +func (*NestedTypeC) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{335} } -func (x *CategoryInput) GetName() string { +func (x *NestedTypeC) GetId() string { if x != nil { - return x.Name + return x.Id } return "" } -func (x *CategoryInput) GetKind() CategoryKind { +func (x *NestedTypeC) GetName() string { if x != nil { - return x.Kind + return x.Name } - return CategoryKind_CATEGORY_KIND_UNSPECIFIED + return "" } -type ProductCountFilter struct { - state protoimpl.MessageState `protogen:"open.v1"` - MinPrice *wrapperspb.DoubleValue `protobuf:"bytes,1,opt,name=min_price,json=minPrice,proto3" json:"min_price,omitempty"` - MaxPrice *wrapperspb.DoubleValue `protobuf:"bytes,2,opt,name=max_price,json=maxPrice,proto3" json:"max_price,omitempty"` - InStock *wrapperspb.BoolValue `protobuf:"bytes,3,opt,name=in_stock,json=inStock,proto3" json:"in_stock,omitempty"` - SearchTerm *wrapperspb.StringValue `protobuf:"bytes,4,opt,name=search_term,json=searchTerm,proto3" json:"search_term,omitempty"` +type FilterType struct { + state protoimpl.MessageState `protogen:"open.v1"` + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + FilterField_1 string `protobuf:"bytes,2,opt,name=filter_field_1,json=filterField1,proto3" json:"filter_field_1,omitempty"` + FilterField_2 string `protobuf:"bytes,3,opt,name=filter_field_2,json=filterField2,proto3" json:"filter_field_2,omitempty"` + Pagination *Pagination `protobuf:"bytes,4,opt,name=pagination,proto3" json:"pagination,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ProductCountFilter) Reset() { - *x = ProductCountFilter{} - mi := &file_product_proto_msgTypes[334] +func (x *FilterType) Reset() { + *x = FilterType{} + mi := &file_product_proto_msgTypes[336] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ProductCountFilter) String() string { +func (x *FilterType) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ProductCountFilter) ProtoMessage() {} +func (*FilterType) ProtoMessage() {} -func (x *ProductCountFilter) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[334] +func (x *FilterType) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[336] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16918,65 +16611,62 @@ func (x *ProductCountFilter) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ProductCountFilter.ProtoReflect.Descriptor instead. -func (*ProductCountFilter) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{334} +// Deprecated: Use FilterType.ProtoReflect.Descriptor instead. +func (*FilterType) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{336} } -func (x *ProductCountFilter) GetMinPrice() *wrapperspb.DoubleValue { +func (x *FilterType) GetName() string { if x != nil { - return x.MinPrice + return x.Name } - return nil + return "" } -func (x *ProductCountFilter) GetMaxPrice() *wrapperspb.DoubleValue { +func (x *FilterType) GetFilterField_1() string { if x != nil { - return x.MaxPrice + return x.FilterField_1 } - return nil + return "" } -func (x *ProductCountFilter) GetInStock() *wrapperspb.BoolValue { +func (x *FilterType) GetFilterField_2() string { if x != nil { - return x.InStock + return x.FilterField_2 } - return nil + return "" } -func (x *ProductCountFilter) GetSearchTerm() *wrapperspb.StringValue { +func (x *FilterType) GetPagination() *Pagination { if x != nil { - return x.SearchTerm + return x.Pagination } return nil } -type SubcategoryItemFilter struct { - state protoimpl.MessageState `protogen:"open.v1"` - MinPrice *wrapperspb.DoubleValue `protobuf:"bytes,1,opt,name=min_price,json=minPrice,proto3" json:"min_price,omitempty"` - MaxPrice *wrapperspb.DoubleValue `protobuf:"bytes,2,opt,name=max_price,json=maxPrice,proto3" json:"max_price,omitempty"` - InStock *wrapperspb.BoolValue `protobuf:"bytes,3,opt,name=in_stock,json=inStock,proto3" json:"in_stock,omitempty"` - IsActive *wrapperspb.BoolValue `protobuf:"bytes,4,opt,name=is_active,json=isActive,proto3" json:"is_active,omitempty"` - SearchTerm *wrapperspb.StringValue `protobuf:"bytes,5,opt,name=search_term,json=searchTerm,proto3" json:"search_term,omitempty"` +type Pagination struct { + state protoimpl.MessageState `protogen:"open.v1"` + Page int32 `protobuf:"varint,1,opt,name=page,proto3" json:"page,omitempty"` + PerPage int32 `protobuf:"varint,2,opt,name=per_page,json=perPage,proto3" json:"per_page,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *SubcategoryItemFilter) Reset() { - *x = SubcategoryItemFilter{} - mi := &file_product_proto_msgTypes[335] +func (x *Pagination) Reset() { + *x = Pagination{} + mi := &file_product_proto_msgTypes[337] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *SubcategoryItemFilter) String() string { +func (x *Pagination) String() string { return protoimpl.X.MessageStringOf(x) } -func (*SubcategoryItemFilter) ProtoMessage() {} +func (*Pagination) ProtoMessage() {} -func (x *SubcategoryItemFilter) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[335] +func (x *Pagination) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[337] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16987,70 +16677,109 @@ func (x *SubcategoryItemFilter) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use SubcategoryItemFilter.ProtoReflect.Descriptor instead. -func (*SubcategoryItemFilter) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{335} +// Deprecated: Use Pagination.ProtoReflect.Descriptor instead. +func (*Pagination) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{337} } -func (x *SubcategoryItemFilter) GetMinPrice() *wrapperspb.DoubleValue { +func (x *Pagination) GetPage() int32 { if x != nil { - return x.MinPrice + return x.Page } - return nil + return 0 } -func (x *SubcategoryItemFilter) GetMaxPrice() *wrapperspb.DoubleValue { +func (x *Pagination) GetPerPage() int32 { if x != nil { - return x.MaxPrice + return x.PerPage } - return nil + return 0 } -func (x *SubcategoryItemFilter) GetInStock() *wrapperspb.BoolValue { +type OrderLineInput struct { + state protoimpl.MessageState `protogen:"open.v1"` + ProductId string `protobuf:"bytes,1,opt,name=product_id,json=productId,proto3" json:"product_id,omitempty"` + Quantity int32 `protobuf:"varint,2,opt,name=quantity,proto3" json:"quantity,omitempty"` + Modifiers *ListOfString `protobuf:"bytes,3,opt,name=modifiers,proto3" json:"modifiers,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *OrderLineInput) Reset() { + *x = OrderLineInput{} + mi := &file_product_proto_msgTypes[338] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *OrderLineInput) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*OrderLineInput) ProtoMessage() {} + +func (x *OrderLineInput) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[338] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use OrderLineInput.ProtoReflect.Descriptor instead. +func (*OrderLineInput) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{338} +} + +func (x *OrderLineInput) GetProductId() string { if x != nil { - return x.InStock + return x.ProductId } - return nil + return "" } -func (x *SubcategoryItemFilter) GetIsActive() *wrapperspb.BoolValue { +func (x *OrderLineInput) GetQuantity() int32 { if x != nil { - return x.IsActive + return x.Quantity } - return nil + return 0 } -func (x *SubcategoryItemFilter) GetSearchTerm() *wrapperspb.StringValue { +func (x *OrderLineInput) GetModifiers() *ListOfString { if x != nil { - return x.SearchTerm + return x.Modifiers } return nil } -type ShippingEstimateInput struct { +type OrderLine struct { state protoimpl.MessageState `protogen:"open.v1"` - Destination ShippingDestination `protobuf:"varint,1,opt,name=destination,proto3,enum=productv1.ShippingDestination" json:"destination,omitempty"` - Weight float64 `protobuf:"fixed64,2,opt,name=weight,proto3" json:"weight,omitempty"` - Expedited *wrapperspb.BoolValue `protobuf:"bytes,3,opt,name=expedited,proto3" json:"expedited,omitempty"` + ProductId string `protobuf:"bytes,1,opt,name=product_id,json=productId,proto3" json:"product_id,omitempty"` + Quantity int32 `protobuf:"varint,2,opt,name=quantity,proto3" json:"quantity,omitempty"` + Modifiers *ListOfString `protobuf:"bytes,3,opt,name=modifiers,proto3" json:"modifiers,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ShippingEstimateInput) Reset() { - *x = ShippingEstimateInput{} - mi := &file_product_proto_msgTypes[336] +func (x *OrderLine) Reset() { + *x = OrderLine{} + mi := &file_product_proto_msgTypes[339] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ShippingEstimateInput) String() string { +func (x *OrderLine) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ShippingEstimateInput) ProtoMessage() {} +func (*OrderLine) ProtoMessage() {} -func (x *ShippingEstimateInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[336] +func (x *OrderLine) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[339] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17061,55 +16790,57 @@ func (x *ShippingEstimateInput) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ShippingEstimateInput.ProtoReflect.Descriptor instead. -func (*ShippingEstimateInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{336} +// Deprecated: Use OrderLine.ProtoReflect.Descriptor instead. +func (*OrderLine) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{339} } -func (x *ShippingEstimateInput) GetDestination() ShippingDestination { +func (x *OrderLine) GetProductId() string { if x != nil { - return x.Destination + return x.ProductId } - return ShippingDestination_SHIPPING_DESTINATION_UNSPECIFIED + return "" } -func (x *ShippingEstimateInput) GetWeight() float64 { +func (x *OrderLine) GetQuantity() int32 { if x != nil { - return x.Weight + return x.Quantity } return 0 } -func (x *ShippingEstimateInput) GetExpedited() *wrapperspb.BoolValue { +func (x *OrderLine) GetModifiers() *ListOfString { if x != nil { - return x.Expedited + return x.Modifiers } return nil } -// Argument-less field resolver messages for Category.totalProducts -type ResolveCategoryTotalProductsContext struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` +type Subcategory struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + Description *wrapperspb.StringValue `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"` + IsActive bool `protobuf:"varint,4,opt,name=is_active,json=isActive,proto3" json:"is_active,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ResolveCategoryTotalProductsContext) Reset() { - *x = ResolveCategoryTotalProductsContext{} - mi := &file_product_proto_msgTypes[337] +func (x *Subcategory) Reset() { + *x = Subcategory{} + mi := &file_product_proto_msgTypes[340] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveCategoryTotalProductsContext) String() string { +func (x *Subcategory) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveCategoryTotalProductsContext) ProtoMessage() {} +func (*Subcategory) ProtoMessage() {} -func (x *ResolveCategoryTotalProductsContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[337] +func (x *Subcategory) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[340] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17120,40 +16851,65 @@ func (x *ResolveCategoryTotalProductsContext) ProtoReflect() protoreflect.Messag return mi.MessageOf(x) } -// Deprecated: Use ResolveCategoryTotalProductsContext.ProtoReflect.Descriptor instead. -func (*ResolveCategoryTotalProductsContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{337} +// Deprecated: Use Subcategory.ProtoReflect.Descriptor instead. +func (*Subcategory) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{340} } -func (x *ResolveCategoryTotalProductsContext) GetId() string { +func (x *Subcategory) GetId() string { if x != nil { return x.Id } return "" } -type ResolveCategoryTotalProductsRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - Context []*ResolveCategoryTotalProductsContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` +func (x *Subcategory) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *Subcategory) GetDescription() *wrapperspb.StringValue { + if x != nil { + return x.Description + } + return nil +} + +func (x *Subcategory) GetIsActive() bool { + if x != nil { + return x.IsActive + } + return false +} + +type CategoryMetrics struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + MetricType string `protobuf:"bytes,2,opt,name=metric_type,json=metricType,proto3" json:"metric_type,omitempty"` + Value float64 `protobuf:"fixed64,3,opt,name=value,proto3" json:"value,omitempty"` + Timestamp string `protobuf:"bytes,4,opt,name=timestamp,proto3" json:"timestamp,omitempty"` + CategoryId string `protobuf:"bytes,5,opt,name=category_id,json=categoryId,proto3" json:"category_id,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ResolveCategoryTotalProductsRequest) Reset() { - *x = ResolveCategoryTotalProductsRequest{} - mi := &file_product_proto_msgTypes[338] +func (x *CategoryMetrics) Reset() { + *x = CategoryMetrics{} + mi := &file_product_proto_msgTypes[341] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveCategoryTotalProductsRequest) String() string { +func (x *CategoryMetrics) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveCategoryTotalProductsRequest) ProtoMessage() {} +func (*CategoryMetrics) ProtoMessage() {} -func (x *ResolveCategoryTotalProductsRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[338] +func (x *CategoryMetrics) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[341] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17164,40 +16920,73 @@ func (x *ResolveCategoryTotalProductsRequest) ProtoReflect() protoreflect.Messag return mi.MessageOf(x) } -// Deprecated: Use ResolveCategoryTotalProductsRequest.ProtoReflect.Descriptor instead. -func (*ResolveCategoryTotalProductsRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{338} +// Deprecated: Use CategoryMetrics.ProtoReflect.Descriptor instead. +func (*CategoryMetrics) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{341} } -func (x *ResolveCategoryTotalProductsRequest) GetContext() []*ResolveCategoryTotalProductsContext { +func (x *CategoryMetrics) GetId() string { if x != nil { - return x.Context + return x.Id } - return nil + return "" } -type ResolveCategoryTotalProductsResult struct { +func (x *CategoryMetrics) GetMetricType() string { + if x != nil { + return x.MetricType + } + return "" +} + +func (x *CategoryMetrics) GetValue() float64 { + if x != nil { + return x.Value + } + return 0 +} + +func (x *CategoryMetrics) GetTimestamp() string { + if x != nil { + return x.Timestamp + } + return "" +} + +func (x *CategoryMetrics) GetCategoryId() string { + if x != nil { + return x.CategoryId + } + return "" +} + +type Cat struct { state protoimpl.MessageState `protogen:"open.v1"` - TotalProducts int32 `protobuf:"varint,1,opt,name=total_products,json=totalProducts,proto3" json:"total_products,omitempty"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + Kind string `protobuf:"bytes,3,opt,name=kind,proto3" json:"kind,omitempty"` + MeowVolume int32 `protobuf:"varint,4,opt,name=meow_volume,json=meowVolume,proto3" json:"meow_volume,omitempty"` + Owner *Owner `protobuf:"bytes,5,opt,name=owner,proto3" json:"owner,omitempty"` + Breed *CatBreed `protobuf:"bytes,6,opt,name=breed,proto3" json:"breed,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ResolveCategoryTotalProductsResult) Reset() { - *x = ResolveCategoryTotalProductsResult{} - mi := &file_product_proto_msgTypes[339] +func (x *Cat) Reset() { + *x = Cat{} + mi := &file_product_proto_msgTypes[342] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveCategoryTotalProductsResult) String() string { +func (x *Cat) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveCategoryTotalProductsResult) ProtoMessage() {} +func (*Cat) ProtoMessage() {} -func (x *ResolveCategoryTotalProductsResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[339] +func (x *Cat) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[342] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17208,86 +16997,80 @@ func (x *ResolveCategoryTotalProductsResult) ProtoReflect() protoreflect.Message return mi.MessageOf(x) } -// Deprecated: Use ResolveCategoryTotalProductsResult.ProtoReflect.Descriptor instead. -func (*ResolveCategoryTotalProductsResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{339} +// Deprecated: Use Cat.ProtoReflect.Descriptor instead. +func (*Cat) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{342} } -func (x *ResolveCategoryTotalProductsResult) GetTotalProducts() int32 { +func (x *Cat) GetId() string { if x != nil { - return x.TotalProducts + return x.Id } - 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 + return "" } -func (x *ResolveCategoryTotalProductsResponse) Reset() { - *x = ResolveCategoryTotalProductsResponse{} - mi := &file_product_proto_msgTypes[340] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) +func (x *Cat) GetName() string { + if x != nil { + return x.Name + } + return "" } -func (x *ResolveCategoryTotalProductsResponse) String() string { - return protoimpl.X.MessageStringOf(x) +func (x *Cat) GetKind() string { + if x != nil { + return x.Kind + } + return "" } -func (*ResolveCategoryTotalProductsResponse) ProtoMessage() {} - -func (x *ResolveCategoryTotalProductsResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[340] +func (x *Cat) GetMeowVolume() int32 { if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms + return x.MeowVolume } - return mi.MessageOf(x) + return 0 } -// Deprecated: Use ResolveCategoryTotalProductsResponse.ProtoReflect.Descriptor instead. -func (*ResolveCategoryTotalProductsResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{340} +func (x *Cat) GetOwner() *Owner { + if x != nil { + return x.Owner + } + return nil } -func (x *ResolveCategoryTotalProductsResponse) GetResult() []*ResolveCategoryTotalProductsResult { +func (x *Cat) GetBreed() *CatBreed { if x != nil { - return x.Result + return x.Breed } return nil } -// Argument-less field resolver messages for Category.topSubcategory -type ResolveCategoryTopSubcategoryContext struct { +type Dog struct { state protoimpl.MessageState `protogen:"open.v1"` Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + Kind string `protobuf:"bytes,3,opt,name=kind,proto3" json:"kind,omitempty"` + BarkVolume int32 `protobuf:"varint,4,opt,name=bark_volume,json=barkVolume,proto3" json:"bark_volume,omitempty"` + Owner *Owner `protobuf:"bytes,5,opt,name=owner,proto3" json:"owner,omitempty"` + Breed *DogBreed `protobuf:"bytes,6,opt,name=breed,proto3" json:"breed,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ResolveCategoryTopSubcategoryContext) Reset() { - *x = ResolveCategoryTopSubcategoryContext{} - mi := &file_product_proto_msgTypes[341] +func (x *Dog) Reset() { + *x = Dog{} + mi := &file_product_proto_msgTypes[343] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveCategoryTopSubcategoryContext) String() string { +func (x *Dog) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveCategoryTopSubcategoryContext) ProtoMessage() {} +func (*Dog) ProtoMessage() {} -func (x *ResolveCategoryTopSubcategoryContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[341] +func (x *Dog) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[343] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17298,91 +17081,78 @@ func (x *ResolveCategoryTopSubcategoryContext) ProtoReflect() protoreflect.Messa return mi.MessageOf(x) } -// Deprecated: Use ResolveCategoryTopSubcategoryContext.ProtoReflect.Descriptor instead. -func (*ResolveCategoryTopSubcategoryContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{341} +// Deprecated: Use Dog.ProtoReflect.Descriptor instead. +func (*Dog) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{343} } -func (x *ResolveCategoryTopSubcategoryContext) GetId() string { +func (x *Dog) GetId() string { if x != nil { return x.Id } return "" } -func (x *ResolveCategoryTopSubcategoryContext) GetName() string { +func (x *Dog) GetName() string { if x != nil { return x.Name } return "" } -type ResolveCategoryTopSubcategoryRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - 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[342] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *ResolveCategoryTopSubcategoryRequest) String() string { - return protoimpl.X.MessageStringOf(x) +func (x *Dog) GetKind() string { + if x != nil { + return x.Kind + } + return "" } -func (*ResolveCategoryTopSubcategoryRequest) ProtoMessage() {} - -func (x *ResolveCategoryTopSubcategoryRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[342] +func (x *Dog) GetBarkVolume() int32 { if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms + return x.BarkVolume } - return mi.MessageOf(x) + return 0 } -// Deprecated: Use ResolveCategoryTopSubcategoryRequest.ProtoReflect.Descriptor instead. -func (*ResolveCategoryTopSubcategoryRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{342} +func (x *Dog) GetOwner() *Owner { + if x != nil { + return x.Owner + } + return nil } -func (x *ResolveCategoryTopSubcategoryRequest) GetContext() []*ResolveCategoryTopSubcategoryContext { +func (x *Dog) GetBreed() *DogBreed { if x != nil { - return x.Context + return x.Breed } 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 +type Owner struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + Contact *ContactInfo `protobuf:"bytes,3,opt,name=contact,proto3" json:"contact,omitempty"` + Pet *Animal `protobuf:"bytes,4,opt,name=pet,proto3" json:"pet,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *ResolveCategoryTopSubcategoryResult) Reset() { - *x = ResolveCategoryTopSubcategoryResult{} - mi := &file_product_proto_msgTypes[343] +func (x *Owner) Reset() { + *x = Owner{} + mi := &file_product_proto_msgTypes[344] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveCategoryTopSubcategoryResult) String() string { +func (x *Owner) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveCategoryTopSubcategoryResult) ProtoMessage() {} +func (*Owner) ProtoMessage() {} -func (x *ResolveCategoryTopSubcategoryResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[343] +func (x *Owner) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[344] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17393,84 +17163,62 @@ func (x *ResolveCategoryTopSubcategoryResult) ProtoReflect() protoreflect.Messag return mi.MessageOf(x) } -// Deprecated: Use ResolveCategoryTopSubcategoryResult.ProtoReflect.Descriptor instead. -func (*ResolveCategoryTopSubcategoryResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{343} +// Deprecated: Use Owner.ProtoReflect.Descriptor instead. +func (*Owner) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{344} } -func (x *ResolveCategoryTopSubcategoryResult) GetTopSubcategory() *Subcategory { +func (x *Owner) GetId() string { if x != nil { - return x.TopSubcategory + return x.Id } - 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[344] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *ResolveCategoryTopSubcategoryResponse) String() string { - return protoimpl.X.MessageStringOf(x) + return "" } -func (*ResolveCategoryTopSubcategoryResponse) ProtoMessage() {} - -func (x *ResolveCategoryTopSubcategoryResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[344] +func (x *Owner) GetName() string { if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms + return x.Name } - return mi.MessageOf(x) + return "" } -// Deprecated: Use ResolveCategoryTopSubcategoryResponse.ProtoReflect.Descriptor instead. -func (*ResolveCategoryTopSubcategoryResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{344} +func (x *Owner) GetContact() *ContactInfo { + if x != nil { + return x.Contact + } + return nil } -func (x *ResolveCategoryTopSubcategoryResponse) GetResult() []*ResolveCategoryTopSubcategoryResult { +func (x *Owner) GetPet() *Animal { if x != nil { - return x.Result + return x.Pet } return nil } -// Argument-less field resolver messages for Category.activeSubcategories -type ResolveCategoryActiveSubcategoriesContext struct { +type ContactInfo struct { state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Email string `protobuf:"bytes,1,opt,name=email,proto3" json:"email,omitempty"` + Phone string `protobuf:"bytes,2,opt,name=phone,proto3" json:"phone,omitempty"` + Address *Address `protobuf:"bytes,3,opt,name=address,proto3" json:"address,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ResolveCategoryActiveSubcategoriesContext) Reset() { - *x = ResolveCategoryActiveSubcategoriesContext{} +func (x *ContactInfo) Reset() { + *x = ContactInfo{} mi := &file_product_proto_msgTypes[345] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveCategoryActiveSubcategoriesContext) String() string { +func (x *ContactInfo) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveCategoryActiveSubcategoriesContext) ProtoMessage() {} +func (*ContactInfo) ProtoMessage() {} -func (x *ResolveCategoryActiveSubcategoriesContext) ProtoReflect() protoreflect.Message { +func (x *ContactInfo) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[345] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -17482,39 +17230,56 @@ func (x *ResolveCategoryActiveSubcategoriesContext) ProtoReflect() protoreflect. return mi.MessageOf(x) } -// Deprecated: Use ResolveCategoryActiveSubcategoriesContext.ProtoReflect.Descriptor instead. -func (*ResolveCategoryActiveSubcategoriesContext) Descriptor() ([]byte, []int) { +// Deprecated: Use ContactInfo.ProtoReflect.Descriptor instead. +func (*ContactInfo) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{345} } -func (x *ResolveCategoryActiveSubcategoriesContext) GetId() string { +func (x *ContactInfo) GetEmail() string { if x != nil { - return x.Id + return x.Email } return "" } -type ResolveCategoryActiveSubcategoriesRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - Context []*ResolveCategoryActiveSubcategoriesContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` +func (x *ContactInfo) GetPhone() string { + if x != nil { + return x.Phone + } + return "" +} + +func (x *ContactInfo) GetAddress() *Address { + if x != nil { + return x.Address + } + return nil +} + +type Address struct { + state protoimpl.MessageState `protogen:"open.v1"` + Street string `protobuf:"bytes,1,opt,name=street,proto3" json:"street,omitempty"` + City string `protobuf:"bytes,2,opt,name=city,proto3" json:"city,omitempty"` + Country string `protobuf:"bytes,3,opt,name=country,proto3" json:"country,omitempty"` + ZipCode string `protobuf:"bytes,4,opt,name=zip_code,json=zipCode,proto3" json:"zip_code,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ResolveCategoryActiveSubcategoriesRequest) Reset() { - *x = ResolveCategoryActiveSubcategoriesRequest{} +func (x *Address) Reset() { + *x = Address{} mi := &file_product_proto_msgTypes[346] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveCategoryActiveSubcategoriesRequest) String() string { +func (x *Address) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveCategoryActiveSubcategoriesRequest) ProtoMessage() {} +func (*Address) ProtoMessage() {} -func (x *ResolveCategoryActiveSubcategoriesRequest) ProtoReflect() protoreflect.Message { +func (x *Address) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[346] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -17526,39 +17291,63 @@ func (x *ResolveCategoryActiveSubcategoriesRequest) ProtoReflect() protoreflect. return mi.MessageOf(x) } -// Deprecated: Use ResolveCategoryActiveSubcategoriesRequest.ProtoReflect.Descriptor instead. -func (*ResolveCategoryActiveSubcategoriesRequest) Descriptor() ([]byte, []int) { +// Deprecated: Use Address.ProtoReflect.Descriptor instead. +func (*Address) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{346} } -func (x *ResolveCategoryActiveSubcategoriesRequest) GetContext() []*ResolveCategoryActiveSubcategoriesContext { +func (x *Address) GetStreet() string { if x != nil { - return x.Context + return x.Street } - return nil + return "" } -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 *Address) GetCity() string { + if x != nil { + return x.City + } + return "" +} + +func (x *Address) GetCountry() string { + if x != nil { + return x.Country + } + return "" +} + +func (x *Address) GetZipCode() string { + if x != nil { + return x.ZipCode + } + return "" +} + +type CatBreed struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + Origin string `protobuf:"bytes,3,opt,name=origin,proto3" json:"origin,omitempty"` + Characteristics *BreedCharacteristics `protobuf:"bytes,4,opt,name=characteristics,proto3" json:"characteristics,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *ResolveCategoryActiveSubcategoriesResult) Reset() { - *x = ResolveCategoryActiveSubcategoriesResult{} +func (x *CatBreed) Reset() { + *x = CatBreed{} mi := &file_product_proto_msgTypes[347] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveCategoryActiveSubcategoriesResult) String() string { +func (x *CatBreed) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveCategoryActiveSubcategoriesResult) ProtoMessage() {} +func (*CatBreed) ProtoMessage() {} -func (x *ResolveCategoryActiveSubcategoriesResult) ProtoReflect() protoreflect.Message { +func (x *CatBreed) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[347] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -17570,39 +17359,63 @@ func (x *ResolveCategoryActiveSubcategoriesResult) ProtoReflect() protoreflect.M return mi.MessageOf(x) } -// Deprecated: Use ResolveCategoryActiveSubcategoriesResult.ProtoReflect.Descriptor instead. -func (*ResolveCategoryActiveSubcategoriesResult) Descriptor() ([]byte, []int) { +// Deprecated: Use CatBreed.ProtoReflect.Descriptor instead. +func (*CatBreed) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{347} } -func (x *ResolveCategoryActiveSubcategoriesResult) GetActiveSubcategories() []*Subcategory { +func (x *CatBreed) GetId() string { if x != nil { - return x.ActiveSubcategories + return x.Id + } + return "" +} + +func (x *CatBreed) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *CatBreed) GetOrigin() string { + if x != nil { + return x.Origin + } + return "" +} + +func (x *CatBreed) GetCharacteristics() *BreedCharacteristics { + if x != nil { + return x.Characteristics } 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 +type DogBreed struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + Origin string `protobuf:"bytes,3,opt,name=origin,proto3" json:"origin,omitempty"` + Characteristics *BreedCharacteristics `protobuf:"bytes,4,opt,name=characteristics,proto3" json:"characteristics,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *ResolveCategoryActiveSubcategoriesResponse) Reset() { - *x = ResolveCategoryActiveSubcategoriesResponse{} +func (x *DogBreed) Reset() { + *x = DogBreed{} mi := &file_product_proto_msgTypes[348] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveCategoryActiveSubcategoriesResponse) String() string { +func (x *DogBreed) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveCategoryActiveSubcategoriesResponse) ProtoMessage() {} +func (*DogBreed) ProtoMessage() {} -func (x *ResolveCategoryActiveSubcategoriesResponse) ProtoReflect() protoreflect.Message { +func (x *DogBreed) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[348] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -17614,40 +17427,62 @@ func (x *ResolveCategoryActiveSubcategoriesResponse) ProtoReflect() protoreflect return mi.MessageOf(x) } -// Deprecated: Use ResolveCategoryActiveSubcategoriesResponse.ProtoReflect.Descriptor instead. -func (*ResolveCategoryActiveSubcategoriesResponse) Descriptor() ([]byte, []int) { +// Deprecated: Use DogBreed.ProtoReflect.Descriptor instead. +func (*DogBreed) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{348} } -func (x *ResolveCategoryActiveSubcategoriesResponse) GetResult() []*ResolveCategoryActiveSubcategoriesResult { +func (x *DogBreed) GetId() string { if x != nil { - return x.Result + return x.Id + } + return "" +} + +func (x *DogBreed) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *DogBreed) GetOrigin() string { + if x != nil { + return x.Origin + } + return "" +} + +func (x *DogBreed) GetCharacteristics() *BreedCharacteristics { + if x != nil { + return x.Characteristics } return nil } -// Argument-less field resolver messages for Subcategory.parentCategory -type ResolveSubcategoryParentCategoryContext struct { +type BreedCharacteristics struct { state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Size string `protobuf:"bytes,1,opt,name=size,proto3" json:"size,omitempty"` + Temperament string `protobuf:"bytes,2,opt,name=temperament,proto3" json:"temperament,omitempty"` + Lifespan string `protobuf:"bytes,3,opt,name=lifespan,proto3" json:"lifespan,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ResolveSubcategoryParentCategoryContext) Reset() { - *x = ResolveSubcategoryParentCategoryContext{} +func (x *BreedCharacteristics) Reset() { + *x = BreedCharacteristics{} mi := &file_product_proto_msgTypes[349] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveSubcategoryParentCategoryContext) String() string { +func (x *BreedCharacteristics) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveSubcategoryParentCategoryContext) ProtoMessage() {} +func (*BreedCharacteristics) ProtoMessage() {} -func (x *ResolveSubcategoryParentCategoryContext) ProtoReflect() protoreflect.Message { +func (x *BreedCharacteristics) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[349] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -17659,39 +17494,54 @@ func (x *ResolveSubcategoryParentCategoryContext) ProtoReflect() protoreflect.Me return mi.MessageOf(x) } -// Deprecated: Use ResolveSubcategoryParentCategoryContext.ProtoReflect.Descriptor instead. -func (*ResolveSubcategoryParentCategoryContext) Descriptor() ([]byte, []int) { +// Deprecated: Use BreedCharacteristics.ProtoReflect.Descriptor instead. +func (*BreedCharacteristics) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{349} } -func (x *ResolveSubcategoryParentCategoryContext) GetId() string { +func (x *BreedCharacteristics) GetSize() string { if x != nil { - return x.Id + return x.Size } return "" } -type ResolveSubcategoryParentCategoryRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - Context []*ResolveSubcategoryParentCategoryContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` +func (x *BreedCharacteristics) GetTemperament() string { + if x != nil { + return x.Temperament + } + return "" +} + +func (x *BreedCharacteristics) GetLifespan() string { + if x != nil { + return x.Lifespan + } + return "" +} + +type ActionSuccess struct { + state protoimpl.MessageState `protogen:"open.v1"` + Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"` + Timestamp string `protobuf:"bytes,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ResolveSubcategoryParentCategoryRequest) Reset() { - *x = ResolveSubcategoryParentCategoryRequest{} +func (x *ActionSuccess) Reset() { + *x = ActionSuccess{} mi := &file_product_proto_msgTypes[350] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveSubcategoryParentCategoryRequest) String() string { +func (x *ActionSuccess) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveSubcategoryParentCategoryRequest) ProtoMessage() {} +func (*ActionSuccess) ProtoMessage() {} -func (x *ResolveSubcategoryParentCategoryRequest) ProtoReflect() protoreflect.Message { +func (x *ActionSuccess) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[350] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -17703,39 +17553,47 @@ func (x *ResolveSubcategoryParentCategoryRequest) ProtoReflect() protoreflect.Me return mi.MessageOf(x) } -// Deprecated: Use ResolveSubcategoryParentCategoryRequest.ProtoReflect.Descriptor instead. -func (*ResolveSubcategoryParentCategoryRequest) Descriptor() ([]byte, []int) { +// Deprecated: Use ActionSuccess.ProtoReflect.Descriptor instead. +func (*ActionSuccess) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{350} } -func (x *ResolveSubcategoryParentCategoryRequest) GetContext() []*ResolveSubcategoryParentCategoryContext { +func (x *ActionSuccess) GetMessage() string { if x != nil { - return x.Context + return x.Message } - return nil + return "" } -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 *ActionSuccess) GetTimestamp() string { + if x != nil { + return x.Timestamp + } + return "" } -func (x *ResolveSubcategoryParentCategoryResult) Reset() { - *x = ResolveSubcategoryParentCategoryResult{} +type ActionError struct { + state protoimpl.MessageState `protogen:"open.v1"` + Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"` + Code string `protobuf:"bytes,2,opt,name=code,proto3" json:"code,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ActionError) Reset() { + *x = ActionError{} mi := &file_product_proto_msgTypes[351] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveSubcategoryParentCategoryResult) String() string { +func (x *ActionError) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveSubcategoryParentCategoryResult) ProtoMessage() {} +func (*ActionError) ProtoMessage() {} -func (x *ResolveSubcategoryParentCategoryResult) ProtoReflect() protoreflect.Message { +func (x *ActionError) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[351] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -17747,39 +17605,49 @@ func (x *ResolveSubcategoryParentCategoryResult) ProtoReflect() protoreflect.Mes return mi.MessageOf(x) } -// Deprecated: Use ResolveSubcategoryParentCategoryResult.ProtoReflect.Descriptor instead. -func (*ResolveSubcategoryParentCategoryResult) Descriptor() ([]byte, []int) { +// Deprecated: Use ActionError.ProtoReflect.Descriptor instead. +func (*ActionError) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{351} } -func (x *ResolveSubcategoryParentCategoryResult) GetParentCategory() *Category { +func (x *ActionError) GetMessage() string { if x != nil { - return x.ParentCategory + return x.Message } - return nil + return "" } -type ResolveSubcategoryParentCategoryResponse struct { - state protoimpl.MessageState `protogen:"open.v1"` - Result []*ResolveSubcategoryParentCategoryResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` +func (x *ActionError) GetCode() string { + if x != nil { + return x.Code + } + return "" +} + +type TestDetails struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Summary string `protobuf:"bytes,2,opt,name=summary,proto3" json:"summary,omitempty"` + Pet *Animal `protobuf:"bytes,3,opt,name=pet,proto3" json:"pet,omitempty"` + Status *ActionResult `protobuf:"bytes,4,opt,name=status,proto3" json:"status,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ResolveSubcategoryParentCategoryResponse) Reset() { - *x = ResolveSubcategoryParentCategoryResponse{} +func (x *TestDetails) Reset() { + *x = TestDetails{} mi := &file_product_proto_msgTypes[352] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveSubcategoryParentCategoryResponse) String() string { +func (x *TestDetails) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveSubcategoryParentCategoryResponse) ProtoMessage() {} +func (*TestDetails) ProtoMessage() {} -func (x *ResolveSubcategoryParentCategoryResponse) ProtoReflect() protoreflect.Message { +func (x *TestDetails) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[352] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -17791,41 +17659,61 @@ func (x *ResolveSubcategoryParentCategoryResponse) ProtoReflect() protoreflect.M return mi.MessageOf(x) } -// Deprecated: Use ResolveSubcategoryParentCategoryResponse.ProtoReflect.Descriptor instead. -func (*ResolveSubcategoryParentCategoryResponse) Descriptor() ([]byte, []int) { +// Deprecated: Use TestDetails.ProtoReflect.Descriptor instead. +func (*TestDetails) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{352} } -func (x *ResolveSubcategoryParentCategoryResponse) GetResult() []*ResolveSubcategoryParentCategoryResult { +func (x *TestDetails) GetId() string { if x != nil { - return x.Result + return x.Id + } + return "" +} + +func (x *TestDetails) GetSummary() string { + if x != nil { + return x.Summary + } + return "" +} + +func (x *TestDetails) GetPet() *Animal { + if x != nil { + return x.Pet } return nil } -// Argument-less field resolver messages for CategoryMetrics.averageScore -type ResolveCategoryMetricsAverageScoreContext struct { +func (x *TestDetails) GetStatus() *ActionResult { + if x != nil { + return x.Status + } + return nil +} + +type CategoryInput 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"` + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Kind CategoryKind `protobuf:"varint,2,opt,name=kind,proto3,enum=productv1.CategoryKind" json:"kind,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ResolveCategoryMetricsAverageScoreContext) Reset() { - *x = ResolveCategoryMetricsAverageScoreContext{} +func (x *CategoryInput) Reset() { + *x = CategoryInput{} mi := &file_product_proto_msgTypes[353] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveCategoryMetricsAverageScoreContext) String() string { +func (x *CategoryInput) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveCategoryMetricsAverageScoreContext) ProtoMessage() {} +func (*CategoryInput) ProtoMessage() {} -func (x *ResolveCategoryMetricsAverageScoreContext) ProtoReflect() protoreflect.Message { +func (x *CategoryInput) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[353] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -17837,46 +17725,49 @@ func (x *ResolveCategoryMetricsAverageScoreContext) ProtoReflect() protoreflect. return mi.MessageOf(x) } -// Deprecated: Use ResolveCategoryMetricsAverageScoreContext.ProtoReflect.Descriptor instead. -func (*ResolveCategoryMetricsAverageScoreContext) Descriptor() ([]byte, []int) { +// Deprecated: Use CategoryInput.ProtoReflect.Descriptor instead. +func (*CategoryInput) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{353} } -func (x *ResolveCategoryMetricsAverageScoreContext) GetId() string { +func (x *CategoryInput) GetName() string { if x != nil { - return x.Id + return x.Name } return "" } -func (x *ResolveCategoryMetricsAverageScoreContext) GetMetricType() string { +func (x *CategoryInput) GetKind() CategoryKind { if x != nil { - return x.MetricType + return x.Kind } - return "" + return CategoryKind_CATEGORY_KIND_UNSPECIFIED } -type ResolveCategoryMetricsAverageScoreRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - Context []*ResolveCategoryMetricsAverageScoreContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` +type ProductCountFilter struct { + state protoimpl.MessageState `protogen:"open.v1"` + MinPrice *wrapperspb.DoubleValue `protobuf:"bytes,1,opt,name=min_price,json=minPrice,proto3" json:"min_price,omitempty"` + MaxPrice *wrapperspb.DoubleValue `protobuf:"bytes,2,opt,name=max_price,json=maxPrice,proto3" json:"max_price,omitempty"` + InStock *wrapperspb.BoolValue `protobuf:"bytes,3,opt,name=in_stock,json=inStock,proto3" json:"in_stock,omitempty"` + SearchTerm *wrapperspb.StringValue `protobuf:"bytes,4,opt,name=search_term,json=searchTerm,proto3" json:"search_term,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ResolveCategoryMetricsAverageScoreRequest) Reset() { - *x = ResolveCategoryMetricsAverageScoreRequest{} +func (x *ProductCountFilter) Reset() { + *x = ProductCountFilter{} mi := &file_product_proto_msgTypes[354] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveCategoryMetricsAverageScoreRequest) String() string { +func (x *ProductCountFilter) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveCategoryMetricsAverageScoreRequest) ProtoMessage() {} +func (*ProductCountFilter) ProtoMessage() {} -func (x *ResolveCategoryMetricsAverageScoreRequest) ProtoReflect() protoreflect.Message { +func (x *ProductCountFilter) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[354] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -17888,39 +17779,64 @@ func (x *ResolveCategoryMetricsAverageScoreRequest) ProtoReflect() protoreflect. return mi.MessageOf(x) } -// Deprecated: Use ResolveCategoryMetricsAverageScoreRequest.ProtoReflect.Descriptor instead. -func (*ResolveCategoryMetricsAverageScoreRequest) Descriptor() ([]byte, []int) { +// Deprecated: Use ProductCountFilter.ProtoReflect.Descriptor instead. +func (*ProductCountFilter) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{354} } -func (x *ResolveCategoryMetricsAverageScoreRequest) GetContext() []*ResolveCategoryMetricsAverageScoreContext { +func (x *ProductCountFilter) GetMinPrice() *wrapperspb.DoubleValue { if x != nil { - return x.Context + return x.MinPrice } 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"` +func (x *ProductCountFilter) GetMaxPrice() *wrapperspb.DoubleValue { + if x != nil { + return x.MaxPrice + } + return nil +} + +func (x *ProductCountFilter) GetInStock() *wrapperspb.BoolValue { + if x != nil { + return x.InStock + } + return nil +} + +func (x *ProductCountFilter) GetSearchTerm() *wrapperspb.StringValue { + if x != nil { + return x.SearchTerm + } + return nil +} + +type SubcategoryItemFilter struct { + state protoimpl.MessageState `protogen:"open.v1"` + MinPrice *wrapperspb.DoubleValue `protobuf:"bytes,1,opt,name=min_price,json=minPrice,proto3" json:"min_price,omitempty"` + MaxPrice *wrapperspb.DoubleValue `protobuf:"bytes,2,opt,name=max_price,json=maxPrice,proto3" json:"max_price,omitempty"` + InStock *wrapperspb.BoolValue `protobuf:"bytes,3,opt,name=in_stock,json=inStock,proto3" json:"in_stock,omitempty"` + IsActive *wrapperspb.BoolValue `protobuf:"bytes,4,opt,name=is_active,json=isActive,proto3" json:"is_active,omitempty"` + SearchTerm *wrapperspb.StringValue `protobuf:"bytes,5,opt,name=search_term,json=searchTerm,proto3" json:"search_term,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ResolveCategoryMetricsAverageScoreResult) Reset() { - *x = ResolveCategoryMetricsAverageScoreResult{} +func (x *SubcategoryItemFilter) Reset() { + *x = SubcategoryItemFilter{} mi := &file_product_proto_msgTypes[355] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveCategoryMetricsAverageScoreResult) String() string { +func (x *SubcategoryItemFilter) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveCategoryMetricsAverageScoreResult) ProtoMessage() {} +func (*SubcategoryItemFilter) ProtoMessage() {} -func (x *ResolveCategoryMetricsAverageScoreResult) ProtoReflect() protoreflect.Message { +func (x *SubcategoryItemFilter) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[355] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -17932,39 +17848,69 @@ func (x *ResolveCategoryMetricsAverageScoreResult) ProtoReflect() protoreflect.M return mi.MessageOf(x) } -// Deprecated: Use ResolveCategoryMetricsAverageScoreResult.ProtoReflect.Descriptor instead. -func (*ResolveCategoryMetricsAverageScoreResult) Descriptor() ([]byte, []int) { +// Deprecated: Use SubcategoryItemFilter.ProtoReflect.Descriptor instead. +func (*SubcategoryItemFilter) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{355} } -func (x *ResolveCategoryMetricsAverageScoreResult) GetAverageScore() float64 { +func (x *SubcategoryItemFilter) GetMinPrice() *wrapperspb.DoubleValue { if x != nil { - return x.AverageScore + return x.MinPrice } - return 0 + return nil } -type ResolveCategoryMetricsAverageScoreResponse struct { - state protoimpl.MessageState `protogen:"open.v1"` - Result []*ResolveCategoryMetricsAverageScoreResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` +func (x *SubcategoryItemFilter) GetMaxPrice() *wrapperspb.DoubleValue { + if x != nil { + return x.MaxPrice + } + return nil +} + +func (x *SubcategoryItemFilter) GetInStock() *wrapperspb.BoolValue { + if x != nil { + return x.InStock + } + return nil +} + +func (x *SubcategoryItemFilter) GetIsActive() *wrapperspb.BoolValue { + if x != nil { + return x.IsActive + } + return nil +} + +func (x *SubcategoryItemFilter) GetSearchTerm() *wrapperspb.StringValue { + if x != nil { + return x.SearchTerm + } + return nil +} + +type ShippingEstimateInput struct { + state protoimpl.MessageState `protogen:"open.v1"` + Destination ShippingDestination `protobuf:"varint,1,opt,name=destination,proto3,enum=productv1.ShippingDestination" json:"destination,omitempty"` + Weight float64 `protobuf:"fixed64,2,opt,name=weight,proto3" json:"weight,omitempty"` + Expedited *wrapperspb.BoolValue `protobuf:"bytes,3,opt,name=expedited,proto3" json:"expedited,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ResolveCategoryMetricsAverageScoreResponse) Reset() { - *x = ResolveCategoryMetricsAverageScoreResponse{} +func (x *ShippingEstimateInput) Reset() { + *x = ShippingEstimateInput{} mi := &file_product_proto_msgTypes[356] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveCategoryMetricsAverageScoreResponse) String() string { +func (x *ShippingEstimateInput) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveCategoryMetricsAverageScoreResponse) ProtoMessage() {} +func (*ShippingEstimateInput) ProtoMessage() {} -func (x *ResolveCategoryMetricsAverageScoreResponse) ProtoReflect() protoreflect.Message { +func (x *ShippingEstimateInput) ProtoReflect() protoreflect.Message { mi := &file_product_proto_msgTypes[356] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -17976,14 +17922,28 @@ func (x *ResolveCategoryMetricsAverageScoreResponse) ProtoReflect() protoreflect return mi.MessageOf(x) } -// Deprecated: Use ResolveCategoryMetricsAverageScoreResponse.ProtoReflect.Descriptor instead. -func (*ResolveCategoryMetricsAverageScoreResponse) Descriptor() ([]byte, []int) { +// Deprecated: Use ShippingEstimateInput.ProtoReflect.Descriptor instead. +func (*ShippingEstimateInput) Descriptor() ([]byte, []int) { return file_product_proto_rawDescGZIP(), []int{356} } -func (x *ResolveCategoryMetricsAverageScoreResponse) GetResult() []*ResolveCategoryMetricsAverageScoreResult { +func (x *ShippingEstimateInput) GetDestination() ShippingDestination { if x != nil { - return x.Result + return x.Destination + } + return ShippingDestination_SHIPPING_DESTINATION_UNSPECIFIED +} + +func (x *ShippingEstimateInput) GetWeight() float64 { + if x != nil { + return x.Weight + } + return 0 +} + +func (x *ShippingEstimateInput) GetExpedited() *wrapperspb.BoolValue { + if x != nil { + return x.Expedited } return nil } @@ -18946,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 { @@ -18991,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 { @@ -19044,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 { @@ -19103,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 { @@ -19155,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 { @@ -19207,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 { @@ -19258,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 { @@ -19753,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" + @@ -19778,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" + @@ -19806,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" + @@ -20023,16 +20026,13 @@ const file_product_proto_rawDesc = "" + "\vtotal_items\x18\x03 \x01(\x05R\n" + "totalItems\x12;\n" + "\vorder_lines\x18\x04 \x01(\v2\x1a.productv1.ListOfOrderLineR\n" + - "orderLines\"\x91\x03\n" + + "orderLines\"\xde\x01\n" + "\bCategory\x12\x0e\n" + "\x02id\x18\x01 \x01(\tR\x02id\x12\x12\n" + "\x04name\x18\x02 \x01(\tR\x04name\x12+\n" + "\x04kind\x18\x03 \x01(\x0e2\x17.productv1.CategoryKindR\x04kind\x12B\n" + "\rsubcategories\x18\x04 \x01(\v2\x1c.productv1.ListOfSubcategoryR\rsubcategories\x12=\n" + - "\fnull_metrics\x18\x05 \x01(\v2\x1a.productv1.CategoryMetricsR\vnullMetrics\x12%\n" + - "\x0etotal_products\x18\x06 \x01(\x05R\rtotalProducts\x12?\n" + - "\x0ftop_subcategory\x18\a \x01(\v2\x16.productv1.SubcategoryR\x0etopSubcategory\x12I\n" + - "\x14active_subcategories\x18\b \x03(\v2\x16.productv1.SubcategoryR\x13activeSubcategories\"|\n" + + "\fnull_metrics\x18\x05 \x01(\v2\x1a.productv1.CategoryMetricsR\vnullMetrics\"|\n" + "\x0eCategoryFilter\x123\n" + "\bcategory\x18\x01 \x01(\x0e2\x17.productv1.CategoryKindR\bcategory\x125\n" + "\n" + @@ -20213,13 +20213,12 @@ const file_product_proto_rawDesc = "" + "\n" + "product_id\x18\x01 \x01(\tR\tproductId\x12\x1a\n" + "\bquantity\x18\x02 \x01(\x05R\bquantity\x125\n" + - "\tmodifiers\x18\x03 \x01(\v2\x17.productv1.ListOfStringR\tmodifiers\"\xcc\x01\n" + + "\tmodifiers\x18\x03 \x01(\v2\x17.productv1.ListOfStringR\tmodifiers\"\x8e\x01\n" + "\vSubcategory\x12\x0e\n" + "\x02id\x18\x01 \x01(\tR\x02id\x12\x12\n" + "\x04name\x18\x02 \x01(\tR\x04name\x12>\n" + "\vdescription\x18\x03 \x01(\v2\x1c.google.protobuf.StringValueR\vdescription\x12\x1b\n" + - "\tis_active\x18\x04 \x01(\bR\bisActive\x12<\n" + - "\x0fparent_category\x18\x05 \x01(\v2\x13.productv1.CategoryR\x0eparentCategory\"\xbc\x01\n" + + "\tis_active\x18\x04 \x01(\bR\bisActive\"\x97\x01\n" + "\x0fCategoryMetrics\x12\x0e\n" + "\x02id\x18\x01 \x01(\tR\x02id\x12\x1f\n" + "\vmetric_type\x18\x02 \x01(\tR\n" + @@ -20227,8 +20226,7 @@ const file_product_proto_rawDesc = "" + "\x05value\x18\x03 \x01(\x01R\x05value\x12\x1c\n" + "\ttimestamp\x18\x04 \x01(\tR\ttimestamp\x12\x1f\n" + "\vcategory_id\x18\x05 \x01(\tR\n" + - "categoryId\x12#\n" + - "\raverage_score\x18\x06 \x01(\x01R\faverageScore\"\xb1\x01\n" + + "categoryId\"\xb1\x01\n" + "\x03Cat\x12\x0e\n" + "\x02id\x18\x01 \x01(\tR\x02id\x12\x12\n" + "\x04name\x18\x02 \x01(\tR\x04name\x12\x12\n" + @@ -20303,50 +20301,7 @@ const file_product_proto_rawDesc = "" + "\x15ShippingEstimateInput\x12@\n" + "\vdestination\x18\x01 \x01(\x0e2\x1e.productv1.ShippingDestinationR\vdestination\x12\x16\n" + "\x06weight\x18\x02 \x01(\x01R\x06weight\x128\n" + - "\texpedited\x18\x03 \x01(\v2\x1a.google.protobuf.BoolValueR\texpedited\"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\"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\"\\\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*\x9a\x01\n" + + "\texpedited\x18\x03 \x01(\v2\x1a.google.protobuf.BoolValueR\texpedited*\x9a\x01\n" + "\fCategoryKind\x12\x1d\n" + "\x19CATEGORY_KIND_UNSPECIFIED\x10\x00\x12\x16\n" + "\x12CATEGORY_KIND_BOOK\x10\x01\x12\x1d\n" + @@ -20419,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" + @@ -20438,13 +20397,9 @@ 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" + - "\x1bResolveTestContainerDetails\x12-.productv1.ResolveTestContainerDetailsRequest\x1a..productv1.ResolveTestContainerDetailsResponse\"\x00\x12\x81\x01\n" + - "\x1cResolveCategoryTotalProducts\x12..productv1.ResolveCategoryTotalProductsRequest\x1a/.productv1.ResolveCategoryTotalProductsResponse\"\x00\x12\x84\x01\n" + - "\x1dResolveCategoryTopSubcategory\x12/.productv1.ResolveCategoryTopSubcategoryRequest\x1a0.productv1.ResolveCategoryTopSubcategoryResponse\"\x00\x12\x93\x01\n" + - "\"ResolveCategoryActiveSubcategories\x124.productv1.ResolveCategoryActiveSubcategoriesRequest\x1a5.productv1.ResolveCategoryActiveSubcategoriesResponse\"\x00\x12\x8d\x01\n" + - " ResolveSubcategoryParentCategory\x122.productv1.ResolveSubcategoryParentCategoryRequest\x1a3.productv1.ResolveSubcategoryParentCategoryResponse\"\x00\x12\x93\x01\n" + - "\"ResolveCategoryMetricsAverageScore\x124.productv1.ResolveCategoryMetricsAverageScoreRequest\x1a5.productv1.ResolveCategoryMetricsAverageScoreResponse\"\x00B%Z#cosmo/pkg/proto/productv1;productv1b\x06proto3" + "\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 ( file_product_proto_rawDescOnce sync.Once @@ -20658,191 +20613,191 @@ 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 - (*ResolveCategoryTotalProductsContext)(nil), // 339: productv1.ResolveCategoryTotalProductsContext - (*ResolveCategoryTotalProductsRequest)(nil), // 340: productv1.ResolveCategoryTotalProductsRequest - (*ResolveCategoryTotalProductsResult)(nil), // 341: productv1.ResolveCategoryTotalProductsResult - (*ResolveCategoryTotalProductsResponse)(nil), // 342: productv1.ResolveCategoryTotalProductsResponse - (*ResolveCategoryTopSubcategoryContext)(nil), // 343: productv1.ResolveCategoryTopSubcategoryContext - (*ResolveCategoryTopSubcategoryRequest)(nil), // 344: productv1.ResolveCategoryTopSubcategoryRequest - (*ResolveCategoryTopSubcategoryResult)(nil), // 345: productv1.ResolveCategoryTopSubcategoryResult - (*ResolveCategoryTopSubcategoryResponse)(nil), // 346: productv1.ResolveCategoryTopSubcategoryResponse - (*ResolveCategoryActiveSubcategoriesContext)(nil), // 347: productv1.ResolveCategoryActiveSubcategoriesContext - (*ResolveCategoryActiveSubcategoriesRequest)(nil), // 348: productv1.ResolveCategoryActiveSubcategoriesRequest - (*ResolveCategoryActiveSubcategoriesResult)(nil), // 349: productv1.ResolveCategoryActiveSubcategoriesResult - (*ResolveCategoryActiveSubcategoriesResponse)(nil), // 350: productv1.ResolveCategoryActiveSubcategoriesResponse - (*ResolveSubcategoryParentCategoryContext)(nil), // 351: productv1.ResolveSubcategoryParentCategoryContext - (*ResolveSubcategoryParentCategoryRequest)(nil), // 352: productv1.ResolveSubcategoryParentCategoryRequest - (*ResolveSubcategoryParentCategoryResult)(nil), // 353: productv1.ResolveSubcategoryParentCategoryResult - (*ResolveSubcategoryParentCategoryResponse)(nil), // 354: productv1.ResolveSubcategoryParentCategoryResponse - (*ResolveCategoryMetricsAverageScoreContext)(nil), // 355: productv1.ResolveCategoryMetricsAverageScoreContext - (*ResolveCategoryMetricsAverageScoreRequest)(nil), // 356: productv1.ResolveCategoryMetricsAverageScoreRequest - (*ResolveCategoryMetricsAverageScoreResult)(nil), // 357: productv1.ResolveCategoryMetricsAverageScoreResult - (*ResolveCategoryMetricsAverageScoreResponse)(nil), // 358: productv1.ResolveCategoryMetricsAverageScoreResponse - (*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 + (*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 @@ -20876,114 +20831,114 @@ var file_product_proto_depIdxs = []int32{ 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 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 @@ -20994,430 +20949,427 @@ var file_product_proto_depIdxs = []int32{ 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 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 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 - 388, // 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 - 380, // 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 - 389, // 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 - 381, // 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 - 382, // 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 - 383, // 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 - 384, // 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 - 385, // 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 - 386, // 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 - 322, // 252: productv1.Category.top_subcategory:type_name -> productv1.Subcategory - 322, // 253: productv1.Category.active_subcategories:type_name -> productv1.Subcategory - 0, // 254: productv1.CategoryFilter.category:type_name -> productv1.CategoryKind - 319, // 255: productv1.CategoryFilter.pagination:type_name -> productv1.Pagination - 324, // 256: productv1.Animal.cat:type_name -> productv1.Cat - 325, // 257: productv1.Animal.dog:type_name -> productv1.Dog - 387, // 258: productv1.SearchInput.limit:type_name -> google.protobuf.Int32Value - 282, // 259: productv1.SearchResult.product:type_name -> productv1.Product - 285, // 260: productv1.SearchResult.user:type_name -> productv1.User - 294, // 261: productv1.SearchResult.category:type_name -> productv1.Category - 389, // 262: productv1.NullableFieldsType.optional_string:type_name -> google.protobuf.StringValue - 387, // 263: productv1.NullableFieldsType.optional_int:type_name -> google.protobuf.Int32Value - 390, // 264: productv1.NullableFieldsType.optional_float:type_name -> google.protobuf.DoubleValue - 388, // 265: productv1.NullableFieldsType.optional_boolean:type_name -> google.protobuf.BoolValue - 389, // 266: productv1.NullableFieldsFilter.name:type_name -> google.protobuf.StringValue - 389, // 267: productv1.NullableFieldsFilter.optional_string:type_name -> google.protobuf.StringValue - 388, // 268: productv1.NullableFieldsFilter.include_nulls:type_name -> google.protobuf.BoolValue - 19, // 269: productv1.BlogPost.optional_tags:type_name -> productv1.ListOfString - 19, // 270: productv1.BlogPost.keywords:type_name -> productv1.ListOfString - 10, // 271: productv1.BlogPost.ratings:type_name -> productv1.ListOfFloat - 7, // 272: productv1.BlogPost.is_published:type_name -> productv1.ListOfBoolean - 13, // 273: productv1.BlogPost.tag_groups:type_name -> productv1.ListOfListOfString - 13, // 274: productv1.BlogPost.related_topics:type_name -> productv1.ListOfListOfString - 13, // 275: productv1.BlogPost.comment_threads:type_name -> productv1.ListOfListOfString - 13, // 276: productv1.BlogPost.suggestions:type_name -> productv1.ListOfListOfString - 294, // 277: productv1.BlogPost.related_categories:type_name -> productv1.Category - 285, // 278: productv1.BlogPost.contributors:type_name -> productv1.User - 17, // 279: productv1.BlogPost.mentioned_products:type_name -> productv1.ListOfProduct - 21, // 280: productv1.BlogPost.mentioned_users:type_name -> productv1.ListOfUser - 11, // 281: productv1.BlogPost.category_groups:type_name -> productv1.ListOfListOfCategory - 14, // 282: productv1.BlogPost.contributor_teams:type_name -> productv1.ListOfListOfUser - 389, // 283: productv1.BlogPostFilter.title:type_name -> google.protobuf.StringValue - 388, // 284: productv1.BlogPostFilter.has_categories:type_name -> google.protobuf.BoolValue - 387, // 285: productv1.BlogPostFilter.min_tags:type_name -> google.protobuf.Int32Value - 389, // 286: productv1.Author.email:type_name -> google.protobuf.StringValue - 19, // 287: productv1.Author.social_links:type_name -> productv1.ListOfString - 13, // 288: productv1.Author.teams_by_project:type_name -> productv1.ListOfListOfString - 13, // 289: productv1.Author.collaborations:type_name -> productv1.ListOfListOfString - 4, // 290: productv1.Author.written_posts:type_name -> productv1.ListOfBlogPost - 294, // 291: productv1.Author.favorite_categories:type_name -> productv1.Category - 21, // 292: productv1.Author.related_authors:type_name -> productv1.ListOfUser - 17, // 293: productv1.Author.product_reviews:type_name -> productv1.ListOfProduct - 14, // 294: productv1.Author.author_groups:type_name -> productv1.ListOfListOfUser - 11, // 295: productv1.Author.category_preferences:type_name -> productv1.ListOfListOfCategory - 14, // 296: productv1.Author.project_teams:type_name -> productv1.ListOfListOfUser - 389, // 297: productv1.AuthorFilter.name:type_name -> google.protobuf.StringValue - 388, // 298: productv1.AuthorFilter.has_teams:type_name -> google.protobuf.BoolValue - 387, // 299: productv1.AuthorFilter.skill_count:type_name -> google.protobuf.Int32Value - 389, // 300: productv1.TestContainer.description:type_name -> google.protobuf.StringValue - 332, // 301: productv1.ActionResult.action_success:type_name -> productv1.ActionSuccess - 333, // 302: productv1.ActionResult.action_error:type_name -> productv1.ActionError - 389, // 303: productv1.NullableFieldsInput.optional_string:type_name -> google.protobuf.StringValue - 387, // 304: productv1.NullableFieldsInput.optional_int:type_name -> google.protobuf.Int32Value - 390, // 305: productv1.NullableFieldsInput.optional_float:type_name -> google.protobuf.DoubleValue - 388, // 306: productv1.NullableFieldsInput.optional_boolean:type_name -> google.protobuf.BoolValue - 19, // 307: productv1.BlogPostInput.optional_tags:type_name -> productv1.ListOfString - 19, // 308: productv1.BlogPostInput.keywords:type_name -> productv1.ListOfString - 10, // 309: productv1.BlogPostInput.ratings:type_name -> productv1.ListOfFloat - 7, // 310: productv1.BlogPostInput.is_published:type_name -> productv1.ListOfBoolean - 13, // 311: productv1.BlogPostInput.tag_groups:type_name -> productv1.ListOfListOfString - 13, // 312: productv1.BlogPostInput.related_topics:type_name -> productv1.ListOfListOfString - 13, // 313: productv1.BlogPostInput.comment_threads:type_name -> productv1.ListOfListOfString - 13, // 314: productv1.BlogPostInput.suggestions:type_name -> productv1.ListOfListOfString - 9, // 315: productv1.BlogPostInput.related_categories:type_name -> productv1.ListOfCategoryInput - 22, // 316: productv1.BlogPostInput.contributors:type_name -> productv1.ListOfUserInput - 12, // 317: productv1.BlogPostInput.category_groups:type_name -> productv1.ListOfListOfCategoryInput - 389, // 318: productv1.AuthorInput.email:type_name -> google.protobuf.StringValue - 19, // 319: productv1.AuthorInput.social_links:type_name -> productv1.ListOfString - 13, // 320: productv1.AuthorInput.teams_by_project:type_name -> productv1.ListOfListOfString - 13, // 321: productv1.AuthorInput.collaborations:type_name -> productv1.ListOfListOfString - 335, // 322: productv1.AuthorInput.favorite_categories:type_name -> productv1.CategoryInput - 15, // 323: productv1.AuthorInput.author_groups:type_name -> productv1.ListOfListOfUserInput - 15, // 324: productv1.AuthorInput.project_teams:type_name -> productv1.ListOfListOfUserInput - 308, // 325: productv1.ProductDetails.review_summary:type_name -> productv1.ActionResult - 296, // 326: productv1.ProductDetails.recommended_pet:type_name -> productv1.Animal - 0, // 327: productv1.StorageCategoryInfo.kind:type_name -> productv1.CategoryKind - 317, // 328: productv1.NestedTypeB.c:type_name -> productv1.NestedTypeC - 319, // 329: productv1.FilterType.pagination:type_name -> productv1.Pagination - 19, // 330: productv1.OrderLineInput.modifiers:type_name -> productv1.ListOfString - 19, // 331: productv1.OrderLine.modifiers:type_name -> productv1.ListOfString - 389, // 332: productv1.Subcategory.description:type_name -> google.protobuf.StringValue - 294, // 333: productv1.Subcategory.parent_category:type_name -> productv1.Category - 326, // 334: productv1.Cat.owner:type_name -> productv1.Owner - 329, // 335: productv1.Cat.breed:type_name -> productv1.CatBreed - 326, // 336: productv1.Dog.owner:type_name -> productv1.Owner - 330, // 337: productv1.Dog.breed:type_name -> productv1.DogBreed - 327, // 338: productv1.Owner.contact:type_name -> productv1.ContactInfo - 296, // 339: productv1.Owner.pet:type_name -> productv1.Animal - 328, // 340: productv1.ContactInfo.address:type_name -> productv1.Address - 331, // 341: productv1.CatBreed.characteristics:type_name -> productv1.BreedCharacteristics - 331, // 342: productv1.DogBreed.characteristics:type_name -> productv1.BreedCharacteristics - 296, // 343: productv1.TestDetails.pet:type_name -> productv1.Animal - 308, // 344: productv1.TestDetails.status:type_name -> productv1.ActionResult - 0, // 345: productv1.CategoryInput.kind:type_name -> productv1.CategoryKind - 390, // 346: productv1.ProductCountFilter.min_price:type_name -> google.protobuf.DoubleValue - 390, // 347: productv1.ProductCountFilter.max_price:type_name -> google.protobuf.DoubleValue - 388, // 348: productv1.ProductCountFilter.in_stock:type_name -> google.protobuf.BoolValue - 389, // 349: productv1.ProductCountFilter.search_term:type_name -> google.protobuf.StringValue - 390, // 350: productv1.SubcategoryItemFilter.min_price:type_name -> google.protobuf.DoubleValue - 390, // 351: productv1.SubcategoryItemFilter.max_price:type_name -> google.protobuf.DoubleValue - 388, // 352: productv1.SubcategoryItemFilter.in_stock:type_name -> google.protobuf.BoolValue - 388, // 353: productv1.SubcategoryItemFilter.is_active:type_name -> google.protobuf.BoolValue - 389, // 354: productv1.SubcategoryItemFilter.search_term:type_name -> google.protobuf.StringValue - 1, // 355: productv1.ShippingEstimateInput.destination:type_name -> productv1.ShippingDestination - 388, // 356: productv1.ShippingEstimateInput.expedited:type_name -> google.protobuf.BoolValue - 339, // 357: productv1.ResolveCategoryTotalProductsRequest.context:type_name -> productv1.ResolveCategoryTotalProductsContext - 341, // 358: productv1.ResolveCategoryTotalProductsResponse.result:type_name -> productv1.ResolveCategoryTotalProductsResult - 343, // 359: productv1.ResolveCategoryTopSubcategoryRequest.context:type_name -> productv1.ResolveCategoryTopSubcategoryContext - 322, // 360: productv1.ResolveCategoryTopSubcategoryResult.top_subcategory:type_name -> productv1.Subcategory - 345, // 361: productv1.ResolveCategoryTopSubcategoryResponse.result:type_name -> productv1.ResolveCategoryTopSubcategoryResult - 347, // 362: productv1.ResolveCategoryActiveSubcategoriesRequest.context:type_name -> productv1.ResolveCategoryActiveSubcategoriesContext - 322, // 363: productv1.ResolveCategoryActiveSubcategoriesResult.active_subcategories:type_name -> productv1.Subcategory - 349, // 364: productv1.ResolveCategoryActiveSubcategoriesResponse.result:type_name -> productv1.ResolveCategoryActiveSubcategoriesResult - 351, // 365: productv1.ResolveSubcategoryParentCategoryRequest.context:type_name -> productv1.ResolveSubcategoryParentCategoryContext - 294, // 366: productv1.ResolveSubcategoryParentCategoryResult.parent_category:type_name -> productv1.Category - 353, // 367: productv1.ResolveSubcategoryParentCategoryResponse.result:type_name -> productv1.ResolveSubcategoryParentCategoryResult - 355, // 368: productv1.ResolveCategoryMetricsAverageScoreRequest.context:type_name -> productv1.ResolveCategoryMetricsAverageScoreContext - 357, // 369: productv1.ResolveCategoryMetricsAverageScoreResponse.result:type_name -> productv1.ResolveCategoryMetricsAverageScoreResult - 304, // 370: productv1.ListOfAuthorFilter.List.items:type_name -> productv1.AuthorFilter - 311, // 371: productv1.ListOfAuthorInput.List.items:type_name -> productv1.AuthorInput - 301, // 372: productv1.ListOfBlogPost.List.items:type_name -> productv1.BlogPost - 302, // 373: productv1.ListOfBlogPostFilter.List.items:type_name -> productv1.BlogPostFilter - 310, // 374: productv1.ListOfBlogPostInput.List.items:type_name -> productv1.BlogPostInput - 294, // 375: productv1.ListOfCategory.List.items:type_name -> productv1.Category - 335, // 376: productv1.ListOfCategoryInput.List.items:type_name -> productv1.CategoryInput - 8, // 377: productv1.ListOfListOfCategory.List.items:type_name -> productv1.ListOfCategory - 9, // 378: productv1.ListOfListOfCategoryInput.List.items:type_name -> productv1.ListOfCategoryInput - 19, // 379: productv1.ListOfListOfString.List.items:type_name -> productv1.ListOfString - 21, // 380: productv1.ListOfListOfUser.List.items:type_name -> productv1.ListOfUser - 22, // 381: productv1.ListOfListOfUserInput.List.items:type_name -> productv1.ListOfUserInput - 321, // 382: productv1.ListOfOrderLine.List.items:type_name -> productv1.OrderLine - 282, // 383: productv1.ListOfProduct.List.items:type_name -> productv1.Product - 283, // 384: productv1.ListOfStorage.List.items:type_name -> productv1.Storage - 322, // 385: productv1.ListOfSubcategory.List.items:type_name -> productv1.Subcategory - 285, // 386: productv1.ListOfUser.List.items:type_name -> productv1.User - 306, // 387: productv1.ListOfUserInput.List.items:type_name -> productv1.UserInput - 0, // 388: productv1.RequireStorageCategoryInfoSummaryByIdFields.StorageCategoryInfo.kind:type_name -> productv1.CategoryKind - 24, // 389: productv1.ProductService.LookupProductById:input_type -> productv1.LookupProductByIdRequest - 27, // 390: productv1.ProductService.LookupStorageById:input_type -> productv1.LookupStorageByIdRequest - 30, // 391: productv1.ProductService.LookupWarehouseById:input_type -> productv1.LookupWarehouseByIdRequest - 114, // 392: productv1.ProductService.MutationBulkCreateAuthors:input_type -> productv1.MutationBulkCreateAuthorsRequest - 118, // 393: productv1.ProductService.MutationBulkCreateBlogPosts:input_type -> productv1.MutationBulkCreateBlogPostsRequest - 116, // 394: productv1.ProductService.MutationBulkUpdateAuthors:input_type -> productv1.MutationBulkUpdateAuthorsRequest - 120, // 395: productv1.ProductService.MutationBulkUpdateBlogPosts:input_type -> productv1.MutationBulkUpdateBlogPostsRequest - 110, // 396: productv1.ProductService.MutationCreateAuthor:input_type -> productv1.MutationCreateAuthorRequest - 106, // 397: productv1.ProductService.MutationCreateBlogPost:input_type -> productv1.MutationCreateBlogPostRequest - 102, // 398: productv1.ProductService.MutationCreateNullableFieldsType:input_type -> productv1.MutationCreateNullableFieldsTypeRequest - 98, // 399: productv1.ProductService.MutationCreateUser:input_type -> productv1.MutationCreateUserRequest - 100, // 400: productv1.ProductService.MutationPerformAction:input_type -> productv1.MutationPerformActionRequest - 112, // 401: productv1.ProductService.MutationUpdateAuthor:input_type -> productv1.MutationUpdateAuthorRequest - 108, // 402: productv1.ProductService.MutationUpdateBlogPost:input_type -> productv1.MutationUpdateBlogPostRequest - 104, // 403: productv1.ProductService.MutationUpdateNullableFieldsType:input_type -> productv1.MutationUpdateNullableFieldsTypeRequest - 88, // 404: productv1.ProductService.QueryAllAuthors:input_type -> productv1.QueryAllAuthorsRequest - 80, // 405: productv1.ProductService.QueryAllBlogPosts:input_type -> productv1.QueryAllBlogPostsRequest - 72, // 406: productv1.ProductService.QueryAllNullableFieldsTypes:input_type -> productv1.QueryAllNullableFieldsTypesRequest - 60, // 407: productv1.ProductService.QueryAllPets:input_type -> productv1.QueryAllPetsRequest - 82, // 408: productv1.ProductService.QueryAuthor:input_type -> productv1.QueryAuthorRequest - 84, // 409: productv1.ProductService.QueryAuthorById:input_type -> productv1.QueryAuthorByIdRequest - 86, // 410: productv1.ProductService.QueryAuthorsWithFilter:input_type -> productv1.QueryAuthorsWithFilterRequest - 74, // 411: productv1.ProductService.QueryBlogPost:input_type -> productv1.QueryBlogPostRequest - 76, // 412: productv1.ProductService.QueryBlogPostById:input_type -> productv1.QueryBlogPostByIdRequest - 78, // 413: productv1.ProductService.QueryBlogPostsWithFilter:input_type -> productv1.QueryBlogPostsWithFilterRequest - 90, // 414: productv1.ProductService.QueryBulkSearchAuthors:input_type -> productv1.QueryBulkSearchAuthorsRequest - 92, // 415: productv1.ProductService.QueryBulkSearchBlogPosts:input_type -> productv1.QueryBulkSearchBlogPostsRequest - 46, // 416: productv1.ProductService.QueryCalculateTotals:input_type -> productv1.QueryCalculateTotalsRequest - 48, // 417: productv1.ProductService.QueryCategories:input_type -> productv1.QueryCategoriesRequest - 52, // 418: productv1.ProductService.QueryCategoriesByKind:input_type -> productv1.QueryCategoriesByKindRequest - 54, // 419: productv1.ProductService.QueryCategoriesByKinds:input_type -> productv1.QueryCategoriesByKindsRequest - 50, // 420: productv1.ProductService.QueryCategory:input_type -> productv1.QueryCategoryRequest - 44, // 421: productv1.ProductService.QueryComplexFilterType:input_type -> productv1.QueryComplexFilterTypeRequest - 56, // 422: productv1.ProductService.QueryFilterCategories:input_type -> productv1.QueryFilterCategoriesRequest - 36, // 423: productv1.ProductService.QueryNestedType:input_type -> productv1.QueryNestedTypeRequest - 66, // 424: productv1.ProductService.QueryNullableFieldsType:input_type -> productv1.QueryNullableFieldsTypeRequest - 68, // 425: productv1.ProductService.QueryNullableFieldsTypeById:input_type -> productv1.QueryNullableFieldsTypeByIdRequest - 70, // 426: productv1.ProductService.QueryNullableFieldsTypeWithFilter:input_type -> productv1.QueryNullableFieldsTypeWithFilterRequest - 58, // 427: productv1.ProductService.QueryRandomPet:input_type -> productv1.QueryRandomPetRequest - 64, // 428: productv1.ProductService.QueryRandomSearchResult:input_type -> productv1.QueryRandomSearchResultRequest - 38, // 429: productv1.ProductService.QueryRecursiveType:input_type -> productv1.QueryRecursiveTypeRequest - 62, // 430: productv1.ProductService.QuerySearch:input_type -> productv1.QuerySearchRequest - 94, // 431: productv1.ProductService.QueryTestContainer:input_type -> productv1.QueryTestContainerRequest - 96, // 432: productv1.ProductService.QueryTestContainers:input_type -> productv1.QueryTestContainersRequest - 40, // 433: productv1.ProductService.QueryTypeFilterWithArguments:input_type -> productv1.QueryTypeFilterWithArgumentsRequest - 42, // 434: productv1.ProductService.QueryTypeWithMultipleFilterFields:input_type -> productv1.QueryTypeWithMultipleFilterFieldsRequest - 34, // 435: productv1.ProductService.QueryUser:input_type -> productv1.QueryUserRequest - 32, // 436: productv1.ProductService.QueryUsers:input_type -> productv1.QueryUsersRequest - 272, // 437: productv1.ProductService.RequireStorageCategoryInfoSummaryById:input_type -> productv1.RequireStorageCategoryInfoSummaryByIdRequest - 267, // 438: productv1.ProductService.RequireStorageKindSummaryById:input_type -> productv1.RequireStorageKindSummaryByIdRequest - 237, // 439: productv1.ProductService.RequireStorageMetadataScoreById:input_type -> productv1.RequireStorageMetadataScoreByIdRequest - 247, // 440: productv1.ProductService.RequireStorageOptionalProcessedMetadataById:input_type -> productv1.RequireStorageOptionalProcessedMetadataByIdRequest - 257, // 441: productv1.ProductService.RequireStorageOptionalProcessedTagsById:input_type -> productv1.RequireStorageOptionalProcessedTagsByIdRequest - 232, // 442: productv1.ProductService.RequireStorageOptionalTagSummaryById:input_type -> productv1.RequireStorageOptionalTagSummaryByIdRequest - 242, // 443: productv1.ProductService.RequireStorageProcessedMetadataById:input_type -> productv1.RequireStorageProcessedMetadataByIdRequest - 262, // 444: productv1.ProductService.RequireStorageProcessedMetadataHistoryById:input_type -> productv1.RequireStorageProcessedMetadataHistoryByIdRequest - 252, // 445: productv1.ProductService.RequireStorageProcessedTagsById:input_type -> productv1.RequireStorageProcessedTagsByIdRequest - 222, // 446: productv1.ProductService.RequireStorageStockHealthScoreById:input_type -> productv1.RequireStorageStockHealthScoreByIdRequest - 227, // 447: productv1.ProductService.RequireStorageTagSummaryById:input_type -> productv1.RequireStorageTagSummaryByIdRequest - 277, // 448: productv1.ProductService.RequireWarehouseStockHealthScoreById:input_type -> productv1.RequireWarehouseStockHealthScoreByIdRequest - 174, // 449: productv1.ProductService.ResolveCategoryCategoryMetrics:input_type -> productv1.ResolveCategoryCategoryMetricsRequest - 184, // 450: productv1.ProductService.ResolveCategoryCategoryStatus:input_type -> productv1.ResolveCategoryCategoryStatusRequest - 189, // 451: productv1.ProductService.ResolveCategoryChildCategories:input_type -> productv1.ResolveCategoryChildCategoriesRequest - 179, // 452: productv1.ProductService.ResolveCategoryMascot:input_type -> productv1.ResolveCategoryMascotRequest - 209, // 453: productv1.ProductService.ResolveCategoryMetricsNormalizedScore:input_type -> productv1.ResolveCategoryMetricsNormalizedScoreRequest - 214, // 454: productv1.ProductService.ResolveCategoryMetricsRelatedCategory:input_type -> productv1.ResolveCategoryMetricsRelatedCategoryRequest - 194, // 455: productv1.ProductService.ResolveCategoryOptionalCategories:input_type -> productv1.ResolveCategoryOptionalCategoriesRequest - 169, // 456: productv1.ProductService.ResolveCategoryPopularityScore:input_type -> productv1.ResolveCategoryPopularityScoreRequest - 164, // 457: productv1.ProductService.ResolveCategoryProductCount:input_type -> productv1.ResolveCategoryProductCountRequest - 134, // 458: productv1.ProductService.ResolveProductMascotRecommendation:input_type -> productv1.ResolveProductMascotRecommendationRequest - 144, // 459: productv1.ProductService.ResolveProductProductDetails:input_type -> productv1.ResolveProductProductDetailsRequest - 129, // 460: productv1.ProductService.ResolveProductRecommendedCategory:input_type -> productv1.ResolveProductRecommendedCategoryRequest - 124, // 461: productv1.ProductService.ResolveProductShippingEstimate:input_type -> productv1.ResolveProductShippingEstimateRequest - 139, // 462: productv1.ProductService.ResolveProductStockStatus:input_type -> productv1.ResolveProductStockStatusRequest - 154, // 463: productv1.ProductService.ResolveStorageLinkedStorages:input_type -> productv1.ResolveStorageLinkedStoragesRequest - 159, // 464: productv1.ProductService.ResolveStorageNearbyStorages:input_type -> productv1.ResolveStorageNearbyStoragesRequest - 149, // 465: productv1.ProductService.ResolveStorageStorageStatus:input_type -> productv1.ResolveStorageStorageStatusRequest - 204, // 466: productv1.ProductService.ResolveSubcategoryFeaturedCategory:input_type -> productv1.ResolveSubcategoryFeaturedCategoryRequest - 199, // 467: productv1.ProductService.ResolveSubcategoryItemCount:input_type -> productv1.ResolveSubcategoryItemCountRequest - 219, // 468: productv1.ProductService.ResolveTestContainerDetails:input_type -> productv1.ResolveTestContainerDetailsRequest - 340, // 469: productv1.ProductService.ResolveCategoryTotalProducts:input_type -> productv1.ResolveCategoryTotalProductsRequest - 344, // 470: productv1.ProductService.ResolveCategoryTopSubcategory:input_type -> productv1.ResolveCategoryTopSubcategoryRequest - 348, // 471: productv1.ProductService.ResolveCategoryActiveSubcategories:input_type -> productv1.ResolveCategoryActiveSubcategoriesRequest - 352, // 472: productv1.ProductService.ResolveSubcategoryParentCategory:input_type -> productv1.ResolveSubcategoryParentCategoryRequest - 356, // 473: productv1.ProductService.ResolveCategoryMetricsAverageScore:input_type -> productv1.ResolveCategoryMetricsAverageScoreRequest - 25, // 474: productv1.ProductService.LookupProductById:output_type -> productv1.LookupProductByIdResponse - 28, // 475: productv1.ProductService.LookupStorageById:output_type -> productv1.LookupStorageByIdResponse - 31, // 476: productv1.ProductService.LookupWarehouseById:output_type -> productv1.LookupWarehouseByIdResponse - 115, // 477: productv1.ProductService.MutationBulkCreateAuthors:output_type -> productv1.MutationBulkCreateAuthorsResponse - 119, // 478: productv1.ProductService.MutationBulkCreateBlogPosts:output_type -> productv1.MutationBulkCreateBlogPostsResponse - 117, // 479: productv1.ProductService.MutationBulkUpdateAuthors:output_type -> productv1.MutationBulkUpdateAuthorsResponse - 121, // 480: productv1.ProductService.MutationBulkUpdateBlogPosts:output_type -> productv1.MutationBulkUpdateBlogPostsResponse - 111, // 481: productv1.ProductService.MutationCreateAuthor:output_type -> productv1.MutationCreateAuthorResponse - 107, // 482: productv1.ProductService.MutationCreateBlogPost:output_type -> productv1.MutationCreateBlogPostResponse - 103, // 483: productv1.ProductService.MutationCreateNullableFieldsType:output_type -> productv1.MutationCreateNullableFieldsTypeResponse - 99, // 484: productv1.ProductService.MutationCreateUser:output_type -> productv1.MutationCreateUserResponse - 101, // 485: productv1.ProductService.MutationPerformAction:output_type -> productv1.MutationPerformActionResponse - 113, // 486: productv1.ProductService.MutationUpdateAuthor:output_type -> productv1.MutationUpdateAuthorResponse - 109, // 487: productv1.ProductService.MutationUpdateBlogPost:output_type -> productv1.MutationUpdateBlogPostResponse - 105, // 488: productv1.ProductService.MutationUpdateNullableFieldsType:output_type -> productv1.MutationUpdateNullableFieldsTypeResponse - 89, // 489: productv1.ProductService.QueryAllAuthors:output_type -> productv1.QueryAllAuthorsResponse - 81, // 490: productv1.ProductService.QueryAllBlogPosts:output_type -> productv1.QueryAllBlogPostsResponse - 73, // 491: productv1.ProductService.QueryAllNullableFieldsTypes:output_type -> productv1.QueryAllNullableFieldsTypesResponse - 61, // 492: productv1.ProductService.QueryAllPets:output_type -> productv1.QueryAllPetsResponse - 83, // 493: productv1.ProductService.QueryAuthor:output_type -> productv1.QueryAuthorResponse - 85, // 494: productv1.ProductService.QueryAuthorById:output_type -> productv1.QueryAuthorByIdResponse - 87, // 495: productv1.ProductService.QueryAuthorsWithFilter:output_type -> productv1.QueryAuthorsWithFilterResponse - 75, // 496: productv1.ProductService.QueryBlogPost:output_type -> productv1.QueryBlogPostResponse - 77, // 497: productv1.ProductService.QueryBlogPostById:output_type -> productv1.QueryBlogPostByIdResponse - 79, // 498: productv1.ProductService.QueryBlogPostsWithFilter:output_type -> productv1.QueryBlogPostsWithFilterResponse - 91, // 499: productv1.ProductService.QueryBulkSearchAuthors:output_type -> productv1.QueryBulkSearchAuthorsResponse - 93, // 500: productv1.ProductService.QueryBulkSearchBlogPosts:output_type -> productv1.QueryBulkSearchBlogPostsResponse - 47, // 501: productv1.ProductService.QueryCalculateTotals:output_type -> productv1.QueryCalculateTotalsResponse - 49, // 502: productv1.ProductService.QueryCategories:output_type -> productv1.QueryCategoriesResponse - 53, // 503: productv1.ProductService.QueryCategoriesByKind:output_type -> productv1.QueryCategoriesByKindResponse - 55, // 504: productv1.ProductService.QueryCategoriesByKinds:output_type -> productv1.QueryCategoriesByKindsResponse - 51, // 505: productv1.ProductService.QueryCategory:output_type -> productv1.QueryCategoryResponse - 45, // 506: productv1.ProductService.QueryComplexFilterType:output_type -> productv1.QueryComplexFilterTypeResponse - 57, // 507: productv1.ProductService.QueryFilterCategories:output_type -> productv1.QueryFilterCategoriesResponse - 37, // 508: productv1.ProductService.QueryNestedType:output_type -> productv1.QueryNestedTypeResponse - 67, // 509: productv1.ProductService.QueryNullableFieldsType:output_type -> productv1.QueryNullableFieldsTypeResponse - 69, // 510: productv1.ProductService.QueryNullableFieldsTypeById:output_type -> productv1.QueryNullableFieldsTypeByIdResponse - 71, // 511: productv1.ProductService.QueryNullableFieldsTypeWithFilter:output_type -> productv1.QueryNullableFieldsTypeWithFilterResponse - 59, // 512: productv1.ProductService.QueryRandomPet:output_type -> productv1.QueryRandomPetResponse - 65, // 513: productv1.ProductService.QueryRandomSearchResult:output_type -> productv1.QueryRandomSearchResultResponse - 39, // 514: productv1.ProductService.QueryRecursiveType:output_type -> productv1.QueryRecursiveTypeResponse - 63, // 515: productv1.ProductService.QuerySearch:output_type -> productv1.QuerySearchResponse - 95, // 516: productv1.ProductService.QueryTestContainer:output_type -> productv1.QueryTestContainerResponse - 97, // 517: productv1.ProductService.QueryTestContainers:output_type -> productv1.QueryTestContainersResponse - 41, // 518: productv1.ProductService.QueryTypeFilterWithArguments:output_type -> productv1.QueryTypeFilterWithArgumentsResponse - 43, // 519: productv1.ProductService.QueryTypeWithMultipleFilterFields:output_type -> productv1.QueryTypeWithMultipleFilterFieldsResponse - 35, // 520: productv1.ProductService.QueryUser:output_type -> productv1.QueryUserResponse - 33, // 521: productv1.ProductService.QueryUsers:output_type -> productv1.QueryUsersResponse - 274, // 522: productv1.ProductService.RequireStorageCategoryInfoSummaryById:output_type -> productv1.RequireStorageCategoryInfoSummaryByIdResponse - 269, // 523: productv1.ProductService.RequireStorageKindSummaryById:output_type -> productv1.RequireStorageKindSummaryByIdResponse - 239, // 524: productv1.ProductService.RequireStorageMetadataScoreById:output_type -> productv1.RequireStorageMetadataScoreByIdResponse - 249, // 525: productv1.ProductService.RequireStorageOptionalProcessedMetadataById:output_type -> productv1.RequireStorageOptionalProcessedMetadataByIdResponse - 259, // 526: productv1.ProductService.RequireStorageOptionalProcessedTagsById:output_type -> productv1.RequireStorageOptionalProcessedTagsByIdResponse - 234, // 527: productv1.ProductService.RequireStorageOptionalTagSummaryById:output_type -> productv1.RequireStorageOptionalTagSummaryByIdResponse - 244, // 528: productv1.ProductService.RequireStorageProcessedMetadataById:output_type -> productv1.RequireStorageProcessedMetadataByIdResponse - 264, // 529: productv1.ProductService.RequireStorageProcessedMetadataHistoryById:output_type -> productv1.RequireStorageProcessedMetadataHistoryByIdResponse - 254, // 530: productv1.ProductService.RequireStorageProcessedTagsById:output_type -> productv1.RequireStorageProcessedTagsByIdResponse - 224, // 531: productv1.ProductService.RequireStorageStockHealthScoreById:output_type -> productv1.RequireStorageStockHealthScoreByIdResponse - 229, // 532: productv1.ProductService.RequireStorageTagSummaryById:output_type -> productv1.RequireStorageTagSummaryByIdResponse - 279, // 533: productv1.ProductService.RequireWarehouseStockHealthScoreById:output_type -> productv1.RequireWarehouseStockHealthScoreByIdResponse - 176, // 534: productv1.ProductService.ResolveCategoryCategoryMetrics:output_type -> productv1.ResolveCategoryCategoryMetricsResponse - 186, // 535: productv1.ProductService.ResolveCategoryCategoryStatus:output_type -> productv1.ResolveCategoryCategoryStatusResponse - 191, // 536: productv1.ProductService.ResolveCategoryChildCategories:output_type -> productv1.ResolveCategoryChildCategoriesResponse - 181, // 537: productv1.ProductService.ResolveCategoryMascot:output_type -> productv1.ResolveCategoryMascotResponse - 211, // 538: productv1.ProductService.ResolveCategoryMetricsNormalizedScore:output_type -> productv1.ResolveCategoryMetricsNormalizedScoreResponse - 216, // 539: productv1.ProductService.ResolveCategoryMetricsRelatedCategory:output_type -> productv1.ResolveCategoryMetricsRelatedCategoryResponse - 196, // 540: productv1.ProductService.ResolveCategoryOptionalCategories:output_type -> productv1.ResolveCategoryOptionalCategoriesResponse - 171, // 541: productv1.ProductService.ResolveCategoryPopularityScore:output_type -> productv1.ResolveCategoryPopularityScoreResponse - 166, // 542: productv1.ProductService.ResolveCategoryProductCount:output_type -> productv1.ResolveCategoryProductCountResponse - 136, // 543: productv1.ProductService.ResolveProductMascotRecommendation:output_type -> productv1.ResolveProductMascotRecommendationResponse - 146, // 544: productv1.ProductService.ResolveProductProductDetails:output_type -> productv1.ResolveProductProductDetailsResponse - 131, // 545: productv1.ProductService.ResolveProductRecommendedCategory:output_type -> productv1.ResolveProductRecommendedCategoryResponse - 126, // 546: productv1.ProductService.ResolveProductShippingEstimate:output_type -> productv1.ResolveProductShippingEstimateResponse - 141, // 547: productv1.ProductService.ResolveProductStockStatus:output_type -> productv1.ResolveProductStockStatusResponse - 156, // 548: productv1.ProductService.ResolveStorageLinkedStorages:output_type -> productv1.ResolveStorageLinkedStoragesResponse - 161, // 549: productv1.ProductService.ResolveStorageNearbyStorages:output_type -> productv1.ResolveStorageNearbyStoragesResponse - 151, // 550: productv1.ProductService.ResolveStorageStorageStatus:output_type -> productv1.ResolveStorageStorageStatusResponse - 206, // 551: productv1.ProductService.ResolveSubcategoryFeaturedCategory:output_type -> productv1.ResolveSubcategoryFeaturedCategoryResponse - 201, // 552: productv1.ProductService.ResolveSubcategoryItemCount:output_type -> productv1.ResolveSubcategoryItemCountResponse - 221, // 553: productv1.ProductService.ResolveTestContainerDetails:output_type -> productv1.ResolveTestContainerDetailsResponse - 342, // 554: productv1.ProductService.ResolveCategoryTotalProducts:output_type -> productv1.ResolveCategoryTotalProductsResponse - 346, // 555: productv1.ProductService.ResolveCategoryTopSubcategory:output_type -> productv1.ResolveCategoryTopSubcategoryResponse - 350, // 556: productv1.ProductService.ResolveCategoryActiveSubcategories:output_type -> productv1.ResolveCategoryActiveSubcategoriesResponse - 354, // 557: productv1.ProductService.ResolveSubcategoryParentCategory:output_type -> productv1.ResolveSubcategoryParentCategoryResponse - 358, // 558: productv1.ProductService.ResolveCategoryMetricsAverageScore:output_type -> productv1.ResolveCategoryMetricsAverageScoreResponse - 474, // [474:559] is the sub-list for method output_type - 389, // [389:474] is the sub-list for method input_type - 389, // [389:389] is the sub-list for extension type_name - 389, // [389:389] is the sub-list for extension extendee - 0, // [0:389] 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() } @@ -21425,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), } diff --git a/v2/pkg/grpctest/productv1/product_grpc.pb.go b/v2/pkg/grpctest/productv1/product_grpc.pb.go index 440b986a70..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,12 +102,8 @@ const ( ProductService_ResolveStorageStorageStatus_FullMethodName = "/productv1.ProductService/ResolveStorageStorageStatus" ProductService_ResolveSubcategoryFeaturedCategory_FullMethodName = "/productv1.ProductService/ResolveSubcategoryFeaturedCategory" ProductService_ResolveSubcategoryItemCount_FullMethodName = "/productv1.ProductService/ResolveSubcategoryItemCount" - ProductService_ResolveTestContainerDetails_FullMethodName = "/productv1.ProductService/ResolveTestContainerDetails" - ProductService_ResolveCategoryTotalProducts_FullMethodName = "/productv1.ProductService/ResolveCategoryTotalProducts" - ProductService_ResolveCategoryTopSubcategory_FullMethodName = "/productv1.ProductService/ResolveCategoryTopSubcategory" - ProductService_ResolveCategoryActiveSubcategories_FullMethodName = "/productv1.ProductService/ResolveCategoryActiveSubcategories" ProductService_ResolveSubcategoryParentCategory_FullMethodName = "/productv1.ProductService/ResolveSubcategoryParentCategory" - ProductService_ResolveCategoryMetricsAverageScore_FullMethodName = "/productv1.ProductService/ResolveCategoryMetricsAverageScore" + ProductService_ResolveTestContainerDetails_FullMethodName = "/productv1.ProductService/ResolveTestContainerDetails" ) // ProductServiceClient is the client API for ProductService service. @@ -175,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) @@ -194,12 +198,8 @@ 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) - ResolveTestContainerDetails(ctx context.Context, in *ResolveTestContainerDetailsRequest, opts ...grpc.CallOption) (*ResolveTestContainerDetailsResponse, error) - ResolveCategoryTotalProducts(ctx context.Context, in *ResolveCategoryTotalProductsRequest, opts ...grpc.CallOption) (*ResolveCategoryTotalProductsResponse, error) - ResolveCategoryTopSubcategory(ctx context.Context, in *ResolveCategoryTopSubcategoryRequest, opts ...grpc.CallOption) (*ResolveCategoryTopSubcategoryResponse, error) - ResolveCategoryActiveSubcategories(ctx context.Context, in *ResolveCategoryActiveSubcategoriesRequest, opts ...grpc.CallOption) (*ResolveCategoryActiveSubcategoriesResponse, error) ResolveSubcategoryParentCategory(ctx context.Context, in *ResolveSubcategoryParentCategoryRequest, opts ...grpc.CallOption) (*ResolveSubcategoryParentCategoryResponse, error) - ResolveCategoryMetricsAverageScore(ctx context.Context, in *ResolveCategoryMetricsAverageScoreRequest, opts ...grpc.CallOption) (*ResolveCategoryMetricsAverageScoreResponse, error) + ResolveTestContainerDetails(ctx context.Context, in *ResolveTestContainerDetailsRequest, opts ...grpc.CallOption) (*ResolveTestContainerDetailsResponse, error) } type productServiceClient struct { @@ -810,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) @@ -850,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) @@ -900,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) @@ -1000,46 +1040,6 @@ func (c *productServiceClient) ResolveSubcategoryItemCount(ctx context.Context, 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) - err := c.cc.Invoke(ctx, ProductService_ResolveTestContainerDetails_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) 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) 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) ResolveSubcategoryParentCategory(ctx context.Context, in *ResolveSubcategoryParentCategoryRequest, opts ...grpc.CallOption) (*ResolveSubcategoryParentCategoryResponse, error) { cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(ResolveSubcategoryParentCategoryResponse) @@ -1050,10 +1050,10 @@ func (c *productServiceClient) ResolveSubcategoryParentCategory(ctx context.Cont return out, nil } -func (c *productServiceClient) ResolveCategoryMetricsAverageScore(ctx context.Context, in *ResolveCategoryMetricsAverageScoreRequest, opts ...grpc.CallOption) (*ResolveCategoryMetricsAverageScoreResponse, error) { +func (c *productServiceClient) ResolveTestContainerDetails(ctx context.Context, in *ResolveTestContainerDetailsRequest, opts ...grpc.CallOption) (*ResolveTestContainerDetailsResponse, error) { cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) - out := new(ResolveCategoryMetricsAverageScoreResponse) - err := c.cc.Invoke(ctx, ProductService_ResolveCategoryMetricsAverageScore_FullMethodName, in, out, cOpts...) + out := new(ResolveTestContainerDetailsResponse) + err := c.cc.Invoke(ctx, ProductService_ResolveTestContainerDetails_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -1129,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) @@ -1148,12 +1152,8 @@ type ProductServiceServer interface { ResolveStorageStorageStatus(context.Context, *ResolveStorageStorageStatusRequest) (*ResolveStorageStorageStatusResponse, error) ResolveSubcategoryFeaturedCategory(context.Context, *ResolveSubcategoryFeaturedCategoryRequest) (*ResolveSubcategoryFeaturedCategoryResponse, error) ResolveSubcategoryItemCount(context.Context, *ResolveSubcategoryItemCountRequest) (*ResolveSubcategoryItemCountResponse, error) - ResolveTestContainerDetails(context.Context, *ResolveTestContainerDetailsRequest) (*ResolveTestContainerDetailsResponse, error) - ResolveCategoryTotalProducts(context.Context, *ResolveCategoryTotalProductsRequest) (*ResolveCategoryTotalProductsResponse, error) - ResolveCategoryTopSubcategory(context.Context, *ResolveCategoryTopSubcategoryRequest) (*ResolveCategoryTopSubcategoryResponse, error) - ResolveCategoryActiveSubcategories(context.Context, *ResolveCategoryActiveSubcategoriesRequest) (*ResolveCategoryActiveSubcategoriesResponse, error) ResolveSubcategoryParentCategory(context.Context, *ResolveSubcategoryParentCategoryRequest) (*ResolveSubcategoryParentCategoryResponse, error) - ResolveCategoryMetricsAverageScore(context.Context, *ResolveCategoryMetricsAverageScoreRequest) (*ResolveCategoryMetricsAverageScoreResponse, error) + ResolveTestContainerDetails(context.Context, *ResolveTestContainerDetailsRequest) (*ResolveTestContainerDetailsResponse, error) mustEmbedUnimplementedProductServiceServer() } @@ -1344,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") } @@ -1356,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") } @@ -1371,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") } @@ -1401,23 +1413,11 @@ func (UnimplementedProductServiceServer) ResolveSubcategoryFeaturedCategory(cont func (UnimplementedProductServiceServer) ResolveSubcategoryItemCount(context.Context, *ResolveSubcategoryItemCountRequest) (*ResolveSubcategoryItemCountResponse, error) { return nil, status.Error(codes.Unimplemented, "method ResolveSubcategoryItemCount not implemented") } -func (UnimplementedProductServiceServer) ResolveTestContainerDetails(context.Context, *ResolveTestContainerDetailsRequest) (*ResolveTestContainerDetailsResponse, error) { - return nil, status.Error(codes.Unimplemented, "method ResolveTestContainerDetails not implemented") -} -func (UnimplementedProductServiceServer) ResolveCategoryTotalProducts(context.Context, *ResolveCategoryTotalProductsRequest) (*ResolveCategoryTotalProductsResponse, error) { - return nil, status.Error(codes.Unimplemented, "method ResolveCategoryTotalProducts not implemented") -} -func (UnimplementedProductServiceServer) ResolveCategoryTopSubcategory(context.Context, *ResolveCategoryTopSubcategoryRequest) (*ResolveCategoryTopSubcategoryResponse, error) { - return nil, status.Error(codes.Unimplemented, "method ResolveCategoryTopSubcategory not implemented") -} -func (UnimplementedProductServiceServer) ResolveCategoryActiveSubcategories(context.Context, *ResolveCategoryActiveSubcategoriesRequest) (*ResolveCategoryActiveSubcategoriesResponse, error) { - return nil, status.Error(codes.Unimplemented, "method ResolveCategoryActiveSubcategories not implemented") -} func (UnimplementedProductServiceServer) ResolveSubcategoryParentCategory(context.Context, *ResolveSubcategoryParentCategoryRequest) (*ResolveSubcategoryParentCategoryResponse, error) { return nil, status.Error(codes.Unimplemented, "method ResolveSubcategoryParentCategory not implemented") } -func (UnimplementedProductServiceServer) ResolveCategoryMetricsAverageScore(context.Context, *ResolveCategoryMetricsAverageScoreRequest) (*ResolveCategoryMetricsAverageScoreResponse, error) { - return nil, status.Error(codes.Unimplemented, "method ResolveCategoryMetricsAverageScore not implemented") +func (UnimplementedProductServiceServer) ResolveTestContainerDetails(context.Context, *ResolveTestContainerDetailsRequest) (*ResolveTestContainerDetailsResponse, error) { + return nil, status.Error(codes.Unimplemented, "method ResolveTestContainerDetails not implemented") } func (UnimplementedProductServiceServer) mustEmbedUnimplementedProductServiceServer() {} func (UnimplementedProductServiceServer) testEmbeddedByValue() {} @@ -2520,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 { @@ -2592,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 { @@ -2682,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 { @@ -2862,78 +2934,6 @@ func _ProductService_ResolveSubcategoryItemCount_Handler(srv interface{}, ctx co 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 { - return nil, err - } - if interceptor == nil { - return srv.(ProductServiceServer).ResolveTestContainerDetails(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: ProductService_ResolveTestContainerDetails_FullMethodName, - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(ProductServiceServer).ResolveTestContainerDetails(ctx, req.(*ResolveTestContainerDetailsRequest)) - } - 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_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_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_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 { @@ -2952,20 +2952,20 @@ func _ProductService_ResolveSubcategoryParentCategory_Handler(srv interface{}, c 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) +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 { return nil, err } if interceptor == nil { - return srv.(ProductServiceServer).ResolveCategoryMetricsAverageScore(ctx, in) + return srv.(ProductServiceServer).ResolveTestContainerDetails(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: ProductService_ResolveCategoryMetricsAverageScore_FullMethodName, + FullMethod: ProductService_ResolveTestContainerDetails_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(ProductServiceServer).ResolveCategoryMetricsAverageScore(ctx, req.(*ResolveCategoryMetricsAverageScoreRequest)) + return srv.(ProductServiceServer).ResolveTestContainerDetails(ctx, req.(*ResolveTestContainerDetailsRequest)) } return interceptor(ctx, in, info, handler) } @@ -3217,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, @@ -3233,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, @@ -3253,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, @@ -3293,29 +3309,13 @@ var ProductService_ServiceDesc = grpc.ServiceDesc{ MethodName: "ResolveSubcategoryItemCount", Handler: _ProductService_ResolveSubcategoryItemCount_Handler, }, - { - MethodName: "ResolveTestContainerDetails", - Handler: _ProductService_ResolveTestContainerDetails_Handler, - }, - { - MethodName: "ResolveCategoryTotalProducts", - Handler: _ProductService_ResolveCategoryTotalProducts_Handler, - }, - { - MethodName: "ResolveCategoryTopSubcategory", - Handler: _ProductService_ResolveCategoryTopSubcategory_Handler, - }, - { - MethodName: "ResolveCategoryActiveSubcategories", - Handler: _ProductService_ResolveCategoryActiveSubcategories_Handler, - }, { MethodName: "ResolveSubcategoryParentCategory", Handler: _ProductService_ResolveSubcategoryParentCategory_Handler, }, { - MethodName: "ResolveCategoryMetricsAverageScore", - Handler: _ProductService_ResolveCategoryMetricsAverageScore_Handler, + MethodName: "ResolveTestContainerDetails", + Handler: _ProductService_ResolveTestContainerDetails_Handler, }, }, Streams: []grpc.StreamDesc{}, From 2cd631249f01b36b6b46f9c68d037463f042a925 Mon Sep 17 00:00:00 2001 From: Ludwig Bedacht Date: Wed, 11 Mar 2026 15:11:51 +0100 Subject: [PATCH 3/3] chore: improve --- v2/pkg/grpctest/Makefile | 26 +++++++++++++++++----- v2/pkg/grpctest/cmd/mapping_helper/main.go | 10 ++++----- 2 files changed, 25 insertions(+), 11 deletions(-) diff --git a/v2/pkg/grpctest/Makefile b/v2/pkg/grpctest/Makefile index dd701ca9e9..bb8fd892b4 100644 --- a/v2/pkg/grpctest/Makefile +++ b/v2/pkg/grpctest/Makefile @@ -23,20 +23,20 @@ regenerate-proto: rm -f $(mkfile_dir)/testdata/service.proto.lock.json .PHONY: generate-mapping-code -generate-mapping-code: generate-mapping-code-grpc-test generate-mapping-code-grpc-datasource regenerate-proto cleanup-mapping-file +generate-mapping-code: cleanup-mapping-file .PHONY: generate-mapping-code-grpc-test -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: - go run $(mkfile_dir)/cmd/mapping_helper/main.go -without-package $(mkfile_dir)/testdata/mapping.json $(grpc_datasource_dir)/mapping_test_helper.go +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: +cleanup-mapping-file: generate-mapping-code-grpc-datasource rm -f $(mkfile_dir)/testdata/mapping.json @@ -47,7 +47,21 @@ 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-grpc-test generate-mapping-code-grpc-datasource cleanup-mapping-file +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 .PHONY: generate-all diff --git a/v2/pkg/grpctest/cmd/mapping_helper/main.go b/v2/pkg/grpctest/cmd/mapping_helper/main.go index 1fc45c9579..f0a35c50b0 100644 --- a/v2/pkg/grpctest/cmd/mapping_helper/main.go +++ b/v2/pkg/grpctest/cmd/mapping_helper/main.go @@ -102,14 +102,14 @@ var ( //go:embed templates/grpctest_mapping.tmpl tpl string //go:embed templates/grcp_datasource_mapping_helper.tmpl - tplWithoutPackage string + tplGRPCDatasource string - withoutPackage bool + grpcDatasource bool ) // define flags for the command func init() { - flag.BoolVar(&withoutPackage, "without-package", false, "generate mapping without package") + flag.BoolVar(&grpcDatasource, "grpc-datasource", false, "use the grpc_datasource package template") } func main() { @@ -159,8 +159,8 @@ func main() { } var usedTemplate = tpl - if withoutPackage { - usedTemplate = tplWithoutPackage + if grpcDatasource { + usedTemplate = tplGRPCDatasource } t := template.Must(template.New("mapping").Parse(usedTemplate))