From 634e76b8157935406e613238de464c416bb64375 Mon Sep 17 00:00:00 2001 From: Ludwig Bedacht Date: Tue, 11 Aug 2026 13:28:16 +0200 Subject: [PATCH] fix: handling of nullable lists for required fields --- .../datasource/grpc_datasource/compiler.go | 3 +- .../execution_plan_requires_test.go | 595 ++ .../grpc_datasource_federation_test.go | 398 + .../grpc_datasource/mapping_test_helper.go | 47 + v2/pkg/grpctest/mapping/mapping.go | 47 + v2/pkg/grpctest/mockservice_connect.go | 36 + v2/pkg/grpctest/mockservice_requires.go | 180 + v2/pkg/grpctest/product.proto | 132 +- v2/pkg/grpctest/productv1/product.pb.go | 8458 ++++++++++------- v2/pkg/grpctest/productv1/product_grpc.pb.go | 350 +- .../productv1connect/product.connect.go | 317 +- v2/pkg/grpctest/schema.go | 38 + v2/pkg/grpctest/testdata/products.graphqls | 16 +- 13 files changed, 6945 insertions(+), 3672 deletions(-) diff --git a/v2/pkg/engine/datasource/grpc_datasource/compiler.go b/v2/pkg/engine/datasource/grpc_datasource/compiler.go index a7444a0651..4f6c0d336c 100644 --- a/v2/pkg/engine/datasource/grpc_datasource/compiler.go +++ b/v2/pkg/engine/datasource/grpc_datasource/compiler.go @@ -1288,7 +1288,8 @@ func (p *RPCCompiler) traverseList(rootMsg protoref.Message, level int, field *F elements := data.Array() newListField := rootMsg.NewField(listFieldDesc) if len(elements) == 0 { - if rpcField.ListMetadata.LevelInfo[level-1].Optional { + // We need to explicitly check for null because an empty list must still initialize the wrapper + if isNullValue(data) && rpcField.ListMetadata.LevelInfo[level-1].Optional { return nil, nil } diff --git a/v2/pkg/engine/datasource/grpc_datasource/execution_plan_requires_test.go b/v2/pkg/engine/datasource/grpc_datasource/execution_plan_requires_test.go index 0d998b5080..03713996af 100644 --- a/v2/pkg/engine/datasource/grpc_datasource/execution_plan_requires_test.go +++ b/v2/pkg/engine/datasource/grpc_datasource/execution_plan_requires_test.go @@ -5719,3 +5719,598 @@ func TestExecutionPlan_FederationRequires_WithFieldResolvers(t *testing.T) { }) } } + +// TestExecutionPlan_FederationRequires_NullableLists covers @requires fields whose return type or +// field argument is a nullable list. Nullable lists are transported in a generated ListOfX wrapper +// message, which the planner represents with IsListType plus an optional ListMetadata level. +func TestExecutionPlan_FederationRequires_NullableLists(t *testing.T) { + t.Parallel() + + // storageEntityLookupCall returns the entity lookup call shared by all tests below. + storageEntityLookupCall := func() RPCCall { + return RPCCall{ + ServiceName: "Products", + MethodName: "LookupStorageById", + Kind: CallKindEntity, + RequestedEntityType: "Storage", + Request: RPCMessage{ + Name: "LookupStorageByIdRequest", + Fields: []RPCField{ + { + Name: "keys", + ProtoTypeName: DataTypeMessage, + Repeated: true, + JSONPath: "representations", + Message: &RPCMessage{ + Name: "LookupStorageByIdRequestKey", + MemberTypes: []string{"Storage"}, + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + }, + }, + }, + }, + }, + }, + Response: RPCMessage{ + Name: "LookupStorageByIdResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + Repeated: true, + JSONPath: "_entities", + Message: &RPCMessage{ + Name: "Storage", + Fields: []RPCField{ + { + Name: "__typename", + ProtoTypeName: DataTypeString, + JSONPath: "__typename", + StaticValue: "Storage", + }, + }, + }, + }, + }, + }, + } + } + + // storageKeyField returns the entity key carried in every required fields context message. + storageKeyField := func() RPCField { + return RPCField{ + Name: "key", + ProtoTypeName: DataTypeMessage, + Message: &RPCMessage{ + Name: "LookupStorageByIdRequestKey", + MemberTypes: []string{"Storage"}, + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + }, + }, + }, + } + } + + // nullableListMetadata describes a single level nullable list. + nullableListMetadata := func() *ListMetadata { + return &ListMetadata{ + NestingLevel: 1, + LevelInfo: []LevelInfo{ + { + Optional: true, + }, + }, + } + } + + tests := []struct { + name string + query string + expectedPlan *RPCExecutionPlan + mapping *GRPCMapping + federationConfigs plan.FederationFieldConfigurations + }{ + { + name: "Should create an execution plan for a required field returning a nullable list of objects", + query: `query EntityLookup($representations: [_Any!]!) { _entities(representations: $representations) { ... on Storage { __typename optionalProcessedMetadataHistory { capacity zone priority } } } }`, + mapping: testMapping(), + federationConfigs: plan.FederationFieldConfigurations{ + { + TypeName: "Storage", + SelectionSet: "id", + }, + { + TypeName: "Storage", + FieldName: "optionalProcessedMetadataHistory", + SelectionSet: "metadataHistory { capacity zone }", + }, + }, + expectedPlan: &RPCExecutionPlan{ + Calls: []RPCCall{ + storageEntityLookupCall(), + { + ID: 1, + ServiceName: "Products", + Kind: CallKindRequired, + MethodName: "RequireStorageOptionalProcessedMetadataHistoryById", + ResponsePath: buildPath("_entities.optionalProcessedMetadataHistory"), + Request: RPCMessage{ + Name: "RequireStorageOptionalProcessedMetadataHistoryByIdRequest", + Fields: []RPCField{ + { + Name: "context", + ProtoTypeName: DataTypeMessage, + Repeated: true, + JSONPath: "representations", + Message: &RPCMessage{ + Name: "RequireStorageOptionalProcessedMetadataHistoryByIdContext", + Fields: []RPCField{ + storageKeyField(), + { + Name: "fields", + ProtoTypeName: DataTypeMessage, + Message: &RPCMessage{ + Name: "RequireStorageOptionalProcessedMetadataHistoryByIdFields", + Fields: []RPCField{ + { + Name: "metadata_history", + ProtoTypeName: DataTypeMessage, + Repeated: true, + JSONPath: "metadataHistory", + Message: &RPCMessage{ + Name: "RequireStorageOptionalProcessedMetadataHistoryByIdFields.StorageMetadata", + Fields: []RPCField{ + { + Name: "capacity", + ProtoTypeName: DataTypeInt32, + JSONPath: "capacity", + }, + { + Name: "zone", + ProtoTypeName: DataTypeString, + JSONPath: "zone", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + Response: RPCMessage{ + Name: "RequireStorageOptionalProcessedMetadataHistoryByIdResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + Repeated: true, + JSONPath: "result", + Message: &RPCMessage{ + Name: "RequireStorageOptionalProcessedMetadataHistoryByIdResult", + Fields: RPCFields{ + { + Name: "optional_processed_metadata_history", + ProtoTypeName: DataTypeMessage, + JSONPath: "optionalProcessedMetadataHistory", + Optional: true, + IsListType: true, + ListMetadata: nullableListMetadata(), + Message: &RPCMessage{ + Name: "StorageMetadata", + Fields: []RPCField{ + { + Name: "capacity", + ProtoTypeName: DataTypeInt32, + JSONPath: "capacity", + }, + { + Name: "zone", + ProtoTypeName: DataTypeString, + JSONPath: "zone", + }, + { + Name: "priority", + ProtoTypeName: DataTypeInt32, + JSONPath: "priority", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + { + name: "Should create an execution plan for a required field returning a nullable list of an interface", + query: `query EntityLookup($representations: [_Any!]!) { _entities(representations: $representations) { ... on Storage { __typename optionalRecommendedItems { __typename id name ... on PalletItem { palletCount } ... on ContainerItem { containerSize } } } } }`, + mapping: testMapping(), + federationConfigs: plan.FederationFieldConfigurations{ + { + TypeName: "Storage", + SelectionSet: "id", + }, + { + TypeName: "Storage", + FieldName: "optionalRecommendedItems", + SelectionSet: "tags", + }, + }, + expectedPlan: &RPCExecutionPlan{ + Calls: []RPCCall{ + storageEntityLookupCall(), + { + ID: 1, + ServiceName: "Products", + Kind: CallKindRequired, + MethodName: "RequireStorageOptionalRecommendedItemsById", + ResponsePath: buildPath("_entities.optionalRecommendedItems"), + Request: RPCMessage{ + Name: "RequireStorageOptionalRecommendedItemsByIdRequest", + Fields: []RPCField{ + { + Name: "context", + ProtoTypeName: DataTypeMessage, + Repeated: true, + JSONPath: "representations", + Message: &RPCMessage{ + Name: "RequireStorageOptionalRecommendedItemsByIdContext", + Fields: []RPCField{ + storageKeyField(), + { + Name: "fields", + ProtoTypeName: DataTypeMessage, + Message: &RPCMessage{ + Name: "RequireStorageOptionalRecommendedItemsByIdFields", + Fields: []RPCField{ + { + Name: "tags", + ProtoTypeName: DataTypeString, + Repeated: true, + JSONPath: "tags", + }, + }, + }, + }, + }, + }, + }, + }, + }, + Response: RPCMessage{ + Name: "RequireStorageOptionalRecommendedItemsByIdResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + Repeated: true, + JSONPath: "result", + Message: &RPCMessage{ + Name: "RequireStorageOptionalRecommendedItemsByIdResult", + Fields: RPCFields{ + { + Name: "optional_recommended_items", + ProtoTypeName: DataTypeMessage, + JSONPath: "optionalRecommendedItems", + Optional: true, + IsListType: true, + ListMetadata: nullableListMetadata(), + Message: &RPCMessage{ + Name: "StorageItem", + OneOfType: OneOfTypeInterface, + MemberTypes: []string{"PalletItem", "ContainerItem"}, + Fields: []RPCField{ + { + Name: "__typename", + ProtoTypeName: DataTypeString, + JSONPath: "__typename", + StaticValue: "StorageItem", + }, + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + }, + FragmentFields: map[string]RPCFields{ + "PalletItem": { + { + Name: "pallet_count", + ProtoTypeName: DataTypeInt32, + JSONPath: "palletCount", + }, + }, + "ContainerItem": { + { + Name: "container_size", + ProtoTypeName: DataTypeString, + JSONPath: "containerSize", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + { + name: "Should create an execution plan for a required field returning a nullable list of a union", + query: `query EntityLookup($representations: [_Any!]!) { _entities(representations: $representations) { ... on Storage { __typename optionalOperationHistory { __typename ... on StorageSuccess { message completedAt } ... on StorageFailure { message errorCode } } } } }`, + mapping: testMapping(), + federationConfigs: plan.FederationFieldConfigurations{ + { + TypeName: "Storage", + SelectionSet: "id", + }, + { + TypeName: "Storage", + FieldName: "optionalOperationHistory", + SelectionSet: "storageKind", + }, + }, + expectedPlan: &RPCExecutionPlan{ + Calls: []RPCCall{ + storageEntityLookupCall(), + { + ID: 1, + ServiceName: "Products", + Kind: CallKindRequired, + MethodName: "RequireStorageOptionalOperationHistoryById", + ResponsePath: buildPath("_entities.optionalOperationHistory"), + Request: RPCMessage{ + Name: "RequireStorageOptionalOperationHistoryByIdRequest", + Fields: []RPCField{ + { + Name: "context", + ProtoTypeName: DataTypeMessage, + Repeated: true, + JSONPath: "representations", + Message: &RPCMessage{ + Name: "RequireStorageOptionalOperationHistoryByIdContext", + Fields: []RPCField{ + storageKeyField(), + { + Name: "fields", + ProtoTypeName: DataTypeMessage, + Message: &RPCMessage{ + Name: "RequireStorageOptionalOperationHistoryByIdFields", + Fields: []RPCField{ + { + Name: "storage_kind", + ProtoTypeName: DataTypeEnum, + EnumName: "CategoryKind", + JSONPath: "storageKind", + }, + }, + }, + }, + }, + }, + }, + }, + }, + Response: RPCMessage{ + Name: "RequireStorageOptionalOperationHistoryByIdResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + Repeated: true, + JSONPath: "result", + Message: &RPCMessage{ + Name: "RequireStorageOptionalOperationHistoryByIdResult", + Fields: RPCFields{ + { + Name: "optional_operation_history", + ProtoTypeName: DataTypeMessage, + JSONPath: "optionalOperationHistory", + Optional: true, + IsListType: true, + ListMetadata: nullableListMetadata(), + Message: &RPCMessage{ + Name: "StorageOperationResult", + OneOfType: OneOfTypeUnion, + MemberTypes: []string{"StorageSuccess", "StorageFailure"}, + Fields: []RPCField{ + { + Name: "__typename", + ProtoTypeName: DataTypeString, + JSONPath: "__typename", + StaticValue: "StorageOperationResult", + }, + }, + FragmentFields: map[string]RPCFields{ + "StorageSuccess": { + { + Name: "message", + ProtoTypeName: DataTypeString, + JSONPath: "message", + }, + { + Name: "completed_at", + ProtoTypeName: DataTypeString, + JSONPath: "completedAt", + }, + }, + "StorageFailure": { + { + Name: "message", + ProtoTypeName: DataTypeString, + JSONPath: "message", + }, + { + Name: "error_code", + ProtoTypeName: DataTypeString, + JSONPath: "errorCode", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + { + name: "Should create an execution plan for a required field with a nullable list argument and a nullable list return type", + query: `query EntityLookup($representations: [_Any!]!, $lengths: [Int!]) { _entities(representations: $representations) { ... on Storage { __typename tagsByLengths(lengths: $lengths) } } }`, + mapping: testMapping(), + federationConfigs: plan.FederationFieldConfigurations{ + { + TypeName: "Storage", + SelectionSet: "id", + }, + { + TypeName: "Storage", + FieldName: "tagsByLengths", + SelectionSet: "tags", + }, + }, + expectedPlan: &RPCExecutionPlan{ + Calls: []RPCCall{ + storageEntityLookupCall(), + { + ID: 1, + ServiceName: "Products", + Kind: CallKindRequired, + MethodName: "RequireStorageTagsByLengthsById", + ResponsePath: buildPath("_entities.tagsByLengths"), + Request: RPCMessage{ + Name: "RequireStorageTagsByLengthsByIdRequest", + Fields: []RPCField{ + { + Name: "context", + ProtoTypeName: DataTypeMessage, + Repeated: true, + JSONPath: "representations", + Message: &RPCMessage{ + Name: "RequireStorageTagsByLengthsByIdContext", + Fields: []RPCField{ + storageKeyField(), + { + Name: "fields", + ProtoTypeName: DataTypeMessage, + Message: &RPCMessage{ + Name: "RequireStorageTagsByLengthsByIdFields", + Fields: []RPCField{ + { + Name: "tags", + ProtoTypeName: DataTypeString, + Repeated: true, + JSONPath: "tags", + }, + }, + }, + }, + }, + }, + }, + { + Name: "field_args", + ProtoTypeName: DataTypeMessage, + Message: &RPCMessage{ + Name: "RequireStorageTagsByLengthsByIdArgs", + Fields: []RPCField{ + { + Name: "lengths", + ProtoTypeName: DataTypeInt32, + JSONPath: "lengths", + Optional: true, + IsListType: true, + ListMetadata: nullableListMetadata(), + }, + }, + }, + }, + }, + }, + Response: RPCMessage{ + Name: "RequireStorageTagsByLengthsByIdResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + Repeated: true, + JSONPath: "result", + Message: &RPCMessage{ + Name: "RequireStorageTagsByLengthsByIdResult", + Fields: RPCFields{ + { + Name: "tags_by_lengths", + ProtoTypeName: DataTypeString, + JSONPath: "tagsByLengths", + Optional: true, + IsListType: true, + ListMetadata: nullableListMetadata(), + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + t.Parallel() + // Parse the GraphQL schema + schemaDoc := grpctest.MustGraphQLSchema(t) + + // Parse the GraphQL query + queryDoc, report := astparser.ParseGraphqlDocumentString(tt.query) + if report.HasErrors() { + t.Fatalf("failed to parse query: %s", report.Error()) + } + + planner, err := NewPlanner("Products", tt.mapping, tt.federationConfigs) + if err != nil { + t.Fatalf("failed to create planner: %s", err) + } + plan, err := planner.PlanOperation(&queryDoc, &schemaDoc) + if err != nil { + t.Fatalf("failed to plan operation: %s", err) + } + + diff := cmp.Diff(tt.expectedPlan, plan) + if diff != "" { + t.Fatalf("execution plan mismatch: %s", diff) + } + }) + } +} diff --git a/v2/pkg/engine/datasource/grpc_datasource/grpc_datasource_federation_test.go b/v2/pkg/engine/datasource/grpc_datasource/grpc_datasource_federation_test.go index 53f30e3057..96744eecbd 100644 --- a/v2/pkg/engine/datasource/grpc_datasource/grpc_datasource_federation_test.go +++ b/v2/pkg/engine/datasource/grpc_datasource/grpc_datasource_federation_test.go @@ -2596,3 +2596,401 @@ func Test_DataSource_Load_WithEntity_Calls_And_Requires_AbstractReturnTypes(t *t }) } } + +// Test_DataSource_Load_WithEntity_Calls_And_Requires_NullableLists exercises @requires fields whose +// return type, field argument, or required selection set is a nullable list. Nullable lists are +// carried in a generated ListOfX wrapper message, so these cases verify that the wrapper survives +// the round trip and that a null list stays distinguishable from an empty one. +func Test_DataSource_Load_WithEntity_Calls_And_Requires_NullableLists(t *testing.T) { + conn, cleanup := setupTestGRPCServer(t) + t.Cleanup(cleanup) + + type graphqlError struct { + Message string `json:"message"` + } + type graphqlResponse struct { + Data map[string]any `json:"data"` + Errors []graphqlError `json:"errors,omitempty"` + } + + testCases := []struct { + name string + query string + vars string + federationConfigs plan.FederationFieldConfigurations + validate func(t *testing.T, data map[string]any) + validateError func(t *testing.T, errData []graphqlError) + }{ + { + /* + optionalProcessedMetadataHistory: [StorageMetadata!] @requires(fields: "metadataHistory { capacity zone }") + + The result is wrapped in ListOfStorageMetadata. + */ + name: "Query Storage with optionalProcessedMetadataHistory returning a nullable list of objects", + query: `query($representations: [_Any!]!) { _entities(representations: $representations) { ...on Storage { id optionalProcessedMetadataHistory { capacity zone priority } } } }`, + vars: `{"variables":{"representations":[ + {"__typename":"Storage","id":"1","metadataHistory":[{"capacity":10,"zone":"A"},{"capacity":20,"zone":"B"}]}, + {"__typename":"Storage","id":"2","metadataHistory":[{"capacity":100,"zone":"X"}]}, + {"__typename":"Storage","id":"3","metadataHistory":[]} + ]}}`, + federationConfigs: plan.FederationFieldConfigurations{ + { + TypeName: "Storage", + SelectionSet: "id", + }, + { + TypeName: "Storage", + FieldName: "optionalProcessedMetadataHistory", + SelectionSet: "metadataHistory { capacity zone }", + }, + }, + validate: func(t *testing.T, data map[string]any) { + entities, ok := data["_entities"].([]any) + require.True(t, ok, "_entities should be an array") + require.Len(t, entities, 3, "Should return 3 entities") + + // Storage 1 (index 0, even, non-empty history): populated list + storage1, ok := entities[0].(map[string]any) + require.True(t, ok, "storage1 should be an object") + require.Equal(t, "1", storage1["id"]) + history1, ok := storage1["optionalProcessedMetadataHistory"].([]any) + require.True(t, ok, "optionalProcessedMetadataHistory should be an array") + require.Len(t, history1, 2) + entry1, ok := history1[0].(map[string]any) + require.True(t, ok, "history entry should be an object") + require.Equal(t, float64(10), entry1["capacity"]) + require.Equal(t, "OPT_HIST_A", entry1["zone"]) + require.Equal(t, float64(1), entry1["priority"]) + entry2, ok := history1[1].(map[string]any) + require.True(t, ok, "history entry should be an object") + require.Equal(t, float64(40), entry2["capacity"]) + require.Equal(t, "OPT_HIST_B", entry2["zone"]) + require.Equal(t, float64(2), entry2["priority"]) + + // Storage 2 (index 1, odd): empty but non-null list + storage2, ok := entities[1].(map[string]any) + require.True(t, ok, "storage2 should be an object") + require.Equal(t, "2", storage2["id"]) + history2, ok := storage2["optionalProcessedMetadataHistory"].([]any) + require.True(t, ok, "optionalProcessedMetadataHistory should be an empty array, not null") + require.Empty(t, history2) + + // Storage 3 (empty history): null list + storage3, ok := entities[2].(map[string]any) + require.True(t, ok, "storage3 should be an object") + require.Equal(t, "3", storage3["id"]) + require.Nil(t, storage3["optionalProcessedMetadataHistory"]) + }, + validateError: func(t *testing.T, errorData []graphqlError) { + require.Empty(t, errorData) + }, + }, + { + /* + optionalRecommendedItems: [StorageItem!] @requires(fields: "tags") + + The result is wrapped in ListOfStorageItem, the item type being an interface. + */ + name: "Query Storage with optionalRecommendedItems returning a nullable list of interfaces", + query: `query($representations: [_Any!]!) { _entities(representations: $representations) { ...on Storage { id optionalRecommendedItems { __typename id name ... on PalletItem { palletCount } ... on ContainerItem { containerSize } } } } }`, + vars: `{"variables":{"representations":[ + {"__typename":"Storage","id":"1","tags":["alpha","beta"]}, + {"__typename":"Storage","id":"2","tags":["gamma"]}, + {"__typename":"Storage","id":"3","tags":[]} + ]}}`, + federationConfigs: plan.FederationFieldConfigurations{ + { + TypeName: "Storage", + SelectionSet: "id", + }, + { + TypeName: "Storage", + FieldName: "optionalRecommendedItems", + SelectionSet: "tags", + }, + }, + validate: func(t *testing.T, data map[string]any) { + entities, ok := data["_entities"].([]any) + require.True(t, ok, "_entities should be an array") + require.Len(t, entities, 3, "Should return 3 entities") + + // Storage 1 (index 0, even, tags present): one item per tag, alternating concrete types + storage1, ok := entities[0].(map[string]any) + require.True(t, ok, "storage1 should be an object") + require.Equal(t, "1", storage1["id"]) + items1, ok := storage1["optionalRecommendedItems"].([]any) + require.True(t, ok, "optionalRecommendedItems should be an array") + require.Len(t, items1, 2) + + pallet, ok := items1[0].(map[string]any) + require.True(t, ok, "first item should be an object") + require.Equal(t, "PalletItem", pallet["__typename"]) + require.Equal(t, "opt-pallet-alpha", pallet["id"]) + require.Equal(t, "Optional pallet alpha", pallet["name"]) + require.Equal(t, float64(1), pallet["palletCount"]) + require.NotContains(t, pallet, "containerSize") + + container, ok := items1[1].(map[string]any) + require.True(t, ok, "second item should be an object") + require.Equal(t, "ContainerItem", container["__typename"]) + require.Equal(t, "opt-container-beta", container["id"]) + require.Equal(t, "Optional container beta", container["name"]) + require.Equal(t, "BETA", container["containerSize"]) + require.NotContains(t, container, "palletCount") + + // Storage 2 (index 1, odd): empty but non-null list + storage2, ok := entities[1].(map[string]any) + require.True(t, ok, "storage2 should be an object") + require.Equal(t, "2", storage2["id"]) + items2, ok := storage2["optionalRecommendedItems"].([]any) + require.True(t, ok, "optionalRecommendedItems should be an empty array, not null") + require.Empty(t, items2) + + // Storage 3 (no tags): null list + storage3, ok := entities[2].(map[string]any) + require.True(t, ok, "storage3 should be an object") + require.Equal(t, "3", storage3["id"]) + require.Nil(t, storage3["optionalRecommendedItems"]) + }, + validateError: func(t *testing.T, errorData []graphqlError) { + require.Empty(t, errorData) + }, + }, + { + /* + optionalOperationHistory: [StorageOperationResult!] @requires(fields: "storageKind") + + The result is wrapped in ListOfStorageOperationResult, the item type being a union. + */ + name: "Query Storage with optionalOperationHistory returning a nullable list of unions", + query: `query($representations: [_Any!]!) { _entities(representations: $representations) { ...on Storage { id optionalOperationHistory { __typename ... on StorageSuccess { message completedAt } ... on StorageFailure { message errorCode } } } } }`, + vars: `{"variables":{"representations":[ + {"__typename":"Storage","id":"1","storageKind":"BOOK"}, + {"__typename":"Storage","id":"2","storageKind":"FURNITURE"}, + {"__typename":"Storage","id":"3","storageKind":"OTHER"} + ]}}`, + federationConfigs: plan.FederationFieldConfigurations{ + { + TypeName: "Storage", + SelectionSet: "id", + }, + { + TypeName: "Storage", + FieldName: "optionalOperationHistory", + SelectionSet: "storageKind", + }, + }, + validate: func(t *testing.T, data map[string]any) { + entities, ok := data["_entities"].([]any) + require.True(t, ok, "_entities should be an array") + require.Len(t, entities, 3, "Should return 3 entities") + + // Storage 1 (BOOK): a success followed by a failure + storage1, ok := entities[0].(map[string]any) + require.True(t, ok, "storage1 should be an object") + require.Equal(t, "1", storage1["id"]) + history1, ok := storage1["optionalOperationHistory"].([]any) + require.True(t, ok, "optionalOperationHistory should be an array") + require.Len(t, history1, 2) + + success, ok := history1[0].(map[string]any) + require.True(t, ok, "first entry should be an object") + require.Equal(t, "StorageSuccess", success["__typename"]) + require.Equal(t, "History entry completed for CATEGORY_KIND_BOOK", success["message"]) + require.Equal(t, "2024-01-03T00:00:00Z", success["completedAt"]) + require.NotContains(t, success, "errorCode") + + failure, ok := history1[1].(map[string]any) + require.True(t, ok, "second entry should be an object") + require.Equal(t, "StorageFailure", failure["__typename"]) + require.Equal(t, "History entry failed for CATEGORY_KIND_BOOK", failure["message"]) + require.Equal(t, "HISTORIC_FAILURE", failure["errorCode"]) + require.NotContains(t, failure, "completedAt") + + // Storage 2 (FURNITURE): empty but non-null list + storage2, ok := entities[1].(map[string]any) + require.True(t, ok, "storage2 should be an object") + require.Equal(t, "2", storage2["id"]) + history2, ok := storage2["optionalOperationHistory"].([]any) + require.True(t, ok, "optionalOperationHistory should be an empty array, not null") + require.Empty(t, history2) + + // Storage 3 (OTHER): null list + storage3, ok := entities[2].(map[string]any) + require.True(t, ok, "storage3 should be an object") + require.Equal(t, "3", storage3["id"]) + require.Nil(t, storage3["optionalOperationHistory"]) + }, + validateError: func(t *testing.T, errorData []graphqlError) { + require.Empty(t, errorData) + }, + }, + { + /* + tagsByLengths(lengths: [Int!]): [String!] @requires(fields: "tags") + + Both the field argument and the result are wrapped (ListOfInt and ListOfString). + */ + name: "Query Storage with tagsByLengths passing a populated nullable list argument", + query: `query($representations: [_Any!]!, $lengths: [Int!]) { _entities(representations: $representations) { ...on Storage { id tagsByLengths(lengths: $lengths) } } }`, + vars: `{"variables":{ + "lengths": [4, 5], + "representations":[ + {"__typename":"Storage","id":"1","tags":["book","chair","electronics"]}, + {"__typename":"Storage","id":"2","tags":["electronics"]} + ] + }}`, + federationConfigs: plan.FederationFieldConfigurations{ + { + TypeName: "Storage", + SelectionSet: "id", + }, + { + TypeName: "Storage", + FieldName: "tagsByLengths", + SelectionSet: "tags", + }, + }, + validate: func(t *testing.T, data map[string]any) { + entities, ok := data["_entities"].([]any) + require.True(t, ok, "_entities should be an array") + require.Len(t, entities, 2, "Should return 2 entities") + + // Storage 1: "book" (4) and "chair" (5) match, "electronics" (11) does not + storage1, ok := entities[0].(map[string]any) + require.True(t, ok, "storage1 should be an object") + require.Equal(t, "1", storage1["id"]) + tags1, ok := storage1["tagsByLengths"].([]any) + require.True(t, ok, "tagsByLengths should be an array") + require.Equal(t, []any{"book", "chair"}, tags1) + + // Storage 2: nothing matches -> empty but non-null list + storage2, ok := entities[1].(map[string]any) + require.True(t, ok, "storage2 should be an object") + require.Equal(t, "2", storage2["id"]) + tags2, ok := storage2["tagsByLengths"].([]any) + require.True(t, ok, "tagsByLengths should be an empty array, not null") + require.Empty(t, tags2) + }, + validateError: func(t *testing.T, errorData []graphqlError) { + require.Empty(t, errorData) + }, + }, + { + name: "Query Storage with tagsByLengths passing an empty nullable list argument", + query: `query($representations: [_Any!]!, $lengths: [Int!]) { _entities(representations: $representations) { ...on Storage { id tagsByLengths(lengths: $lengths) } } }`, + vars: `{"variables":{ + "lengths": [], + "representations":[ + {"__typename":"Storage","id":"1","tags":["book","chair"]} + ] + }}`, + federationConfigs: plan.FederationFieldConfigurations{ + { + TypeName: "Storage", + SelectionSet: "id", + }, + { + TypeName: "Storage", + FieldName: "tagsByLengths", + SelectionSet: "tags", + }, + }, + validate: func(t *testing.T, data map[string]any) { + entities, ok := data["_entities"].([]any) + require.True(t, ok, "_entities should be an array") + require.Len(t, entities, 1, "Should return 1 entity") + + // An empty argument list is not a null one: the mock still returns a list. + storage1, ok := entities[0].(map[string]any) + require.True(t, ok, "storage1 should be an object") + require.Equal(t, "1", storage1["id"]) + tags1, ok := storage1["tagsByLengths"].([]any) + require.True(t, ok, "tagsByLengths should be an empty array, not null") + require.Empty(t, tags1) + }, + validateError: func(t *testing.T, errorData []graphqlError) { + require.Empty(t, errorData) + }, + }, + { + name: "Query Storage with tagsByLengths passing a null nullable list argument", + query: `query($representations: [_Any!]!, $lengths: [Int!]) { _entities(representations: $representations) { ...on Storage { id tagsByLengths(lengths: $lengths) } } }`, + vars: `{"variables":{ + "lengths": null, + "representations":[ + {"__typename":"Storage","id":"1","tags":["book","chair"]} + ] + }}`, + federationConfigs: plan.FederationFieldConfigurations{ + { + TypeName: "Storage", + SelectionSet: "id", + }, + { + TypeName: "Storage", + FieldName: "tagsByLengths", + SelectionSet: "tags", + }, + }, + validate: func(t *testing.T, data map[string]any) { + entities, ok := data["_entities"].([]any) + require.True(t, ok, "_entities should be an array") + require.Len(t, entities, 1, "Should return 1 entity") + + // A null argument list reaches the service as null, so the result is null too. + storage1, ok := entities[0].(map[string]any) + require.True(t, ok, "storage1 should be an object") + require.Equal(t, "1", storage1["id"]) + require.Nil(t, storage1["tagsByLengths"]) + }, + validateError: func(t *testing.T, errorData []graphqlError) { + require.Empty(t, errorData) + }, + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + // Parse the GraphQL schema + schemaDoc := grpctest.MustGraphQLSchema(t) + + // Parse the GraphQL query + queryDoc, report := astparser.ParseGraphqlDocumentString(tc.query) + if report.HasErrors() { + t.Fatalf("failed to parse query: %s", report.Error()) + } + + compiler, err := NewProtoCompiler(grpctest.MustProtoSchema(t), testMapping()) + if err != nil { + t.Fatalf("failed to compile proto: %v", err) + } + + // Create the datasource + ds, err := NewDataSource(NewGRPCTransport(conn), DataSourceConfig{ + Operation: &queryDoc, + Definition: &schemaDoc, + SubgraphName: "Products", + Mapping: testMapping(), + Compiler: compiler, + FederationConfigs: tc.federationConfigs, + }) + require.NoError(t, err) + + // Execute the query through our datasource + input := fmt.Sprintf(`{"query":%q,"body":%s}`, tc.query, tc.vars) + data, err := ds.Load(context.Background(), nil, []byte(input)) + require.NoError(t, err) + + // Parse the response + var resp graphqlResponse + + err = json.Unmarshal(data, &resp) + require.NoError(t, err, "Failed to unmarshal response") + + tc.validate(t, resp.Data) + tc.validateError(t, resp.Errors) + }) + } +} diff --git a/v2/pkg/engine/datasource/grpc_datasource/mapping_test_helper.go b/v2/pkg/engine/datasource/grpc_datasource/mapping_test_helper.go index 392cb724c7..45b6c90d8f 100644 --- a/v2/pkg/engine/datasource/grpc_datasource/mapping_test_helper.go +++ b/v2/pkg/engine/datasource/grpc_datasource/mapping_test_helper.go @@ -610,6 +610,22 @@ func testMapping() *GRPCMapping { Response: "RequireStorageProcessedMetadataHistoryByIdResponse", }, }, + "optionalProcessedMetadataHistory": { + TargetName: "optional_processed_metadata_history", + RPCConfig: RPCConfig{ + RPC: "RequireStorageOptionalProcessedMetadataHistoryById", + Request: "RequireStorageOptionalProcessedMetadataHistoryByIdRequest", + Response: "RequireStorageOptionalProcessedMetadataHistoryByIdResponse", + }, + }, + "tagsByLengths": { + TargetName: "tags_by_lengths", + RPCConfig: RPCConfig{ + RPC: "RequireStorageTagsByLengthsById", + Request: "RequireStorageTagsByLengthsByIdRequest", + Response: "RequireStorageTagsByLengthsByIdResponse", + }, + }, "kindSummary": { TargetName: "kind_summary", RPCConfig: RPCConfig{ @@ -706,6 +722,22 @@ func testMapping() *GRPCMapping { Response: "RequireStorageOptionalLatestOperationByIdResponse", }, }, + "optionalRecommendedItems": { + TargetName: "optional_recommended_items", + RPCConfig: RPCConfig{ + RPC: "RequireStorageOptionalRecommendedItemsById", + Request: "RequireStorageOptionalRecommendedItemsByIdRequest", + Response: "RequireStorageOptionalRecommendedItemsByIdResponse", + }, + }, + "optionalOperationHistory": { + TargetName: "optional_operation_history", + RPCConfig: RPCConfig{ + RPC: "RequireStorageOptionalOperationHistoryById", + Request: "RequireStorageOptionalOperationHistoryByIdRequest", + Response: "RequireStorageOptionalOperationHistoryByIdResponse", + }, + }, "filteredTagSummary": { TargetName: "filtered_tag_summary", RPCConfig: RPCConfig{ @@ -1120,6 +1152,15 @@ func testMapping() *GRPCMapping { "processedMetadataHistory": { TargetName: "processed_metadata_history", }, + "optionalProcessedMetadataHistory": { + TargetName: "optional_processed_metadata_history", + }, + "tagsByLengths": { + TargetName: "tags_by_lengths", + ArgumentMappings: FieldArgumentMap{ + "lengths": "lengths", + }, + }, "storageKind": { TargetName: "storage_kind", }, @@ -1171,6 +1212,12 @@ func testMapping() *GRPCMapping { "optionalLatestOperation": { TargetName: "optional_latest_operation", }, + "optionalRecommendedItems": { + TargetName: "optional_recommended_items", + }, + "optionalOperationHistory": { + TargetName: "optional_operation_history", + }, "storageStatus": { TargetName: "storage_status", ArgumentMappings: FieldArgumentMap{ diff --git a/v2/pkg/grpctest/mapping/mapping.go b/v2/pkg/grpctest/mapping/mapping.go index 27e28114d7..4c91d948f8 100644 --- a/v2/pkg/grpctest/mapping/mapping.go +++ b/v2/pkg/grpctest/mapping/mapping.go @@ -616,6 +616,22 @@ func DefaultGRPCMapping() *grpcdatasource.GRPCMapping { Response: "RequireStorageProcessedMetadataHistoryByIdResponse", }, }, + "optionalProcessedMetadataHistory": { + TargetName: "optional_processed_metadata_history", + RPCConfig: grpcdatasource.RPCConfig{ + RPC: "RequireStorageOptionalProcessedMetadataHistoryById", + Request: "RequireStorageOptionalProcessedMetadataHistoryByIdRequest", + Response: "RequireStorageOptionalProcessedMetadataHistoryByIdResponse", + }, + }, + "tagsByLengths": { + TargetName: "tags_by_lengths", + RPCConfig: grpcdatasource.RPCConfig{ + RPC: "RequireStorageTagsByLengthsById", + Request: "RequireStorageTagsByLengthsByIdRequest", + Response: "RequireStorageTagsByLengthsByIdResponse", + }, + }, "kindSummary": { TargetName: "kind_summary", RPCConfig: grpcdatasource.RPCConfig{ @@ -712,6 +728,22 @@ func DefaultGRPCMapping() *grpcdatasource.GRPCMapping { Response: "RequireStorageOptionalLatestOperationByIdResponse", }, }, + "optionalRecommendedItems": { + TargetName: "optional_recommended_items", + RPCConfig: grpcdatasource.RPCConfig{ + RPC: "RequireStorageOptionalRecommendedItemsById", + Request: "RequireStorageOptionalRecommendedItemsByIdRequest", + Response: "RequireStorageOptionalRecommendedItemsByIdResponse", + }, + }, + "optionalOperationHistory": { + TargetName: "optional_operation_history", + RPCConfig: grpcdatasource.RPCConfig{ + RPC: "RequireStorageOptionalOperationHistoryById", + Request: "RequireStorageOptionalOperationHistoryByIdRequest", + Response: "RequireStorageOptionalOperationHistoryByIdResponse", + }, + }, "filteredTagSummary": { TargetName: "filtered_tag_summary", RPCConfig: grpcdatasource.RPCConfig{ @@ -1126,6 +1158,15 @@ func DefaultGRPCMapping() *grpcdatasource.GRPCMapping { "processedMetadataHistory": { TargetName: "processed_metadata_history", }, + "optionalProcessedMetadataHistory": { + TargetName: "optional_processed_metadata_history", + }, + "tagsByLengths": { + TargetName: "tags_by_lengths", + ArgumentMappings: grpcdatasource.FieldArgumentMap{ + "lengths": "lengths", + }, + }, "storageKind": { TargetName: "storage_kind", }, @@ -1177,6 +1218,12 @@ func DefaultGRPCMapping() *grpcdatasource.GRPCMapping { "optionalLatestOperation": { TargetName: "optional_latest_operation", }, + "optionalRecommendedItems": { + TargetName: "optional_recommended_items", + }, + "optionalOperationHistory": { + TargetName: "optional_operation_history", + }, "storageStatus": { TargetName: "storage_status", ArgumentMappings: grpcdatasource.FieldArgumentMap{ diff --git a/v2/pkg/grpctest/mockservice_connect.go b/v2/pkg/grpctest/mockservice_connect.go index 1f861e9d31..5f207809ea 100644 --- a/v2/pkg/grpctest/mockservice_connect.go +++ b/v2/pkg/grpctest/mockservice_connect.go @@ -592,6 +592,15 @@ func (s *MockServiceConnect) RequireStorageOperationReportById(ctx context.Conte return connect.NewResponse(resp), nil } +// RequireStorageOptionalOperationHistoryById forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) RequireStorageOptionalOperationHistoryById(ctx context.Context, req *connect.Request[productv1.RequireStorageOptionalOperationHistoryByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalOperationHistoryByIdResponse], error) { + resp, err := s.inner.RequireStorageOptionalOperationHistoryById(connectCtxToGRPC(ctx, req.Header()), req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + // RequireStorageOptionalProcessedMetadataById forwards the Connect call to the gRPC implementation. func (s *MockServiceConnect) RequireStorageOptionalProcessedMetadataById(ctx context.Context, req *connect.Request[productv1.RequireStorageOptionalProcessedMetadataByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalProcessedMetadataByIdResponse], error) { resp, err := s.inner.RequireStorageOptionalProcessedMetadataById(connectCtxToGRPC(ctx, req.Header()), req.Msg) @@ -601,6 +610,15 @@ func (s *MockServiceConnect) RequireStorageOptionalProcessedMetadataById(ctx con return connect.NewResponse(resp), nil } +// RequireStorageOptionalProcessedMetadataHistoryById forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) RequireStorageOptionalProcessedMetadataHistoryById(ctx context.Context, req *connect.Request[productv1.RequireStorageOptionalProcessedMetadataHistoryByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalProcessedMetadataHistoryByIdResponse], error) { + resp, err := s.inner.RequireStorageOptionalProcessedMetadataHistoryById(connectCtxToGRPC(ctx, req.Header()), req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + // RequireStorageOptionalProcessedTagsById forwards the Connect call to the gRPC implementation. func (s *MockServiceConnect) RequireStorageOptionalProcessedTagsById(ctx context.Context, req *connect.Request[productv1.RequireStorageOptionalProcessedTagsByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalProcessedTagsByIdResponse], error) { resp, err := s.inner.RequireStorageOptionalProcessedTagsById(connectCtxToGRPC(ctx, req.Header()), req.Msg) @@ -610,6 +628,15 @@ func (s *MockServiceConnect) RequireStorageOptionalProcessedTagsById(ctx context return connect.NewResponse(resp), nil } +// RequireStorageOptionalRecommendedItemsById forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) RequireStorageOptionalRecommendedItemsById(ctx context.Context, req *connect.Request[productv1.RequireStorageOptionalRecommendedItemsByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalRecommendedItemsByIdResponse], error) { + resp, err := s.inner.RequireStorageOptionalRecommendedItemsById(connectCtxToGRPC(ctx, req.Header()), req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + // RequireStorageOptionalTagSummaryById forwards the Connect call to the gRPC implementation. func (s *MockServiceConnect) RequireStorageOptionalTagSummaryById(ctx context.Context, req *connect.Request[productv1.RequireStorageOptionalTagSummaryByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalTagSummaryByIdResponse], error) { resp, err := s.inner.RequireStorageOptionalTagSummaryById(connectCtxToGRPC(ctx, req.Header()), req.Msg) @@ -673,6 +700,15 @@ func (s *MockServiceConnect) RequireStorageTagSummaryById(ctx context.Context, r return connect.NewResponse(resp), nil } +// RequireStorageTagsByLengthsById forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) RequireStorageTagsByLengthsById(ctx context.Context, req *connect.Request[productv1.RequireStorageTagsByLengthsByIdRequest]) (*connect.Response[productv1.RequireStorageTagsByLengthsByIdResponse], error) { + resp, err := s.inner.RequireStorageTagsByLengthsById(connectCtxToGRPC(ctx, req.Header()), req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + // RequireWarehouseStockHealthScoreById forwards the Connect call to the gRPC implementation. func (s *MockServiceConnect) RequireWarehouseStockHealthScoreById(ctx context.Context, req *connect.Request[productv1.RequireWarehouseStockHealthScoreByIdRequest]) (*connect.Response[productv1.RequireWarehouseStockHealthScoreByIdResponse], error) { resp, err := s.inner.RequireWarehouseStockHealthScoreById(connectCtxToGRPC(ctx, req.Header()), req.Msg) diff --git a/v2/pkg/grpctest/mockservice_requires.go b/v2/pkg/grpctest/mockservice_requires.go index 9f57abdd01..d4980126eb 100644 --- a/v2/pkg/grpctest/mockservice_requires.go +++ b/v2/pkg/grpctest/mockservice_requires.go @@ -3,6 +3,7 @@ package grpctest import ( "context" "fmt" + "slices" "strings" "google.golang.org/protobuf/types/known/wrapperspb" @@ -792,3 +793,182 @@ func (s *MockService) RequireStorageFilteredTagSummaryById(_ context.Context, re return &productv1.RequireStorageFilteredTagSummaryByIdResponse{Result: results}, nil } + +// RequireStorageOptionalProcessedMetadataHistoryById implements [productv1.ProductServiceServer]. +// Returns a nullable list of complex types (StorageMetadata) wrapped in a ListOfStorageMetadata +// message, so a null list can be distinguished from an empty one: +// - no metadata history in the context -> null list +// - odd context index -> empty (but non-null) list +// - otherwise -> processed history +func (s *MockService) RequireStorageOptionalProcessedMetadataHistoryById(_ context.Context, req *productv1.RequireStorageOptionalProcessedMetadataHistoryByIdRequest) (*productv1.RequireStorageOptionalProcessedMetadataHistoryByIdResponse, error) { + results := make([]*productv1.RequireStorageOptionalProcessedMetadataHistoryByIdResult, 0, len(req.GetContext())) + + for i, ctx := range req.GetContext() { + metadataHistory := ctx.GetFields().GetMetadataHistory() + + var processedHistory *productv1.ListOfStorageMetadata + switch { + case len(metadataHistory) == 0: + // null list + case i%2 == 1: + processedHistory = &productv1.ListOfStorageMetadata{ + List: &productv1.ListOfStorageMetadata_List{}, + } + default: + items := make([]*productv1.StorageMetadata, 0, len(metadataHistory)) + for j, metadata := range metadataHistory { + items = append(items, &productv1.StorageMetadata{ + Capacity: metadata.GetCapacity() * int32(j+1), + Zone: "OPT_HIST_" + metadata.GetZone(), + Priority: int32(j + 1), + }) + } + processedHistory = &productv1.ListOfStorageMetadata{ + List: &productv1.ListOfStorageMetadata_List{Items: items}, + } + } + + results = append(results, &productv1.RequireStorageOptionalProcessedMetadataHistoryByIdResult{ + OptionalProcessedMetadataHistory: processedHistory, + }) + } + + return &productv1.RequireStorageOptionalProcessedMetadataHistoryByIdResponse{Result: results}, nil +} + +// RequireStorageOptionalRecommendedItemsById implements [productv1.ProductServiceServer]. +// Returns a nullable list of interfaces (StorageItem) wrapped in a ListOfStorageItem message: +// - no tags in the context -> null list +// - odd context index -> empty (but non-null) list +// - otherwise -> one item per tag, alternating between both concrete types +func (s *MockService) RequireStorageOptionalRecommendedItemsById(_ context.Context, req *productv1.RequireStorageOptionalRecommendedItemsByIdRequest) (*productv1.RequireStorageOptionalRecommendedItemsByIdResponse, error) { + results := make([]*productv1.RequireStorageOptionalRecommendedItemsByIdResult, 0, len(req.GetContext())) + + for i, ctx := range req.GetContext() { + tags := ctx.GetFields().GetTags() + + var recommendedItems *productv1.ListOfStorageItem + switch { + case len(tags) == 0: + // null list + case i%2 == 1: + recommendedItems = &productv1.ListOfStorageItem{ + List: &productv1.ListOfStorageItem_List{}, + } + default: + items := make([]*productv1.StorageItem, 0, len(tags)) + for j, tag := range tags { + if j%2 == 0 { + items = append(items, newHandledPalletStorageItem( + fmt.Sprintf("opt-pallet-%s", tag), + fmt.Sprintf("Optional pallet %s", tag), + int32(j+1), + )) + } else { + items = append(items, newHandledContainerStorageItem( + fmt.Sprintf("opt-container-%s", tag), + fmt.Sprintf("Optional container %s", tag), + strings.ToUpper(tag), + )) + } + } + recommendedItems = &productv1.ListOfStorageItem{ + List: &productv1.ListOfStorageItem_List{Items: items}, + } + } + + results = append(results, &productv1.RequireStorageOptionalRecommendedItemsByIdResult{ + OptionalRecommendedItems: recommendedItems, + }) + } + + return &productv1.RequireStorageOptionalRecommendedItemsByIdResponse{Result: results}, nil +} + +// RequireStorageOptionalOperationHistoryById implements [productv1.ProductServiceServer]. +// Returns a nullable list of unions (StorageOperationResult) wrapped in a +// ListOfStorageOperationResult message, derived from the required storageKind enum: +// - BOOK / ELECTRONICS -> a success followed by a failure +// - FURNITURE -> empty (but non-null) list +// - OTHER / unspecified -> null list +func (s *MockService) RequireStorageOptionalOperationHistoryById(_ context.Context, req *productv1.RequireStorageOptionalOperationHistoryByIdRequest) (*productv1.RequireStorageOptionalOperationHistoryByIdResponse, error) { + results := make([]*productv1.RequireStorageOptionalOperationHistoryByIdResult, 0, len(req.GetContext())) + + for _, ctx := range req.GetContext() { + kind := ctx.GetFields().GetStorageKind() + + var operationHistory *productv1.ListOfStorageOperationResult + switch kind { + case productv1.CategoryKind_CATEGORY_KIND_BOOK, + productv1.CategoryKind_CATEGORY_KIND_ELECTRONICS: + operationHistory = &productv1.ListOfStorageOperationResult{ + List: &productv1.ListOfStorageOperationResult_List{ + Items: []*productv1.StorageOperationResult{ + { + Value: &productv1.StorageOperationResult_StorageSuccess{ + StorageSuccess: &productv1.StorageSuccess{ + Message: fmt.Sprintf("History entry completed for %s", kind.String()), + CompletedAt: "2024-01-03T00:00:00Z", + }, + }, + }, + { + Value: &productv1.StorageOperationResult_StorageFailure{ + StorageFailure: &productv1.StorageFailure{ + Message: fmt.Sprintf("History entry failed for %s", kind.String()), + ErrorCode: "HISTORIC_FAILURE", + }, + }, + }, + }, + }, + } + case productv1.CategoryKind_CATEGORY_KIND_FURNITURE: + operationHistory = &productv1.ListOfStorageOperationResult{ + List: &productv1.ListOfStorageOperationResult_List{}, + } + default: + // OTHER and unspecified produce a null list. + } + + results = append(results, &productv1.RequireStorageOptionalOperationHistoryByIdResult{ + OptionalOperationHistory: operationHistory, + }) + } + + return &productv1.RequireStorageOptionalOperationHistoryByIdResponse{Result: results}, nil +} + +// RequireStorageTagsByLengthsById implements [productv1.ProductServiceServer]. +// Both the nullable list field argument and the nullable list return type are carried in +// ListOfX wrappers: +// - the lengths argument is null -> null list +// - the lengths argument is empty -> empty (but non-null) list +// - otherwise -> the tags whose length matches one of the given lengths +func (s *MockService) RequireStorageTagsByLengthsById(_ context.Context, req *productv1.RequireStorageTagsByLengthsByIdRequest) (*productv1.RequireStorageTagsByLengthsByIdResponse, error) { + lengths := req.GetFieldArgs().GetLengths() + results := make([]*productv1.RequireStorageTagsByLengthsByIdResult, 0, len(req.GetContext())) + + for _, ctx := range req.GetContext() { + tags := ctx.GetFields().GetTags() + + var tagsByLengths *productv1.ListOfString + if lengths.GetList() != nil { + matched := make([]string, 0, len(tags)) + for _, tag := range tags { + if slices.Contains(lengths.GetList().GetItems(), int32(len(tag))) { + matched = append(matched, tag) + } + } + tagsByLengths = &productv1.ListOfString{ + List: &productv1.ListOfString_List{Items: matched}, + } + } + + results = append(results, &productv1.RequireStorageTagsByLengthsByIdResult{ + TagsByLengths: tagsByLengths, + }) + } + + return &productv1.RequireStorageTagsByLengthsByIdResponse{Result: results}, nil +} diff --git a/v2/pkg/grpctest/product.proto b/v2/pkg/grpctest/product.proto index 19be1f4d51..9618340a88 100644 --- a/v2/pkg/grpctest/product.proto +++ b/v2/pkg/grpctest/product.proto @@ -72,8 +72,11 @@ service ProductService { rpc RequireStorageNullableFilteredTagSummaryById(RequireStorageNullableFilteredTagSummaryByIdRequest) returns (RequireStorageNullableFilteredTagSummaryByIdResponse) {} rpc RequireStorageOperationReportById(RequireStorageOperationReportByIdRequest) returns (RequireStorageOperationReportByIdResponse) {} rpc RequireStorageOptionalLatestOperationById(RequireStorageOptionalLatestOperationByIdRequest) returns (RequireStorageOptionalLatestOperationByIdResponse) {} + rpc RequireStorageOptionalOperationHistoryById(RequireStorageOptionalOperationHistoryByIdRequest) returns (RequireStorageOptionalOperationHistoryByIdResponse) {} rpc RequireStorageOptionalProcessedMetadataById(RequireStorageOptionalProcessedMetadataByIdRequest) returns (RequireStorageOptionalProcessedMetadataByIdResponse) {} + rpc RequireStorageOptionalProcessedMetadataHistoryById(RequireStorageOptionalProcessedMetadataHistoryByIdRequest) returns (RequireStorageOptionalProcessedMetadataHistoryByIdResponse) {} rpc RequireStorageOptionalProcessedTagsById(RequireStorageOptionalProcessedTagsByIdRequest) returns (RequireStorageOptionalProcessedTagsByIdResponse) {} + rpc RequireStorageOptionalRecommendedItemsById(RequireStorageOptionalRecommendedItemsByIdRequest) returns (RequireStorageOptionalRecommendedItemsByIdResponse) {} rpc RequireStorageOptionalTagSummaryById(RequireStorageOptionalTagSummaryByIdRequest) returns (RequireStorageOptionalTagSummaryByIdResponse) {} rpc RequireStorageProcessedMetadataById(RequireStorageProcessedMetadataByIdRequest) returns (RequireStorageProcessedMetadataByIdResponse) {} rpc RequireStorageProcessedMetadataHistoryById(RequireStorageProcessedMetadataHistoryByIdRequest) returns (RequireStorageProcessedMetadataHistoryByIdResponse) {} @@ -83,6 +86,7 @@ service ProductService { rpc RequireStorageSecuritySummaryById(RequireStorageSecuritySummaryByIdRequest) returns (RequireStorageSecuritySummaryByIdResponse) {} rpc RequireStorageStockHealthScoreById(RequireStorageStockHealthScoreByIdRequest) returns (RequireStorageStockHealthScoreByIdResponse) {} rpc RequireStorageTagSummaryById(RequireStorageTagSummaryByIdRequest) returns (RequireStorageTagSummaryByIdResponse) {} + rpc RequireStorageTagsByLengthsById(RequireStorageTagsByLengthsByIdRequest) returns (RequireStorageTagsByLengthsByIdResponse) {} rpc RequireWarehouseStockHealthScoreById(RequireWarehouseStockHealthScoreByIdRequest) returns (RequireWarehouseStockHealthScoreByIdResponse) {} rpc ResolveCategoryActiveSubcategories(ResolveCategoryActiveSubcategoriesRequest) returns (ResolveCategoryActiveSubcategoriesResponse) {} rpc ResolveCategoryCategoryMetrics(ResolveCategoryCategoryMetricsRequest) returns (ResolveCategoryCategoryMetricsResponse) {} @@ -181,6 +185,12 @@ message ListOfFloat { } List list = 1; } +message ListOfInt { + message List { + repeated int32 items = 1; + } + List list = 1; +} // Wrapper message for a list of Category. message ListOfListOfCategory { message List { @@ -237,7 +247,24 @@ message ListOfStorage { } List list = 1; } -// Wrapper message for a list of String. +message ListOfStorageItem { + message List { + repeated StorageItem items = 1; + } + List list = 1; +} +message ListOfStorageMetadata { + message List { + repeated StorageMetadata items = 1; + } + List list = 1; +} +message ListOfStorageOperationResult { + message List { + repeated StorageOperationResult items = 1; + } + List list = 1; +} message ListOfString { message List { repeated string items = 1; @@ -1526,6 +1553,63 @@ message RequireStorageProcessedMetadataHistoryByIdFields { repeated StorageMetadata metadata_history = 1; } +message RequireStorageOptionalProcessedMetadataHistoryByIdRequest { + // RequireStorageOptionalProcessedMetadataHistoryByIdContext provides the context for the required fields method RequireStorageOptionalProcessedMetadataHistoryById. + repeated RequireStorageOptionalProcessedMetadataHistoryByIdContext context = 1; +} + +message RequireStorageOptionalProcessedMetadataHistoryByIdContext { + LookupStorageByIdRequestKey key = 1; + RequireStorageOptionalProcessedMetadataHistoryByIdFields fields = 2; +} + +message RequireStorageOptionalProcessedMetadataHistoryByIdResponse { + // RequireStorageOptionalProcessedMetadataHistoryByIdResult provides the result for the required fields method RequireStorageOptionalProcessedMetadataHistoryById. + repeated RequireStorageOptionalProcessedMetadataHistoryByIdResult result = 1; +} + +message RequireStorageOptionalProcessedMetadataHistoryByIdResult { + ListOfStorageMetadata optional_processed_metadata_history = 1; +} + +message RequireStorageOptionalProcessedMetadataHistoryByIdFields { + message StorageMetadata { + int32 capacity = 1; + string zone = 2; + } + + repeated StorageMetadata metadata_history = 1; +} + +message RequireStorageTagsByLengthsByIdRequest { + // RequireStorageTagsByLengthsByIdContext provides the context for the required fields method RequireStorageTagsByLengthsById. + repeated RequireStorageTagsByLengthsByIdContext context = 1; + // RequireStorageTagsByLengthsByIdArgs provides the field arguments for the required field with method RequireStorageTagsByLengthsById. + RequireStorageTagsByLengthsByIdArgs field_args = 2; +} + +message RequireStorageTagsByLengthsByIdContext { + LookupStorageByIdRequestKey key = 1; + RequireStorageTagsByLengthsByIdFields fields = 2; +} + +message RequireStorageTagsByLengthsByIdArgs { + ListOfInt lengths = 1; +} + +message RequireStorageTagsByLengthsByIdResponse { + // RequireStorageTagsByLengthsByIdResult provides the result for the required fields method RequireStorageTagsByLengthsById. + repeated RequireStorageTagsByLengthsByIdResult result = 1; +} + +message RequireStorageTagsByLengthsByIdResult { + ListOfString tags_by_lengths = 1; +} + +message RequireStorageTagsByLengthsByIdFields { + repeated string tags = 1; +} + message RequireStorageKindSummaryByIdRequest { // RequireStorageKindSummaryByIdContext provides the context for the required fields method RequireStorageKindSummaryById. repeated RequireStorageKindSummaryByIdContext context = 1; @@ -1959,6 +2043,52 @@ message RequireStorageOptionalLatestOperationByIdFields { ListOfString optional_tags = 1; } +message RequireStorageOptionalRecommendedItemsByIdRequest { + // RequireStorageOptionalRecommendedItemsByIdContext provides the context for the required fields method RequireStorageOptionalRecommendedItemsById. + repeated RequireStorageOptionalRecommendedItemsByIdContext context = 1; +} + +message RequireStorageOptionalRecommendedItemsByIdContext { + LookupStorageByIdRequestKey key = 1; + RequireStorageOptionalRecommendedItemsByIdFields fields = 2; +} + +message RequireStorageOptionalRecommendedItemsByIdResponse { + // RequireStorageOptionalRecommendedItemsByIdResult provides the result for the required fields method RequireStorageOptionalRecommendedItemsById. + repeated RequireStorageOptionalRecommendedItemsByIdResult result = 1; +} + +message RequireStorageOptionalRecommendedItemsByIdResult { + ListOfStorageItem optional_recommended_items = 1; +} + +message RequireStorageOptionalRecommendedItemsByIdFields { + repeated string tags = 1; +} + +message RequireStorageOptionalOperationHistoryByIdRequest { + // RequireStorageOptionalOperationHistoryByIdContext provides the context for the required fields method RequireStorageOptionalOperationHistoryById. + repeated RequireStorageOptionalOperationHistoryByIdContext context = 1; +} + +message RequireStorageOptionalOperationHistoryByIdContext { + LookupStorageByIdRequestKey key = 1; + RequireStorageOptionalOperationHistoryByIdFields fields = 2; +} + +message RequireStorageOptionalOperationHistoryByIdResponse { + // RequireStorageOptionalOperationHistoryByIdResult provides the result for the required fields method RequireStorageOptionalOperationHistoryById. + repeated RequireStorageOptionalOperationHistoryByIdResult result = 1; +} + +message RequireStorageOptionalOperationHistoryByIdResult { + ListOfStorageOperationResult optional_operation_history = 1; +} + +message RequireStorageOptionalOperationHistoryByIdFields { + CategoryKind storage_kind = 1; +} + message RequireStorageFilteredTagSummaryByIdRequest { // RequireStorageFilteredTagSummaryByIdContext provides the context for the required fields method RequireStorageFilteredTagSummaryById. repeated RequireStorageFilteredTagSummaryByIdContext context = 1; diff --git a/v2/pkg/grpctest/productv1/product.pb.go b/v2/pkg/grpctest/productv1/product.pb.go index 64746d38bc..99a4225f51 100644 --- a/v2/pkg/grpctest/productv1/product.pb.go +++ b/v2/pkg/grpctest/productv1/product.pb.go @@ -579,6 +579,50 @@ func (x *ListOfFloat) GetList() *ListOfFloat_List { return nil } +type ListOfInt struct { + state protoimpl.MessageState `protogen:"open.v1"` + List *ListOfInt_List `protobuf:"bytes,1,opt,name=list,proto3" json:"list,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListOfInt) Reset() { + *x = ListOfInt{} + mi := &file_product_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListOfInt) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListOfInt) ProtoMessage() {} + +func (x *ListOfInt) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[10] + 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 ListOfInt.ProtoReflect.Descriptor instead. +func (*ListOfInt) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{10} +} + +func (x *ListOfInt) GetList() *ListOfInt_List { + if x != nil { + return x.List + } + return nil +} + // Wrapper message for a list of Category. type ListOfListOfCategory struct { state protoimpl.MessageState `protogen:"open.v1"` @@ -589,7 +633,7 @@ type ListOfListOfCategory struct { func (x *ListOfListOfCategory) Reset() { *x = ListOfListOfCategory{} - mi := &file_product_proto_msgTypes[10] + mi := &file_product_proto_msgTypes[11] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -601,7 +645,7 @@ func (x *ListOfListOfCategory) String() string { func (*ListOfListOfCategory) ProtoMessage() {} func (x *ListOfListOfCategory) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[10] + mi := &file_product_proto_msgTypes[11] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -614,7 +658,7 @@ func (x *ListOfListOfCategory) ProtoReflect() protoreflect.Message { // Deprecated: Use ListOfListOfCategory.ProtoReflect.Descriptor instead. func (*ListOfListOfCategory) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{10} + return file_product_proto_rawDescGZIP(), []int{11} } func (x *ListOfListOfCategory) GetList() *ListOfListOfCategory_List { @@ -634,7 +678,7 @@ type ListOfListOfCategoryInput struct { func (x *ListOfListOfCategoryInput) Reset() { *x = ListOfListOfCategoryInput{} - mi := &file_product_proto_msgTypes[11] + mi := &file_product_proto_msgTypes[12] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -646,7 +690,7 @@ func (x *ListOfListOfCategoryInput) String() string { func (*ListOfListOfCategoryInput) ProtoMessage() {} func (x *ListOfListOfCategoryInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[11] + mi := &file_product_proto_msgTypes[12] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -659,7 +703,7 @@ func (x *ListOfListOfCategoryInput) ProtoReflect() protoreflect.Message { // Deprecated: Use ListOfListOfCategoryInput.ProtoReflect.Descriptor instead. func (*ListOfListOfCategoryInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{11} + return file_product_proto_rawDescGZIP(), []int{12} } func (x *ListOfListOfCategoryInput) GetList() *ListOfListOfCategoryInput_List { @@ -679,7 +723,7 @@ type ListOfListOfString struct { func (x *ListOfListOfString) Reset() { *x = ListOfListOfString{} - mi := &file_product_proto_msgTypes[12] + mi := &file_product_proto_msgTypes[13] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -691,7 +735,7 @@ func (x *ListOfListOfString) String() string { func (*ListOfListOfString) ProtoMessage() {} func (x *ListOfListOfString) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[12] + mi := &file_product_proto_msgTypes[13] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -704,7 +748,7 @@ func (x *ListOfListOfString) ProtoReflect() protoreflect.Message { // Deprecated: Use ListOfListOfString.ProtoReflect.Descriptor instead. func (*ListOfListOfString) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{12} + return file_product_proto_rawDescGZIP(), []int{13} } func (x *ListOfListOfString) GetList() *ListOfListOfString_List { @@ -724,7 +768,7 @@ type ListOfListOfUser struct { func (x *ListOfListOfUser) Reset() { *x = ListOfListOfUser{} - mi := &file_product_proto_msgTypes[13] + mi := &file_product_proto_msgTypes[14] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -736,7 +780,7 @@ func (x *ListOfListOfUser) String() string { func (*ListOfListOfUser) ProtoMessage() {} func (x *ListOfListOfUser) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[13] + mi := &file_product_proto_msgTypes[14] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -749,7 +793,7 @@ func (x *ListOfListOfUser) ProtoReflect() protoreflect.Message { // Deprecated: Use ListOfListOfUser.ProtoReflect.Descriptor instead. func (*ListOfListOfUser) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{13} + return file_product_proto_rawDescGZIP(), []int{14} } func (x *ListOfListOfUser) GetList() *ListOfListOfUser_List { @@ -769,7 +813,7 @@ type ListOfListOfUserInput struct { func (x *ListOfListOfUserInput) Reset() { *x = ListOfListOfUserInput{} - mi := &file_product_proto_msgTypes[14] + mi := &file_product_proto_msgTypes[15] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -781,7 +825,7 @@ func (x *ListOfListOfUserInput) String() string { func (*ListOfListOfUserInput) ProtoMessage() {} func (x *ListOfListOfUserInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[14] + mi := &file_product_proto_msgTypes[15] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -794,7 +838,7 @@ func (x *ListOfListOfUserInput) ProtoReflect() protoreflect.Message { // Deprecated: Use ListOfListOfUserInput.ProtoReflect.Descriptor instead. func (*ListOfListOfUserInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{14} + return file_product_proto_rawDescGZIP(), []int{15} } func (x *ListOfListOfUserInput) GetList() *ListOfListOfUserInput_List { @@ -814,7 +858,7 @@ type ListOfOrderLine struct { func (x *ListOfOrderLine) Reset() { *x = ListOfOrderLine{} - mi := &file_product_proto_msgTypes[15] + mi := &file_product_proto_msgTypes[16] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -826,7 +870,7 @@ func (x *ListOfOrderLine) String() string { func (*ListOfOrderLine) ProtoMessage() {} func (x *ListOfOrderLine) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[15] + mi := &file_product_proto_msgTypes[16] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -839,7 +883,7 @@ func (x *ListOfOrderLine) ProtoReflect() protoreflect.Message { // Deprecated: Use ListOfOrderLine.ProtoReflect.Descriptor instead. func (*ListOfOrderLine) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{15} + return file_product_proto_rawDescGZIP(), []int{16} } func (x *ListOfOrderLine) GetList() *ListOfOrderLine_List { @@ -859,7 +903,7 @@ type ListOfProduct struct { func (x *ListOfProduct) Reset() { *x = ListOfProduct{} - mi := &file_product_proto_msgTypes[16] + mi := &file_product_proto_msgTypes[17] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -871,7 +915,7 @@ func (x *ListOfProduct) String() string { func (*ListOfProduct) ProtoMessage() {} func (x *ListOfProduct) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[16] + mi := &file_product_proto_msgTypes[17] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -884,7 +928,7 @@ func (x *ListOfProduct) ProtoReflect() protoreflect.Message { // Deprecated: Use ListOfProduct.ProtoReflect.Descriptor instead. func (*ListOfProduct) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{16} + return file_product_proto_rawDescGZIP(), []int{17} } func (x *ListOfProduct) GetList() *ListOfProduct_List { @@ -904,7 +948,7 @@ type ListOfStorage struct { func (x *ListOfStorage) Reset() { *x = ListOfStorage{} - mi := &file_product_proto_msgTypes[17] + mi := &file_product_proto_msgTypes[18] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -916,7 +960,7 @@ func (x *ListOfStorage) String() string { func (*ListOfStorage) ProtoMessage() {} func (x *ListOfStorage) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[17] + mi := &file_product_proto_msgTypes[18] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -929,7 +973,7 @@ func (x *ListOfStorage) ProtoReflect() protoreflect.Message { // Deprecated: Use ListOfStorage.ProtoReflect.Descriptor instead. func (*ListOfStorage) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{17} + return file_product_proto_rawDescGZIP(), []int{18} } func (x *ListOfStorage) GetList() *ListOfStorage_List { @@ -939,7 +983,138 @@ func (x *ListOfStorage) GetList() *ListOfStorage_List { return nil } -// Wrapper message for a list of String. +type ListOfStorageItem struct { + state protoimpl.MessageState `protogen:"open.v1"` + List *ListOfStorageItem_List `protobuf:"bytes,1,opt,name=list,proto3" json:"list,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListOfStorageItem) Reset() { + *x = ListOfStorageItem{} + mi := &file_product_proto_msgTypes[19] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListOfStorageItem) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListOfStorageItem) ProtoMessage() {} + +func (x *ListOfStorageItem) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[19] + 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 ListOfStorageItem.ProtoReflect.Descriptor instead. +func (*ListOfStorageItem) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{19} +} + +func (x *ListOfStorageItem) GetList() *ListOfStorageItem_List { + if x != nil { + return x.List + } + return nil +} + +type ListOfStorageMetadata struct { + state protoimpl.MessageState `protogen:"open.v1"` + List *ListOfStorageMetadata_List `protobuf:"bytes,1,opt,name=list,proto3" json:"list,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListOfStorageMetadata) Reset() { + *x = ListOfStorageMetadata{} + mi := &file_product_proto_msgTypes[20] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListOfStorageMetadata) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListOfStorageMetadata) ProtoMessage() {} + +func (x *ListOfStorageMetadata) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[20] + 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 ListOfStorageMetadata.ProtoReflect.Descriptor instead. +func (*ListOfStorageMetadata) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{20} +} + +func (x *ListOfStorageMetadata) GetList() *ListOfStorageMetadata_List { + if x != nil { + return x.List + } + return nil +} + +type ListOfStorageOperationResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + List *ListOfStorageOperationResult_List `protobuf:"bytes,1,opt,name=list,proto3" json:"list,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListOfStorageOperationResult) Reset() { + *x = ListOfStorageOperationResult{} + mi := &file_product_proto_msgTypes[21] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListOfStorageOperationResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListOfStorageOperationResult) ProtoMessage() {} + +func (x *ListOfStorageOperationResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[21] + 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 ListOfStorageOperationResult.ProtoReflect.Descriptor instead. +func (*ListOfStorageOperationResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{21} +} + +func (x *ListOfStorageOperationResult) GetList() *ListOfStorageOperationResult_List { + if x != nil { + return x.List + } + return nil +} + type ListOfString struct { state protoimpl.MessageState `protogen:"open.v1"` List *ListOfString_List `protobuf:"bytes,1,opt,name=list,proto3" json:"list,omitempty"` @@ -949,7 +1124,7 @@ type ListOfString struct { func (x *ListOfString) Reset() { *x = ListOfString{} - mi := &file_product_proto_msgTypes[18] + mi := &file_product_proto_msgTypes[22] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -961,7 +1136,7 @@ func (x *ListOfString) String() string { func (*ListOfString) ProtoMessage() {} func (x *ListOfString) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[18] + mi := &file_product_proto_msgTypes[22] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -974,7 +1149,7 @@ func (x *ListOfString) ProtoReflect() protoreflect.Message { // Deprecated: Use ListOfString.ProtoReflect.Descriptor instead. func (*ListOfString) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{18} + return file_product_proto_rawDescGZIP(), []int{22} } func (x *ListOfString) GetList() *ListOfString_List { @@ -994,7 +1169,7 @@ type ListOfSubcategory struct { func (x *ListOfSubcategory) Reset() { *x = ListOfSubcategory{} - mi := &file_product_proto_msgTypes[19] + mi := &file_product_proto_msgTypes[23] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1006,7 +1181,7 @@ func (x *ListOfSubcategory) String() string { func (*ListOfSubcategory) ProtoMessage() {} func (x *ListOfSubcategory) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[19] + mi := &file_product_proto_msgTypes[23] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1019,7 +1194,7 @@ func (x *ListOfSubcategory) ProtoReflect() protoreflect.Message { // Deprecated: Use ListOfSubcategory.ProtoReflect.Descriptor instead. func (*ListOfSubcategory) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{19} + return file_product_proto_rawDescGZIP(), []int{23} } func (x *ListOfSubcategory) GetList() *ListOfSubcategory_List { @@ -1039,7 +1214,7 @@ type ListOfUser struct { func (x *ListOfUser) Reset() { *x = ListOfUser{} - mi := &file_product_proto_msgTypes[20] + mi := &file_product_proto_msgTypes[24] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1051,7 +1226,7 @@ func (x *ListOfUser) String() string { func (*ListOfUser) ProtoMessage() {} func (x *ListOfUser) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[20] + mi := &file_product_proto_msgTypes[24] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1064,7 +1239,7 @@ func (x *ListOfUser) ProtoReflect() protoreflect.Message { // Deprecated: Use ListOfUser.ProtoReflect.Descriptor instead. func (*ListOfUser) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{20} + return file_product_proto_rawDescGZIP(), []int{24} } func (x *ListOfUser) GetList() *ListOfUser_List { @@ -1084,7 +1259,7 @@ type ListOfUserInput struct { func (x *ListOfUserInput) Reset() { *x = ListOfUserInput{} - mi := &file_product_proto_msgTypes[21] + mi := &file_product_proto_msgTypes[25] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1096,7 +1271,7 @@ func (x *ListOfUserInput) String() string { func (*ListOfUserInput) ProtoMessage() {} func (x *ListOfUserInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[21] + mi := &file_product_proto_msgTypes[25] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1109,7 +1284,7 @@ func (x *ListOfUserInput) ProtoReflect() protoreflect.Message { // Deprecated: Use ListOfUserInput.ProtoReflect.Descriptor instead. func (*ListOfUserInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{21} + return file_product_proto_rawDescGZIP(), []int{25} } func (x *ListOfUserInput) GetList() *ListOfUserInput_List { @@ -1130,7 +1305,7 @@ type LookupProductByIdRequestKey struct { func (x *LookupProductByIdRequestKey) Reset() { *x = LookupProductByIdRequestKey{} - mi := &file_product_proto_msgTypes[22] + mi := &file_product_proto_msgTypes[26] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1142,7 +1317,7 @@ func (x *LookupProductByIdRequestKey) String() string { func (*LookupProductByIdRequestKey) ProtoMessage() {} func (x *LookupProductByIdRequestKey) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[22] + mi := &file_product_proto_msgTypes[26] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1155,7 +1330,7 @@ func (x *LookupProductByIdRequestKey) ProtoReflect() protoreflect.Message { // Deprecated: Use LookupProductByIdRequestKey.ProtoReflect.Descriptor instead. func (*LookupProductByIdRequestKey) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{22} + return file_product_proto_rawDescGZIP(), []int{26} } func (x *LookupProductByIdRequestKey) GetId() string { @@ -1177,7 +1352,7 @@ type LookupProductByIdRequest struct { func (x *LookupProductByIdRequest) Reset() { *x = LookupProductByIdRequest{} - mi := &file_product_proto_msgTypes[23] + mi := &file_product_proto_msgTypes[27] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1189,7 +1364,7 @@ func (x *LookupProductByIdRequest) String() string { func (*LookupProductByIdRequest) ProtoMessage() {} func (x *LookupProductByIdRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[23] + mi := &file_product_proto_msgTypes[27] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1202,7 +1377,7 @@ func (x *LookupProductByIdRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use LookupProductByIdRequest.ProtoReflect.Descriptor instead. func (*LookupProductByIdRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{23} + return file_product_proto_rawDescGZIP(), []int{27} } func (x *LookupProductByIdRequest) GetKeys() []*LookupProductByIdRequestKey { @@ -1235,7 +1410,7 @@ type LookupProductByIdResponse struct { func (x *LookupProductByIdResponse) Reset() { *x = LookupProductByIdResponse{} - mi := &file_product_proto_msgTypes[24] + mi := &file_product_proto_msgTypes[28] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1247,7 +1422,7 @@ func (x *LookupProductByIdResponse) String() string { func (*LookupProductByIdResponse) ProtoMessage() {} func (x *LookupProductByIdResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[24] + mi := &file_product_proto_msgTypes[28] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1260,7 +1435,7 @@ func (x *LookupProductByIdResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use LookupProductByIdResponse.ProtoReflect.Descriptor instead. func (*LookupProductByIdResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{24} + return file_product_proto_rawDescGZIP(), []int{28} } func (x *LookupProductByIdResponse) GetResult() []*Product { @@ -1281,7 +1456,7 @@ type LookupStorageByIdRequestKey struct { func (x *LookupStorageByIdRequestKey) Reset() { *x = LookupStorageByIdRequestKey{} - mi := &file_product_proto_msgTypes[25] + mi := &file_product_proto_msgTypes[29] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1293,7 +1468,7 @@ func (x *LookupStorageByIdRequestKey) String() string { func (*LookupStorageByIdRequestKey) ProtoMessage() {} func (x *LookupStorageByIdRequestKey) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[25] + mi := &file_product_proto_msgTypes[29] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1306,7 +1481,7 @@ func (x *LookupStorageByIdRequestKey) ProtoReflect() protoreflect.Message { // Deprecated: Use LookupStorageByIdRequestKey.ProtoReflect.Descriptor instead. func (*LookupStorageByIdRequestKey) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{25} + return file_product_proto_rawDescGZIP(), []int{29} } func (x *LookupStorageByIdRequestKey) GetId() string { @@ -1328,7 +1503,7 @@ type LookupStorageByIdRequest struct { func (x *LookupStorageByIdRequest) Reset() { *x = LookupStorageByIdRequest{} - mi := &file_product_proto_msgTypes[26] + mi := &file_product_proto_msgTypes[30] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1340,7 +1515,7 @@ func (x *LookupStorageByIdRequest) String() string { func (*LookupStorageByIdRequest) ProtoMessage() {} func (x *LookupStorageByIdRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[26] + mi := &file_product_proto_msgTypes[30] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1353,7 +1528,7 @@ func (x *LookupStorageByIdRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use LookupStorageByIdRequest.ProtoReflect.Descriptor instead. func (*LookupStorageByIdRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{26} + return file_product_proto_rawDescGZIP(), []int{30} } func (x *LookupStorageByIdRequest) GetKeys() []*LookupStorageByIdRequestKey { @@ -1386,7 +1561,7 @@ type LookupStorageByIdResponse struct { func (x *LookupStorageByIdResponse) Reset() { *x = LookupStorageByIdResponse{} - mi := &file_product_proto_msgTypes[27] + mi := &file_product_proto_msgTypes[31] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1398,7 +1573,7 @@ func (x *LookupStorageByIdResponse) String() string { func (*LookupStorageByIdResponse) ProtoMessage() {} func (x *LookupStorageByIdResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[27] + mi := &file_product_proto_msgTypes[31] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1411,7 +1586,7 @@ func (x *LookupStorageByIdResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use LookupStorageByIdResponse.ProtoReflect.Descriptor instead. func (*LookupStorageByIdResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{27} + return file_product_proto_rawDescGZIP(), []int{31} } func (x *LookupStorageByIdResponse) GetResult() []*Storage { @@ -1432,7 +1607,7 @@ type LookupWarehouseByIdRequestKey struct { func (x *LookupWarehouseByIdRequestKey) Reset() { *x = LookupWarehouseByIdRequestKey{} - mi := &file_product_proto_msgTypes[28] + mi := &file_product_proto_msgTypes[32] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1444,7 +1619,7 @@ func (x *LookupWarehouseByIdRequestKey) String() string { func (*LookupWarehouseByIdRequestKey) ProtoMessage() {} func (x *LookupWarehouseByIdRequestKey) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[28] + mi := &file_product_proto_msgTypes[32] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1457,7 +1632,7 @@ func (x *LookupWarehouseByIdRequestKey) ProtoReflect() protoreflect.Message { // Deprecated: Use LookupWarehouseByIdRequestKey.ProtoReflect.Descriptor instead. func (*LookupWarehouseByIdRequestKey) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{28} + return file_product_proto_rawDescGZIP(), []int{32} } func (x *LookupWarehouseByIdRequestKey) GetId() string { @@ -1479,7 +1654,7 @@ type LookupWarehouseByIdRequest struct { func (x *LookupWarehouseByIdRequest) Reset() { *x = LookupWarehouseByIdRequest{} - mi := &file_product_proto_msgTypes[29] + mi := &file_product_proto_msgTypes[33] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1491,7 +1666,7 @@ func (x *LookupWarehouseByIdRequest) String() string { func (*LookupWarehouseByIdRequest) ProtoMessage() {} func (x *LookupWarehouseByIdRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[29] + mi := &file_product_proto_msgTypes[33] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1504,7 +1679,7 @@ func (x *LookupWarehouseByIdRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use LookupWarehouseByIdRequest.ProtoReflect.Descriptor instead. func (*LookupWarehouseByIdRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{29} + return file_product_proto_rawDescGZIP(), []int{33} } func (x *LookupWarehouseByIdRequest) GetKeys() []*LookupWarehouseByIdRequestKey { @@ -1537,7 +1712,7 @@ type LookupWarehouseByIdResponse struct { func (x *LookupWarehouseByIdResponse) Reset() { *x = LookupWarehouseByIdResponse{} - mi := &file_product_proto_msgTypes[30] + mi := &file_product_proto_msgTypes[34] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1549,7 +1724,7 @@ func (x *LookupWarehouseByIdResponse) String() string { func (*LookupWarehouseByIdResponse) ProtoMessage() {} func (x *LookupWarehouseByIdResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[30] + mi := &file_product_proto_msgTypes[34] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1562,7 +1737,7 @@ func (x *LookupWarehouseByIdResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use LookupWarehouseByIdResponse.ProtoReflect.Descriptor instead. func (*LookupWarehouseByIdResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{30} + return file_product_proto_rawDescGZIP(), []int{34} } func (x *LookupWarehouseByIdResponse) GetResult() []*Warehouse { @@ -1581,7 +1756,7 @@ type QueryUsersRequest struct { func (x *QueryUsersRequest) Reset() { *x = QueryUsersRequest{} - mi := &file_product_proto_msgTypes[31] + mi := &file_product_proto_msgTypes[35] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1593,7 +1768,7 @@ func (x *QueryUsersRequest) String() string { func (*QueryUsersRequest) ProtoMessage() {} func (x *QueryUsersRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[31] + mi := &file_product_proto_msgTypes[35] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1606,7 +1781,7 @@ func (x *QueryUsersRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryUsersRequest.ProtoReflect.Descriptor instead. func (*QueryUsersRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{31} + return file_product_proto_rawDescGZIP(), []int{35} } // Response message for users operation. @@ -1619,7 +1794,7 @@ type QueryUsersResponse struct { func (x *QueryUsersResponse) Reset() { *x = QueryUsersResponse{} - mi := &file_product_proto_msgTypes[32] + mi := &file_product_proto_msgTypes[36] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1631,7 +1806,7 @@ func (x *QueryUsersResponse) String() string { func (*QueryUsersResponse) ProtoMessage() {} func (x *QueryUsersResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[32] + mi := &file_product_proto_msgTypes[36] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1644,7 +1819,7 @@ func (x *QueryUsersResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryUsersResponse.ProtoReflect.Descriptor instead. func (*QueryUsersResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{32} + return file_product_proto_rawDescGZIP(), []int{36} } func (x *QueryUsersResponse) GetUsers() []*User { @@ -1664,7 +1839,7 @@ type QueryUserRequest struct { func (x *QueryUserRequest) Reset() { *x = QueryUserRequest{} - mi := &file_product_proto_msgTypes[33] + mi := &file_product_proto_msgTypes[37] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1676,7 +1851,7 @@ func (x *QueryUserRequest) String() string { func (*QueryUserRequest) ProtoMessage() {} func (x *QueryUserRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[33] + mi := &file_product_proto_msgTypes[37] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1689,7 +1864,7 @@ func (x *QueryUserRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryUserRequest.ProtoReflect.Descriptor instead. func (*QueryUserRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{33} + return file_product_proto_rawDescGZIP(), []int{37} } func (x *QueryUserRequest) GetId() string { @@ -1709,7 +1884,7 @@ type QueryUserResponse struct { func (x *QueryUserResponse) Reset() { *x = QueryUserResponse{} - mi := &file_product_proto_msgTypes[34] + mi := &file_product_proto_msgTypes[38] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1721,7 +1896,7 @@ func (x *QueryUserResponse) String() string { func (*QueryUserResponse) ProtoMessage() {} func (x *QueryUserResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[34] + mi := &file_product_proto_msgTypes[38] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1734,7 +1909,7 @@ func (x *QueryUserResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryUserResponse.ProtoReflect.Descriptor instead. func (*QueryUserResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{34} + return file_product_proto_rawDescGZIP(), []int{38} } func (x *QueryUserResponse) GetUser() *User { @@ -1753,7 +1928,7 @@ type QueryNestedTypeRequest struct { func (x *QueryNestedTypeRequest) Reset() { *x = QueryNestedTypeRequest{} - mi := &file_product_proto_msgTypes[35] + mi := &file_product_proto_msgTypes[39] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1765,7 +1940,7 @@ func (x *QueryNestedTypeRequest) String() string { func (*QueryNestedTypeRequest) ProtoMessage() {} func (x *QueryNestedTypeRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[35] + mi := &file_product_proto_msgTypes[39] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1778,7 +1953,7 @@ func (x *QueryNestedTypeRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryNestedTypeRequest.ProtoReflect.Descriptor instead. func (*QueryNestedTypeRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{35} + return file_product_proto_rawDescGZIP(), []int{39} } // Response message for nestedType operation. @@ -1791,7 +1966,7 @@ type QueryNestedTypeResponse struct { func (x *QueryNestedTypeResponse) Reset() { *x = QueryNestedTypeResponse{} - mi := &file_product_proto_msgTypes[36] + mi := &file_product_proto_msgTypes[40] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1803,7 +1978,7 @@ func (x *QueryNestedTypeResponse) String() string { func (*QueryNestedTypeResponse) ProtoMessage() {} func (x *QueryNestedTypeResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[36] + mi := &file_product_proto_msgTypes[40] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1816,7 +1991,7 @@ func (x *QueryNestedTypeResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryNestedTypeResponse.ProtoReflect.Descriptor instead. func (*QueryNestedTypeResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{36} + return file_product_proto_rawDescGZIP(), []int{40} } func (x *QueryNestedTypeResponse) GetNestedType() []*NestedTypeA { @@ -1835,7 +2010,7 @@ type QueryRecursiveTypeRequest struct { func (x *QueryRecursiveTypeRequest) Reset() { *x = QueryRecursiveTypeRequest{} - mi := &file_product_proto_msgTypes[37] + mi := &file_product_proto_msgTypes[41] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1847,7 +2022,7 @@ func (x *QueryRecursiveTypeRequest) String() string { func (*QueryRecursiveTypeRequest) ProtoMessage() {} func (x *QueryRecursiveTypeRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[37] + mi := &file_product_proto_msgTypes[41] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1860,7 +2035,7 @@ func (x *QueryRecursiveTypeRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryRecursiveTypeRequest.ProtoReflect.Descriptor instead. func (*QueryRecursiveTypeRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{37} + return file_product_proto_rawDescGZIP(), []int{41} } // Response message for recursiveType operation. @@ -1873,7 +2048,7 @@ type QueryRecursiveTypeResponse struct { func (x *QueryRecursiveTypeResponse) Reset() { *x = QueryRecursiveTypeResponse{} - mi := &file_product_proto_msgTypes[38] + mi := &file_product_proto_msgTypes[42] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1885,7 +2060,7 @@ func (x *QueryRecursiveTypeResponse) String() string { func (*QueryRecursiveTypeResponse) ProtoMessage() {} func (x *QueryRecursiveTypeResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[38] + mi := &file_product_proto_msgTypes[42] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1898,7 +2073,7 @@ func (x *QueryRecursiveTypeResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryRecursiveTypeResponse.ProtoReflect.Descriptor instead. func (*QueryRecursiveTypeResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{38} + return file_product_proto_rawDescGZIP(), []int{42} } func (x *QueryRecursiveTypeResponse) GetRecursiveType() *RecursiveType { @@ -1919,7 +2094,7 @@ type QueryTypeFilterWithArgumentsRequest struct { func (x *QueryTypeFilterWithArgumentsRequest) Reset() { *x = QueryTypeFilterWithArgumentsRequest{} - mi := &file_product_proto_msgTypes[39] + mi := &file_product_proto_msgTypes[43] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1931,7 +2106,7 @@ func (x *QueryTypeFilterWithArgumentsRequest) String() string { func (*QueryTypeFilterWithArgumentsRequest) ProtoMessage() {} func (x *QueryTypeFilterWithArgumentsRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[39] + mi := &file_product_proto_msgTypes[43] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1944,7 +2119,7 @@ func (x *QueryTypeFilterWithArgumentsRequest) ProtoReflect() protoreflect.Messag // Deprecated: Use QueryTypeFilterWithArgumentsRequest.ProtoReflect.Descriptor instead. func (*QueryTypeFilterWithArgumentsRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{39} + return file_product_proto_rawDescGZIP(), []int{43} } func (x *QueryTypeFilterWithArgumentsRequest) GetFilterField_1() string { @@ -1971,7 +2146,7 @@ type QueryTypeFilterWithArgumentsResponse struct { func (x *QueryTypeFilterWithArgumentsResponse) Reset() { *x = QueryTypeFilterWithArgumentsResponse{} - mi := &file_product_proto_msgTypes[40] + mi := &file_product_proto_msgTypes[44] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1983,7 +2158,7 @@ func (x *QueryTypeFilterWithArgumentsResponse) String() string { func (*QueryTypeFilterWithArgumentsResponse) ProtoMessage() {} func (x *QueryTypeFilterWithArgumentsResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[40] + mi := &file_product_proto_msgTypes[44] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1996,7 +2171,7 @@ func (x *QueryTypeFilterWithArgumentsResponse) ProtoReflect() protoreflect.Messa // Deprecated: Use QueryTypeFilterWithArgumentsResponse.ProtoReflect.Descriptor instead. func (*QueryTypeFilterWithArgumentsResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{40} + return file_product_proto_rawDescGZIP(), []int{44} } func (x *QueryTypeFilterWithArgumentsResponse) GetTypeFilterWithArguments() []*TypeWithMultipleFilterFields { @@ -2016,7 +2191,7 @@ type QueryTypeWithMultipleFilterFieldsRequest struct { func (x *QueryTypeWithMultipleFilterFieldsRequest) Reset() { *x = QueryTypeWithMultipleFilterFieldsRequest{} - mi := &file_product_proto_msgTypes[41] + mi := &file_product_proto_msgTypes[45] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2028,7 +2203,7 @@ func (x *QueryTypeWithMultipleFilterFieldsRequest) String() string { func (*QueryTypeWithMultipleFilterFieldsRequest) ProtoMessage() {} func (x *QueryTypeWithMultipleFilterFieldsRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[41] + mi := &file_product_proto_msgTypes[45] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2041,7 +2216,7 @@ func (x *QueryTypeWithMultipleFilterFieldsRequest) ProtoReflect() protoreflect.M // Deprecated: Use QueryTypeWithMultipleFilterFieldsRequest.ProtoReflect.Descriptor instead. func (*QueryTypeWithMultipleFilterFieldsRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{41} + return file_product_proto_rawDescGZIP(), []int{45} } func (x *QueryTypeWithMultipleFilterFieldsRequest) GetFilter() *FilterTypeInput { @@ -2061,7 +2236,7 @@ type QueryTypeWithMultipleFilterFieldsResponse struct { func (x *QueryTypeWithMultipleFilterFieldsResponse) Reset() { *x = QueryTypeWithMultipleFilterFieldsResponse{} - mi := &file_product_proto_msgTypes[42] + mi := &file_product_proto_msgTypes[46] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2073,7 +2248,7 @@ func (x *QueryTypeWithMultipleFilterFieldsResponse) String() string { func (*QueryTypeWithMultipleFilterFieldsResponse) ProtoMessage() {} func (x *QueryTypeWithMultipleFilterFieldsResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[42] + mi := &file_product_proto_msgTypes[46] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2086,7 +2261,7 @@ func (x *QueryTypeWithMultipleFilterFieldsResponse) ProtoReflect() protoreflect. // Deprecated: Use QueryTypeWithMultipleFilterFieldsResponse.ProtoReflect.Descriptor instead. func (*QueryTypeWithMultipleFilterFieldsResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{42} + return file_product_proto_rawDescGZIP(), []int{46} } func (x *QueryTypeWithMultipleFilterFieldsResponse) GetTypeWithMultipleFilterFields() []*TypeWithMultipleFilterFields { @@ -2106,7 +2281,7 @@ type QueryComplexFilterTypeRequest struct { func (x *QueryComplexFilterTypeRequest) Reset() { *x = QueryComplexFilterTypeRequest{} - mi := &file_product_proto_msgTypes[43] + mi := &file_product_proto_msgTypes[47] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2118,7 +2293,7 @@ func (x *QueryComplexFilterTypeRequest) String() string { func (*QueryComplexFilterTypeRequest) ProtoMessage() {} func (x *QueryComplexFilterTypeRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[43] + mi := &file_product_proto_msgTypes[47] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2131,7 +2306,7 @@ func (x *QueryComplexFilterTypeRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryComplexFilterTypeRequest.ProtoReflect.Descriptor instead. func (*QueryComplexFilterTypeRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{43} + return file_product_proto_rawDescGZIP(), []int{47} } func (x *QueryComplexFilterTypeRequest) GetFilter() *ComplexFilterTypeInput { @@ -2151,7 +2326,7 @@ type QueryComplexFilterTypeResponse struct { func (x *QueryComplexFilterTypeResponse) Reset() { *x = QueryComplexFilterTypeResponse{} - mi := &file_product_proto_msgTypes[44] + mi := &file_product_proto_msgTypes[48] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2163,7 +2338,7 @@ func (x *QueryComplexFilterTypeResponse) String() string { func (*QueryComplexFilterTypeResponse) ProtoMessage() {} func (x *QueryComplexFilterTypeResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[44] + mi := &file_product_proto_msgTypes[48] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2176,7 +2351,7 @@ func (x *QueryComplexFilterTypeResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryComplexFilterTypeResponse.ProtoReflect.Descriptor instead. func (*QueryComplexFilterTypeResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{44} + return file_product_proto_rawDescGZIP(), []int{48} } func (x *QueryComplexFilterTypeResponse) GetComplexFilterType() []*TypeWithComplexFilterInput { @@ -2196,7 +2371,7 @@ type QueryCalculateTotalsRequest struct { func (x *QueryCalculateTotalsRequest) Reset() { *x = QueryCalculateTotalsRequest{} - mi := &file_product_proto_msgTypes[45] + mi := &file_product_proto_msgTypes[49] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2208,7 +2383,7 @@ func (x *QueryCalculateTotalsRequest) String() string { func (*QueryCalculateTotalsRequest) ProtoMessage() {} func (x *QueryCalculateTotalsRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[45] + mi := &file_product_proto_msgTypes[49] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2221,7 +2396,7 @@ func (x *QueryCalculateTotalsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryCalculateTotalsRequest.ProtoReflect.Descriptor instead. func (*QueryCalculateTotalsRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{45} + return file_product_proto_rawDescGZIP(), []int{49} } func (x *QueryCalculateTotalsRequest) GetOrders() []*OrderInput { @@ -2241,7 +2416,7 @@ type QueryCalculateTotalsResponse struct { func (x *QueryCalculateTotalsResponse) Reset() { *x = QueryCalculateTotalsResponse{} - mi := &file_product_proto_msgTypes[46] + mi := &file_product_proto_msgTypes[50] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2253,7 +2428,7 @@ func (x *QueryCalculateTotalsResponse) String() string { func (*QueryCalculateTotalsResponse) ProtoMessage() {} func (x *QueryCalculateTotalsResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[46] + mi := &file_product_proto_msgTypes[50] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2266,7 +2441,7 @@ func (x *QueryCalculateTotalsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryCalculateTotalsResponse.ProtoReflect.Descriptor instead. func (*QueryCalculateTotalsResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{46} + return file_product_proto_rawDescGZIP(), []int{50} } func (x *QueryCalculateTotalsResponse) GetCalculateTotals() []*Order { @@ -2285,7 +2460,7 @@ type QueryCategoriesRequest struct { func (x *QueryCategoriesRequest) Reset() { *x = QueryCategoriesRequest{} - mi := &file_product_proto_msgTypes[47] + mi := &file_product_proto_msgTypes[51] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2297,7 +2472,7 @@ func (x *QueryCategoriesRequest) String() string { func (*QueryCategoriesRequest) ProtoMessage() {} func (x *QueryCategoriesRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[47] + mi := &file_product_proto_msgTypes[51] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2310,7 +2485,7 @@ func (x *QueryCategoriesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryCategoriesRequest.ProtoReflect.Descriptor instead. func (*QueryCategoriesRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{47} + return file_product_proto_rawDescGZIP(), []int{51} } // Response message for categories operation. @@ -2323,7 +2498,7 @@ type QueryCategoriesResponse struct { func (x *QueryCategoriesResponse) Reset() { *x = QueryCategoriesResponse{} - mi := &file_product_proto_msgTypes[48] + mi := &file_product_proto_msgTypes[52] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2335,7 +2510,7 @@ func (x *QueryCategoriesResponse) String() string { func (*QueryCategoriesResponse) ProtoMessage() {} func (x *QueryCategoriesResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[48] + mi := &file_product_proto_msgTypes[52] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2348,7 +2523,7 @@ func (x *QueryCategoriesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryCategoriesResponse.ProtoReflect.Descriptor instead. func (*QueryCategoriesResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{48} + return file_product_proto_rawDescGZIP(), []int{52} } func (x *QueryCategoriesResponse) GetCategories() []*Category { @@ -2368,7 +2543,7 @@ type QueryCategoryRequest struct { func (x *QueryCategoryRequest) Reset() { *x = QueryCategoryRequest{} - mi := &file_product_proto_msgTypes[49] + mi := &file_product_proto_msgTypes[53] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2380,7 +2555,7 @@ func (x *QueryCategoryRequest) String() string { func (*QueryCategoryRequest) ProtoMessage() {} func (x *QueryCategoryRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[49] + mi := &file_product_proto_msgTypes[53] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2393,7 +2568,7 @@ func (x *QueryCategoryRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryCategoryRequest.ProtoReflect.Descriptor instead. func (*QueryCategoryRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{49} + return file_product_proto_rawDescGZIP(), []int{53} } func (x *QueryCategoryRequest) GetId() string { @@ -2413,7 +2588,7 @@ type QueryCategoryResponse struct { func (x *QueryCategoryResponse) Reset() { *x = QueryCategoryResponse{} - mi := &file_product_proto_msgTypes[50] + mi := &file_product_proto_msgTypes[54] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2425,7 +2600,7 @@ func (x *QueryCategoryResponse) String() string { func (*QueryCategoryResponse) ProtoMessage() {} func (x *QueryCategoryResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[50] + mi := &file_product_proto_msgTypes[54] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2438,7 +2613,7 @@ func (x *QueryCategoryResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryCategoryResponse.ProtoReflect.Descriptor instead. func (*QueryCategoryResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{50} + return file_product_proto_rawDescGZIP(), []int{54} } func (x *QueryCategoryResponse) GetCategory() *Category { @@ -2458,7 +2633,7 @@ type QueryCategoriesByKindRequest struct { func (x *QueryCategoriesByKindRequest) Reset() { *x = QueryCategoriesByKindRequest{} - mi := &file_product_proto_msgTypes[51] + mi := &file_product_proto_msgTypes[55] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2470,7 +2645,7 @@ func (x *QueryCategoriesByKindRequest) String() string { func (*QueryCategoriesByKindRequest) ProtoMessage() {} func (x *QueryCategoriesByKindRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[51] + mi := &file_product_proto_msgTypes[55] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2483,7 +2658,7 @@ func (x *QueryCategoriesByKindRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryCategoriesByKindRequest.ProtoReflect.Descriptor instead. func (*QueryCategoriesByKindRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{51} + return file_product_proto_rawDescGZIP(), []int{55} } func (x *QueryCategoriesByKindRequest) GetKind() CategoryKind { @@ -2503,7 +2678,7 @@ type QueryCategoriesByKindResponse struct { func (x *QueryCategoriesByKindResponse) Reset() { *x = QueryCategoriesByKindResponse{} - mi := &file_product_proto_msgTypes[52] + mi := &file_product_proto_msgTypes[56] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2515,7 +2690,7 @@ func (x *QueryCategoriesByKindResponse) String() string { func (*QueryCategoriesByKindResponse) ProtoMessage() {} func (x *QueryCategoriesByKindResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[52] + mi := &file_product_proto_msgTypes[56] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2528,7 +2703,7 @@ func (x *QueryCategoriesByKindResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryCategoriesByKindResponse.ProtoReflect.Descriptor instead. func (*QueryCategoriesByKindResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{52} + return file_product_proto_rawDescGZIP(), []int{56} } func (x *QueryCategoriesByKindResponse) GetCategoriesByKind() []*Category { @@ -2548,7 +2723,7 @@ type QueryCategoriesByKindsRequest struct { func (x *QueryCategoriesByKindsRequest) Reset() { *x = QueryCategoriesByKindsRequest{} - mi := &file_product_proto_msgTypes[53] + mi := &file_product_proto_msgTypes[57] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2560,7 +2735,7 @@ func (x *QueryCategoriesByKindsRequest) String() string { func (*QueryCategoriesByKindsRequest) ProtoMessage() {} func (x *QueryCategoriesByKindsRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[53] + mi := &file_product_proto_msgTypes[57] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2573,7 +2748,7 @@ func (x *QueryCategoriesByKindsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryCategoriesByKindsRequest.ProtoReflect.Descriptor instead. func (*QueryCategoriesByKindsRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{53} + return file_product_proto_rawDescGZIP(), []int{57} } func (x *QueryCategoriesByKindsRequest) GetKinds() []CategoryKind { @@ -2593,7 +2768,7 @@ type QueryCategoriesByKindsResponse struct { func (x *QueryCategoriesByKindsResponse) Reset() { *x = QueryCategoriesByKindsResponse{} - mi := &file_product_proto_msgTypes[54] + mi := &file_product_proto_msgTypes[58] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2605,7 +2780,7 @@ func (x *QueryCategoriesByKindsResponse) String() string { func (*QueryCategoriesByKindsResponse) ProtoMessage() {} func (x *QueryCategoriesByKindsResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[54] + mi := &file_product_proto_msgTypes[58] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2618,7 +2793,7 @@ func (x *QueryCategoriesByKindsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryCategoriesByKindsResponse.ProtoReflect.Descriptor instead. func (*QueryCategoriesByKindsResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{54} + return file_product_proto_rawDescGZIP(), []int{58} } func (x *QueryCategoriesByKindsResponse) GetCategoriesByKinds() []*Category { @@ -2638,7 +2813,7 @@ type QueryFilterCategoriesRequest struct { func (x *QueryFilterCategoriesRequest) Reset() { *x = QueryFilterCategoriesRequest{} - mi := &file_product_proto_msgTypes[55] + mi := &file_product_proto_msgTypes[59] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2650,7 +2825,7 @@ func (x *QueryFilterCategoriesRequest) String() string { func (*QueryFilterCategoriesRequest) ProtoMessage() {} func (x *QueryFilterCategoriesRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[55] + mi := &file_product_proto_msgTypes[59] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2663,7 +2838,7 @@ func (x *QueryFilterCategoriesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryFilterCategoriesRequest.ProtoReflect.Descriptor instead. func (*QueryFilterCategoriesRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{55} + return file_product_proto_rawDescGZIP(), []int{59} } func (x *QueryFilterCategoriesRequest) GetFilter() *CategoryFilter { @@ -2683,7 +2858,7 @@ type QueryFilterCategoriesResponse struct { func (x *QueryFilterCategoriesResponse) Reset() { *x = QueryFilterCategoriesResponse{} - mi := &file_product_proto_msgTypes[56] + mi := &file_product_proto_msgTypes[60] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2695,7 +2870,7 @@ func (x *QueryFilterCategoriesResponse) String() string { func (*QueryFilterCategoriesResponse) ProtoMessage() {} func (x *QueryFilterCategoriesResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[56] + mi := &file_product_proto_msgTypes[60] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2708,7 +2883,7 @@ func (x *QueryFilterCategoriesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryFilterCategoriesResponse.ProtoReflect.Descriptor instead. func (*QueryFilterCategoriesResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{56} + return file_product_proto_rawDescGZIP(), []int{60} } func (x *QueryFilterCategoriesResponse) GetFilterCategories() []*Category { @@ -2727,7 +2902,7 @@ type QueryRandomPetRequest struct { func (x *QueryRandomPetRequest) Reset() { *x = QueryRandomPetRequest{} - mi := &file_product_proto_msgTypes[57] + mi := &file_product_proto_msgTypes[61] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2739,7 +2914,7 @@ func (x *QueryRandomPetRequest) String() string { func (*QueryRandomPetRequest) ProtoMessage() {} func (x *QueryRandomPetRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[57] + mi := &file_product_proto_msgTypes[61] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2752,7 +2927,7 @@ func (x *QueryRandomPetRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryRandomPetRequest.ProtoReflect.Descriptor instead. func (*QueryRandomPetRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{57} + return file_product_proto_rawDescGZIP(), []int{61} } // Response message for randomPet operation. @@ -2765,7 +2940,7 @@ type QueryRandomPetResponse struct { func (x *QueryRandomPetResponse) Reset() { *x = QueryRandomPetResponse{} - mi := &file_product_proto_msgTypes[58] + mi := &file_product_proto_msgTypes[62] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2777,7 +2952,7 @@ func (x *QueryRandomPetResponse) String() string { func (*QueryRandomPetResponse) ProtoMessage() {} func (x *QueryRandomPetResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[58] + mi := &file_product_proto_msgTypes[62] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2790,7 +2965,7 @@ func (x *QueryRandomPetResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryRandomPetResponse.ProtoReflect.Descriptor instead. func (*QueryRandomPetResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{58} + return file_product_proto_rawDescGZIP(), []int{62} } func (x *QueryRandomPetResponse) GetRandomPet() *Animal { @@ -2809,7 +2984,7 @@ type QueryAllPetsRequest struct { func (x *QueryAllPetsRequest) Reset() { *x = QueryAllPetsRequest{} - mi := &file_product_proto_msgTypes[59] + mi := &file_product_proto_msgTypes[63] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2821,7 +2996,7 @@ func (x *QueryAllPetsRequest) String() string { func (*QueryAllPetsRequest) ProtoMessage() {} func (x *QueryAllPetsRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[59] + mi := &file_product_proto_msgTypes[63] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2834,7 +3009,7 @@ func (x *QueryAllPetsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryAllPetsRequest.ProtoReflect.Descriptor instead. func (*QueryAllPetsRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{59} + return file_product_proto_rawDescGZIP(), []int{63} } // Response message for allPets operation. @@ -2847,7 +3022,7 @@ type QueryAllPetsResponse struct { func (x *QueryAllPetsResponse) Reset() { *x = QueryAllPetsResponse{} - mi := &file_product_proto_msgTypes[60] + mi := &file_product_proto_msgTypes[64] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2859,7 +3034,7 @@ func (x *QueryAllPetsResponse) String() string { func (*QueryAllPetsResponse) ProtoMessage() {} func (x *QueryAllPetsResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[60] + mi := &file_product_proto_msgTypes[64] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2872,7 +3047,7 @@ func (x *QueryAllPetsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryAllPetsResponse.ProtoReflect.Descriptor instead. func (*QueryAllPetsResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{60} + return file_product_proto_rawDescGZIP(), []int{64} } func (x *QueryAllPetsResponse) GetAllPets() []*Animal { @@ -2892,7 +3067,7 @@ type QuerySearchRequest struct { func (x *QuerySearchRequest) Reset() { *x = QuerySearchRequest{} - mi := &file_product_proto_msgTypes[61] + mi := &file_product_proto_msgTypes[65] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2904,7 +3079,7 @@ func (x *QuerySearchRequest) String() string { func (*QuerySearchRequest) ProtoMessage() {} func (x *QuerySearchRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[61] + mi := &file_product_proto_msgTypes[65] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2917,7 +3092,7 @@ func (x *QuerySearchRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use QuerySearchRequest.ProtoReflect.Descriptor instead. func (*QuerySearchRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{61} + return file_product_proto_rawDescGZIP(), []int{65} } func (x *QuerySearchRequest) GetInput() *SearchInput { @@ -2937,7 +3112,7 @@ type QuerySearchResponse struct { func (x *QuerySearchResponse) Reset() { *x = QuerySearchResponse{} - mi := &file_product_proto_msgTypes[62] + mi := &file_product_proto_msgTypes[66] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2949,7 +3124,7 @@ func (x *QuerySearchResponse) String() string { func (*QuerySearchResponse) ProtoMessage() {} func (x *QuerySearchResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[62] + mi := &file_product_proto_msgTypes[66] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2962,7 +3137,7 @@ func (x *QuerySearchResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use QuerySearchResponse.ProtoReflect.Descriptor instead. func (*QuerySearchResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{62} + return file_product_proto_rawDescGZIP(), []int{66} } func (x *QuerySearchResponse) GetSearch() []*SearchResult { @@ -2981,7 +3156,7 @@ type QueryRandomSearchResultRequest struct { func (x *QueryRandomSearchResultRequest) Reset() { *x = QueryRandomSearchResultRequest{} - mi := &file_product_proto_msgTypes[63] + mi := &file_product_proto_msgTypes[67] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2993,7 +3168,7 @@ func (x *QueryRandomSearchResultRequest) String() string { func (*QueryRandomSearchResultRequest) ProtoMessage() {} func (x *QueryRandomSearchResultRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[63] + mi := &file_product_proto_msgTypes[67] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3006,7 +3181,7 @@ func (x *QueryRandomSearchResultRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryRandomSearchResultRequest.ProtoReflect.Descriptor instead. func (*QueryRandomSearchResultRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{63} + return file_product_proto_rawDescGZIP(), []int{67} } // Response message for randomSearchResult operation. @@ -3019,7 +3194,7 @@ type QueryRandomSearchResultResponse struct { func (x *QueryRandomSearchResultResponse) Reset() { *x = QueryRandomSearchResultResponse{} - mi := &file_product_proto_msgTypes[64] + mi := &file_product_proto_msgTypes[68] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3031,7 +3206,7 @@ func (x *QueryRandomSearchResultResponse) String() string { func (*QueryRandomSearchResultResponse) ProtoMessage() {} func (x *QueryRandomSearchResultResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[64] + mi := &file_product_proto_msgTypes[68] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3044,7 +3219,7 @@ func (x *QueryRandomSearchResultResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryRandomSearchResultResponse.ProtoReflect.Descriptor instead. func (*QueryRandomSearchResultResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{64} + return file_product_proto_rawDescGZIP(), []int{68} } func (x *QueryRandomSearchResultResponse) GetRandomSearchResult() *SearchResult { @@ -3063,7 +3238,7 @@ type QueryNullableFieldsTypeRequest struct { func (x *QueryNullableFieldsTypeRequest) Reset() { *x = QueryNullableFieldsTypeRequest{} - mi := &file_product_proto_msgTypes[65] + mi := &file_product_proto_msgTypes[69] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3075,7 +3250,7 @@ func (x *QueryNullableFieldsTypeRequest) String() string { func (*QueryNullableFieldsTypeRequest) ProtoMessage() {} func (x *QueryNullableFieldsTypeRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[65] + mi := &file_product_proto_msgTypes[69] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3088,7 +3263,7 @@ func (x *QueryNullableFieldsTypeRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryNullableFieldsTypeRequest.ProtoReflect.Descriptor instead. func (*QueryNullableFieldsTypeRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{65} + return file_product_proto_rawDescGZIP(), []int{69} } // Response message for nullableFieldsType operation. @@ -3101,7 +3276,7 @@ type QueryNullableFieldsTypeResponse struct { func (x *QueryNullableFieldsTypeResponse) Reset() { *x = QueryNullableFieldsTypeResponse{} - mi := &file_product_proto_msgTypes[66] + mi := &file_product_proto_msgTypes[70] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3113,7 +3288,7 @@ func (x *QueryNullableFieldsTypeResponse) String() string { func (*QueryNullableFieldsTypeResponse) ProtoMessage() {} func (x *QueryNullableFieldsTypeResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[66] + mi := &file_product_proto_msgTypes[70] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3126,7 +3301,7 @@ func (x *QueryNullableFieldsTypeResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryNullableFieldsTypeResponse.ProtoReflect.Descriptor instead. func (*QueryNullableFieldsTypeResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{66} + return file_product_proto_rawDescGZIP(), []int{70} } func (x *QueryNullableFieldsTypeResponse) GetNullableFieldsType() *NullableFieldsType { @@ -3146,7 +3321,7 @@ type QueryNullableFieldsTypeByIdRequest struct { func (x *QueryNullableFieldsTypeByIdRequest) Reset() { *x = QueryNullableFieldsTypeByIdRequest{} - mi := &file_product_proto_msgTypes[67] + mi := &file_product_proto_msgTypes[71] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3158,7 +3333,7 @@ func (x *QueryNullableFieldsTypeByIdRequest) String() string { func (*QueryNullableFieldsTypeByIdRequest) ProtoMessage() {} func (x *QueryNullableFieldsTypeByIdRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[67] + mi := &file_product_proto_msgTypes[71] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3171,7 +3346,7 @@ func (x *QueryNullableFieldsTypeByIdRequest) ProtoReflect() protoreflect.Message // Deprecated: Use QueryNullableFieldsTypeByIdRequest.ProtoReflect.Descriptor instead. func (*QueryNullableFieldsTypeByIdRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{67} + return file_product_proto_rawDescGZIP(), []int{71} } func (x *QueryNullableFieldsTypeByIdRequest) GetId() string { @@ -3191,7 +3366,7 @@ type QueryNullableFieldsTypeByIdResponse struct { func (x *QueryNullableFieldsTypeByIdResponse) Reset() { *x = QueryNullableFieldsTypeByIdResponse{} - mi := &file_product_proto_msgTypes[68] + mi := &file_product_proto_msgTypes[72] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3203,7 +3378,7 @@ func (x *QueryNullableFieldsTypeByIdResponse) String() string { func (*QueryNullableFieldsTypeByIdResponse) ProtoMessage() {} func (x *QueryNullableFieldsTypeByIdResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[68] + mi := &file_product_proto_msgTypes[72] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3216,7 +3391,7 @@ func (x *QueryNullableFieldsTypeByIdResponse) ProtoReflect() protoreflect.Messag // Deprecated: Use QueryNullableFieldsTypeByIdResponse.ProtoReflect.Descriptor instead. func (*QueryNullableFieldsTypeByIdResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{68} + return file_product_proto_rawDescGZIP(), []int{72} } func (x *QueryNullableFieldsTypeByIdResponse) GetNullableFieldsTypeById() *NullableFieldsType { @@ -3236,7 +3411,7 @@ type QueryNullableFieldsTypeWithFilterRequest struct { func (x *QueryNullableFieldsTypeWithFilterRequest) Reset() { *x = QueryNullableFieldsTypeWithFilterRequest{} - mi := &file_product_proto_msgTypes[69] + mi := &file_product_proto_msgTypes[73] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3248,7 +3423,7 @@ func (x *QueryNullableFieldsTypeWithFilterRequest) String() string { func (*QueryNullableFieldsTypeWithFilterRequest) ProtoMessage() {} func (x *QueryNullableFieldsTypeWithFilterRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[69] + mi := &file_product_proto_msgTypes[73] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3261,7 +3436,7 @@ func (x *QueryNullableFieldsTypeWithFilterRequest) ProtoReflect() protoreflect.M // Deprecated: Use QueryNullableFieldsTypeWithFilterRequest.ProtoReflect.Descriptor instead. func (*QueryNullableFieldsTypeWithFilterRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{69} + return file_product_proto_rawDescGZIP(), []int{73} } func (x *QueryNullableFieldsTypeWithFilterRequest) GetFilter() *NullableFieldsFilter { @@ -3281,7 +3456,7 @@ type QueryNullableFieldsTypeWithFilterResponse struct { func (x *QueryNullableFieldsTypeWithFilterResponse) Reset() { *x = QueryNullableFieldsTypeWithFilterResponse{} - mi := &file_product_proto_msgTypes[70] + mi := &file_product_proto_msgTypes[74] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3293,7 +3468,7 @@ func (x *QueryNullableFieldsTypeWithFilterResponse) String() string { func (*QueryNullableFieldsTypeWithFilterResponse) ProtoMessage() {} func (x *QueryNullableFieldsTypeWithFilterResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[70] + mi := &file_product_proto_msgTypes[74] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3306,7 +3481,7 @@ func (x *QueryNullableFieldsTypeWithFilterResponse) ProtoReflect() protoreflect. // Deprecated: Use QueryNullableFieldsTypeWithFilterResponse.ProtoReflect.Descriptor instead. func (*QueryNullableFieldsTypeWithFilterResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{70} + return file_product_proto_rawDescGZIP(), []int{74} } func (x *QueryNullableFieldsTypeWithFilterResponse) GetNullableFieldsTypeWithFilter() []*NullableFieldsType { @@ -3325,7 +3500,7 @@ type QueryAllNullableFieldsTypesRequest struct { func (x *QueryAllNullableFieldsTypesRequest) Reset() { *x = QueryAllNullableFieldsTypesRequest{} - mi := &file_product_proto_msgTypes[71] + mi := &file_product_proto_msgTypes[75] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3337,7 +3512,7 @@ func (x *QueryAllNullableFieldsTypesRequest) String() string { func (*QueryAllNullableFieldsTypesRequest) ProtoMessage() {} func (x *QueryAllNullableFieldsTypesRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[71] + mi := &file_product_proto_msgTypes[75] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3350,7 +3525,7 @@ func (x *QueryAllNullableFieldsTypesRequest) ProtoReflect() protoreflect.Message // Deprecated: Use QueryAllNullableFieldsTypesRequest.ProtoReflect.Descriptor instead. func (*QueryAllNullableFieldsTypesRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{71} + return file_product_proto_rawDescGZIP(), []int{75} } // Response message for allNullableFieldsTypes operation. @@ -3363,7 +3538,7 @@ type QueryAllNullableFieldsTypesResponse struct { func (x *QueryAllNullableFieldsTypesResponse) Reset() { *x = QueryAllNullableFieldsTypesResponse{} - mi := &file_product_proto_msgTypes[72] + mi := &file_product_proto_msgTypes[76] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3375,7 +3550,7 @@ func (x *QueryAllNullableFieldsTypesResponse) String() string { func (*QueryAllNullableFieldsTypesResponse) ProtoMessage() {} func (x *QueryAllNullableFieldsTypesResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[72] + mi := &file_product_proto_msgTypes[76] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3388,7 +3563,7 @@ func (x *QueryAllNullableFieldsTypesResponse) ProtoReflect() protoreflect.Messag // Deprecated: Use QueryAllNullableFieldsTypesResponse.ProtoReflect.Descriptor instead. func (*QueryAllNullableFieldsTypesResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{72} + return file_product_proto_rawDescGZIP(), []int{76} } func (x *QueryAllNullableFieldsTypesResponse) GetAllNullableFieldsTypes() []*NullableFieldsType { @@ -3407,7 +3582,7 @@ type QueryBlogPostRequest struct { func (x *QueryBlogPostRequest) Reset() { *x = QueryBlogPostRequest{} - mi := &file_product_proto_msgTypes[73] + mi := &file_product_proto_msgTypes[77] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3419,7 +3594,7 @@ func (x *QueryBlogPostRequest) String() string { func (*QueryBlogPostRequest) ProtoMessage() {} func (x *QueryBlogPostRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[73] + mi := &file_product_proto_msgTypes[77] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3432,7 +3607,7 @@ func (x *QueryBlogPostRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryBlogPostRequest.ProtoReflect.Descriptor instead. func (*QueryBlogPostRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{73} + return file_product_proto_rawDescGZIP(), []int{77} } // Response message for blogPost operation. @@ -3445,7 +3620,7 @@ type QueryBlogPostResponse struct { func (x *QueryBlogPostResponse) Reset() { *x = QueryBlogPostResponse{} - mi := &file_product_proto_msgTypes[74] + mi := &file_product_proto_msgTypes[78] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3457,7 +3632,7 @@ func (x *QueryBlogPostResponse) String() string { func (*QueryBlogPostResponse) ProtoMessage() {} func (x *QueryBlogPostResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[74] + mi := &file_product_proto_msgTypes[78] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3470,7 +3645,7 @@ func (x *QueryBlogPostResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryBlogPostResponse.ProtoReflect.Descriptor instead. func (*QueryBlogPostResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{74} + return file_product_proto_rawDescGZIP(), []int{78} } func (x *QueryBlogPostResponse) GetBlogPost() *BlogPost { @@ -3490,7 +3665,7 @@ type QueryBlogPostByIdRequest struct { func (x *QueryBlogPostByIdRequest) Reset() { *x = QueryBlogPostByIdRequest{} - mi := &file_product_proto_msgTypes[75] + mi := &file_product_proto_msgTypes[79] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3502,7 +3677,7 @@ func (x *QueryBlogPostByIdRequest) String() string { func (*QueryBlogPostByIdRequest) ProtoMessage() {} func (x *QueryBlogPostByIdRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[75] + mi := &file_product_proto_msgTypes[79] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3515,7 +3690,7 @@ func (x *QueryBlogPostByIdRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryBlogPostByIdRequest.ProtoReflect.Descriptor instead. func (*QueryBlogPostByIdRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{75} + return file_product_proto_rawDescGZIP(), []int{79} } func (x *QueryBlogPostByIdRequest) GetId() string { @@ -3535,7 +3710,7 @@ type QueryBlogPostByIdResponse struct { func (x *QueryBlogPostByIdResponse) Reset() { *x = QueryBlogPostByIdResponse{} - mi := &file_product_proto_msgTypes[76] + mi := &file_product_proto_msgTypes[80] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3547,7 +3722,7 @@ func (x *QueryBlogPostByIdResponse) String() string { func (*QueryBlogPostByIdResponse) ProtoMessage() {} func (x *QueryBlogPostByIdResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[76] + mi := &file_product_proto_msgTypes[80] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3560,7 +3735,7 @@ func (x *QueryBlogPostByIdResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryBlogPostByIdResponse.ProtoReflect.Descriptor instead. func (*QueryBlogPostByIdResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{76} + return file_product_proto_rawDescGZIP(), []int{80} } func (x *QueryBlogPostByIdResponse) GetBlogPostById() *BlogPost { @@ -3580,7 +3755,7 @@ type QueryBlogPostsWithFilterRequest struct { func (x *QueryBlogPostsWithFilterRequest) Reset() { *x = QueryBlogPostsWithFilterRequest{} - mi := &file_product_proto_msgTypes[77] + mi := &file_product_proto_msgTypes[81] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3592,7 +3767,7 @@ func (x *QueryBlogPostsWithFilterRequest) String() string { func (*QueryBlogPostsWithFilterRequest) ProtoMessage() {} func (x *QueryBlogPostsWithFilterRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[77] + mi := &file_product_proto_msgTypes[81] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3605,7 +3780,7 @@ func (x *QueryBlogPostsWithFilterRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryBlogPostsWithFilterRequest.ProtoReflect.Descriptor instead. func (*QueryBlogPostsWithFilterRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{77} + return file_product_proto_rawDescGZIP(), []int{81} } func (x *QueryBlogPostsWithFilterRequest) GetFilter() *BlogPostFilter { @@ -3625,7 +3800,7 @@ type QueryBlogPostsWithFilterResponse struct { func (x *QueryBlogPostsWithFilterResponse) Reset() { *x = QueryBlogPostsWithFilterResponse{} - mi := &file_product_proto_msgTypes[78] + mi := &file_product_proto_msgTypes[82] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3637,7 +3812,7 @@ func (x *QueryBlogPostsWithFilterResponse) String() string { func (*QueryBlogPostsWithFilterResponse) ProtoMessage() {} func (x *QueryBlogPostsWithFilterResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[78] + mi := &file_product_proto_msgTypes[82] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3650,7 +3825,7 @@ func (x *QueryBlogPostsWithFilterResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryBlogPostsWithFilterResponse.ProtoReflect.Descriptor instead. func (*QueryBlogPostsWithFilterResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{78} + return file_product_proto_rawDescGZIP(), []int{82} } func (x *QueryBlogPostsWithFilterResponse) GetBlogPostsWithFilter() []*BlogPost { @@ -3669,7 +3844,7 @@ type QueryAllBlogPostsRequest struct { func (x *QueryAllBlogPostsRequest) Reset() { *x = QueryAllBlogPostsRequest{} - mi := &file_product_proto_msgTypes[79] + mi := &file_product_proto_msgTypes[83] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3681,7 +3856,7 @@ func (x *QueryAllBlogPostsRequest) String() string { func (*QueryAllBlogPostsRequest) ProtoMessage() {} func (x *QueryAllBlogPostsRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[79] + mi := &file_product_proto_msgTypes[83] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3694,7 +3869,7 @@ func (x *QueryAllBlogPostsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryAllBlogPostsRequest.ProtoReflect.Descriptor instead. func (*QueryAllBlogPostsRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{79} + return file_product_proto_rawDescGZIP(), []int{83} } // Response message for allBlogPosts operation. @@ -3707,7 +3882,7 @@ type QueryAllBlogPostsResponse struct { func (x *QueryAllBlogPostsResponse) Reset() { *x = QueryAllBlogPostsResponse{} - mi := &file_product_proto_msgTypes[80] + mi := &file_product_proto_msgTypes[84] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3719,7 +3894,7 @@ func (x *QueryAllBlogPostsResponse) String() string { func (*QueryAllBlogPostsResponse) ProtoMessage() {} func (x *QueryAllBlogPostsResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[80] + mi := &file_product_proto_msgTypes[84] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3732,7 +3907,7 @@ func (x *QueryAllBlogPostsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryAllBlogPostsResponse.ProtoReflect.Descriptor instead. func (*QueryAllBlogPostsResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{80} + return file_product_proto_rawDescGZIP(), []int{84} } func (x *QueryAllBlogPostsResponse) GetAllBlogPosts() []*BlogPost { @@ -3751,7 +3926,7 @@ type QueryAuthorRequest struct { func (x *QueryAuthorRequest) Reset() { *x = QueryAuthorRequest{} - mi := &file_product_proto_msgTypes[81] + mi := &file_product_proto_msgTypes[85] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3763,7 +3938,7 @@ func (x *QueryAuthorRequest) String() string { func (*QueryAuthorRequest) ProtoMessage() {} func (x *QueryAuthorRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[81] + mi := &file_product_proto_msgTypes[85] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3776,7 +3951,7 @@ func (x *QueryAuthorRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryAuthorRequest.ProtoReflect.Descriptor instead. func (*QueryAuthorRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{81} + return file_product_proto_rawDescGZIP(), []int{85} } // Response message for author operation. @@ -3789,7 +3964,7 @@ type QueryAuthorResponse struct { func (x *QueryAuthorResponse) Reset() { *x = QueryAuthorResponse{} - mi := &file_product_proto_msgTypes[82] + mi := &file_product_proto_msgTypes[86] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3801,7 +3976,7 @@ func (x *QueryAuthorResponse) String() string { func (*QueryAuthorResponse) ProtoMessage() {} func (x *QueryAuthorResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[82] + mi := &file_product_proto_msgTypes[86] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3814,7 +3989,7 @@ func (x *QueryAuthorResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryAuthorResponse.ProtoReflect.Descriptor instead. func (*QueryAuthorResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{82} + return file_product_proto_rawDescGZIP(), []int{86} } func (x *QueryAuthorResponse) GetAuthor() *Author { @@ -3834,7 +4009,7 @@ type QueryAuthorByIdRequest struct { func (x *QueryAuthorByIdRequest) Reset() { *x = QueryAuthorByIdRequest{} - mi := &file_product_proto_msgTypes[83] + mi := &file_product_proto_msgTypes[87] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3846,7 +4021,7 @@ func (x *QueryAuthorByIdRequest) String() string { func (*QueryAuthorByIdRequest) ProtoMessage() {} func (x *QueryAuthorByIdRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[83] + mi := &file_product_proto_msgTypes[87] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3859,7 +4034,7 @@ func (x *QueryAuthorByIdRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryAuthorByIdRequest.ProtoReflect.Descriptor instead. func (*QueryAuthorByIdRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{83} + return file_product_proto_rawDescGZIP(), []int{87} } func (x *QueryAuthorByIdRequest) GetId() string { @@ -3879,7 +4054,7 @@ type QueryAuthorByIdResponse struct { func (x *QueryAuthorByIdResponse) Reset() { *x = QueryAuthorByIdResponse{} - mi := &file_product_proto_msgTypes[84] + mi := &file_product_proto_msgTypes[88] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3891,7 +4066,7 @@ func (x *QueryAuthorByIdResponse) String() string { func (*QueryAuthorByIdResponse) ProtoMessage() {} func (x *QueryAuthorByIdResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[84] + mi := &file_product_proto_msgTypes[88] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3904,7 +4079,7 @@ func (x *QueryAuthorByIdResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryAuthorByIdResponse.ProtoReflect.Descriptor instead. func (*QueryAuthorByIdResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{84} + return file_product_proto_rawDescGZIP(), []int{88} } func (x *QueryAuthorByIdResponse) GetAuthorById() *Author { @@ -3924,7 +4099,7 @@ type QueryAuthorsWithFilterRequest struct { func (x *QueryAuthorsWithFilterRequest) Reset() { *x = QueryAuthorsWithFilterRequest{} - mi := &file_product_proto_msgTypes[85] + mi := &file_product_proto_msgTypes[89] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3936,7 +4111,7 @@ func (x *QueryAuthorsWithFilterRequest) String() string { func (*QueryAuthorsWithFilterRequest) ProtoMessage() {} func (x *QueryAuthorsWithFilterRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[85] + mi := &file_product_proto_msgTypes[89] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3949,7 +4124,7 @@ func (x *QueryAuthorsWithFilterRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryAuthorsWithFilterRequest.ProtoReflect.Descriptor instead. func (*QueryAuthorsWithFilterRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{85} + return file_product_proto_rawDescGZIP(), []int{89} } func (x *QueryAuthorsWithFilterRequest) GetFilter() *AuthorFilter { @@ -3969,7 +4144,7 @@ type QueryAuthorsWithFilterResponse struct { func (x *QueryAuthorsWithFilterResponse) Reset() { *x = QueryAuthorsWithFilterResponse{} - mi := &file_product_proto_msgTypes[86] + mi := &file_product_proto_msgTypes[90] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3981,7 +4156,7 @@ func (x *QueryAuthorsWithFilterResponse) String() string { func (*QueryAuthorsWithFilterResponse) ProtoMessage() {} func (x *QueryAuthorsWithFilterResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[86] + mi := &file_product_proto_msgTypes[90] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3994,7 +4169,7 @@ func (x *QueryAuthorsWithFilterResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryAuthorsWithFilterResponse.ProtoReflect.Descriptor instead. func (*QueryAuthorsWithFilterResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{86} + return file_product_proto_rawDescGZIP(), []int{90} } func (x *QueryAuthorsWithFilterResponse) GetAuthorsWithFilter() []*Author { @@ -4013,7 +4188,7 @@ type QueryAllAuthorsRequest struct { func (x *QueryAllAuthorsRequest) Reset() { *x = QueryAllAuthorsRequest{} - mi := &file_product_proto_msgTypes[87] + mi := &file_product_proto_msgTypes[91] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4025,7 +4200,7 @@ func (x *QueryAllAuthorsRequest) String() string { func (*QueryAllAuthorsRequest) ProtoMessage() {} func (x *QueryAllAuthorsRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[87] + mi := &file_product_proto_msgTypes[91] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4038,7 +4213,7 @@ func (x *QueryAllAuthorsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryAllAuthorsRequest.ProtoReflect.Descriptor instead. func (*QueryAllAuthorsRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{87} + return file_product_proto_rawDescGZIP(), []int{91} } // Response message for allAuthors operation. @@ -4051,7 +4226,7 @@ type QueryAllAuthorsResponse struct { func (x *QueryAllAuthorsResponse) Reset() { *x = QueryAllAuthorsResponse{} - mi := &file_product_proto_msgTypes[88] + mi := &file_product_proto_msgTypes[92] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4063,7 +4238,7 @@ func (x *QueryAllAuthorsResponse) String() string { func (*QueryAllAuthorsResponse) ProtoMessage() {} func (x *QueryAllAuthorsResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[88] + mi := &file_product_proto_msgTypes[92] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4076,7 +4251,7 @@ func (x *QueryAllAuthorsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryAllAuthorsResponse.ProtoReflect.Descriptor instead. func (*QueryAllAuthorsResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{88} + return file_product_proto_rawDescGZIP(), []int{92} } func (x *QueryAllAuthorsResponse) GetAllAuthors() []*Author { @@ -4096,7 +4271,7 @@ type QueryBulkSearchAuthorsRequest struct { func (x *QueryBulkSearchAuthorsRequest) Reset() { *x = QueryBulkSearchAuthorsRequest{} - mi := &file_product_proto_msgTypes[89] + mi := &file_product_proto_msgTypes[93] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4108,7 +4283,7 @@ func (x *QueryBulkSearchAuthorsRequest) String() string { func (*QueryBulkSearchAuthorsRequest) ProtoMessage() {} func (x *QueryBulkSearchAuthorsRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[89] + mi := &file_product_proto_msgTypes[93] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4121,7 +4296,7 @@ func (x *QueryBulkSearchAuthorsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryBulkSearchAuthorsRequest.ProtoReflect.Descriptor instead. func (*QueryBulkSearchAuthorsRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{89} + return file_product_proto_rawDescGZIP(), []int{93} } func (x *QueryBulkSearchAuthorsRequest) GetFilters() *ListOfAuthorFilter { @@ -4141,7 +4316,7 @@ type QueryBulkSearchAuthorsResponse struct { func (x *QueryBulkSearchAuthorsResponse) Reset() { *x = QueryBulkSearchAuthorsResponse{} - mi := &file_product_proto_msgTypes[90] + mi := &file_product_proto_msgTypes[94] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4153,7 +4328,7 @@ func (x *QueryBulkSearchAuthorsResponse) String() string { func (*QueryBulkSearchAuthorsResponse) ProtoMessage() {} func (x *QueryBulkSearchAuthorsResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[90] + mi := &file_product_proto_msgTypes[94] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4166,7 +4341,7 @@ func (x *QueryBulkSearchAuthorsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryBulkSearchAuthorsResponse.ProtoReflect.Descriptor instead. func (*QueryBulkSearchAuthorsResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{90} + return file_product_proto_rawDescGZIP(), []int{94} } func (x *QueryBulkSearchAuthorsResponse) GetBulkSearchAuthors() []*Author { @@ -4186,7 +4361,7 @@ type QueryBulkSearchBlogPostsRequest struct { func (x *QueryBulkSearchBlogPostsRequest) Reset() { *x = QueryBulkSearchBlogPostsRequest{} - mi := &file_product_proto_msgTypes[91] + mi := &file_product_proto_msgTypes[95] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4198,7 +4373,7 @@ func (x *QueryBulkSearchBlogPostsRequest) String() string { func (*QueryBulkSearchBlogPostsRequest) ProtoMessage() {} func (x *QueryBulkSearchBlogPostsRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[91] + mi := &file_product_proto_msgTypes[95] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4211,7 +4386,7 @@ func (x *QueryBulkSearchBlogPostsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryBulkSearchBlogPostsRequest.ProtoReflect.Descriptor instead. func (*QueryBulkSearchBlogPostsRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{91} + return file_product_proto_rawDescGZIP(), []int{95} } func (x *QueryBulkSearchBlogPostsRequest) GetFilters() *ListOfBlogPostFilter { @@ -4231,7 +4406,7 @@ type QueryBulkSearchBlogPostsResponse struct { func (x *QueryBulkSearchBlogPostsResponse) Reset() { *x = QueryBulkSearchBlogPostsResponse{} - mi := &file_product_proto_msgTypes[92] + mi := &file_product_proto_msgTypes[96] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4243,7 +4418,7 @@ func (x *QueryBulkSearchBlogPostsResponse) String() string { func (*QueryBulkSearchBlogPostsResponse) ProtoMessage() {} func (x *QueryBulkSearchBlogPostsResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[92] + mi := &file_product_proto_msgTypes[96] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4256,7 +4431,7 @@ func (x *QueryBulkSearchBlogPostsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryBulkSearchBlogPostsResponse.ProtoReflect.Descriptor instead. func (*QueryBulkSearchBlogPostsResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{92} + return file_product_proto_rawDescGZIP(), []int{96} } func (x *QueryBulkSearchBlogPostsResponse) GetBulkSearchBlogPosts() []*BlogPost { @@ -4276,7 +4451,7 @@ type QueryTestContainerRequest struct { func (x *QueryTestContainerRequest) Reset() { *x = QueryTestContainerRequest{} - mi := &file_product_proto_msgTypes[93] + mi := &file_product_proto_msgTypes[97] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4288,7 +4463,7 @@ func (x *QueryTestContainerRequest) String() string { func (*QueryTestContainerRequest) ProtoMessage() {} func (x *QueryTestContainerRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[93] + mi := &file_product_proto_msgTypes[97] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4301,7 +4476,7 @@ func (x *QueryTestContainerRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryTestContainerRequest.ProtoReflect.Descriptor instead. func (*QueryTestContainerRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{93} + return file_product_proto_rawDescGZIP(), []int{97} } func (x *QueryTestContainerRequest) GetId() string { @@ -4321,7 +4496,7 @@ type QueryTestContainerResponse struct { func (x *QueryTestContainerResponse) Reset() { *x = QueryTestContainerResponse{} - mi := &file_product_proto_msgTypes[94] + mi := &file_product_proto_msgTypes[98] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4333,7 +4508,7 @@ func (x *QueryTestContainerResponse) String() string { func (*QueryTestContainerResponse) ProtoMessage() {} func (x *QueryTestContainerResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[94] + mi := &file_product_proto_msgTypes[98] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4346,7 +4521,7 @@ func (x *QueryTestContainerResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryTestContainerResponse.ProtoReflect.Descriptor instead. func (*QueryTestContainerResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{94} + return file_product_proto_rawDescGZIP(), []int{98} } func (x *QueryTestContainerResponse) GetTestContainer() *TestContainer { @@ -4365,7 +4540,7 @@ type QueryTestContainersRequest struct { func (x *QueryTestContainersRequest) Reset() { *x = QueryTestContainersRequest{} - mi := &file_product_proto_msgTypes[95] + mi := &file_product_proto_msgTypes[99] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4377,7 +4552,7 @@ func (x *QueryTestContainersRequest) String() string { func (*QueryTestContainersRequest) ProtoMessage() {} func (x *QueryTestContainersRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[95] + mi := &file_product_proto_msgTypes[99] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4390,7 +4565,7 @@ func (x *QueryTestContainersRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryTestContainersRequest.ProtoReflect.Descriptor instead. func (*QueryTestContainersRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{95} + return file_product_proto_rawDescGZIP(), []int{99} } // Response message for testContainers operation. @@ -4403,7 +4578,7 @@ type QueryTestContainersResponse struct { func (x *QueryTestContainersResponse) Reset() { *x = QueryTestContainersResponse{} - mi := &file_product_proto_msgTypes[96] + mi := &file_product_proto_msgTypes[100] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4415,7 +4590,7 @@ func (x *QueryTestContainersResponse) String() string { func (*QueryTestContainersResponse) ProtoMessage() {} func (x *QueryTestContainersResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[96] + mi := &file_product_proto_msgTypes[100] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4428,7 +4603,7 @@ func (x *QueryTestContainersResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryTestContainersResponse.ProtoReflect.Descriptor instead. func (*QueryTestContainersResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{96} + return file_product_proto_rawDescGZIP(), []int{100} } func (x *QueryTestContainersResponse) GetTestContainers() []*TestContainer { @@ -4448,7 +4623,7 @@ type QueryConditionalSearchRequest struct { func (x *QueryConditionalSearchRequest) Reset() { *x = QueryConditionalSearchRequest{} - mi := &file_product_proto_msgTypes[97] + mi := &file_product_proto_msgTypes[101] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4460,7 +4635,7 @@ func (x *QueryConditionalSearchRequest) String() string { func (*QueryConditionalSearchRequest) ProtoMessage() {} func (x *QueryConditionalSearchRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[97] + mi := &file_product_proto_msgTypes[101] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4473,7 +4648,7 @@ func (x *QueryConditionalSearchRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryConditionalSearchRequest.ProtoReflect.Descriptor instead. func (*QueryConditionalSearchRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{97} + return file_product_proto_rawDescGZIP(), []int{101} } func (x *QueryConditionalSearchRequest) GetConditions() *ConditionsInput { @@ -4493,7 +4668,7 @@ type QueryConditionalSearchResponse struct { func (x *QueryConditionalSearchResponse) Reset() { *x = QueryConditionalSearchResponse{} - mi := &file_product_proto_msgTypes[98] + mi := &file_product_proto_msgTypes[102] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4505,7 +4680,7 @@ func (x *QueryConditionalSearchResponse) String() string { func (*QueryConditionalSearchResponse) ProtoMessage() {} func (x *QueryConditionalSearchResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[98] + mi := &file_product_proto_msgTypes[102] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4518,7 +4693,7 @@ func (x *QueryConditionalSearchResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryConditionalSearchResponse.ProtoReflect.Descriptor instead. func (*QueryConditionalSearchResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{98} + return file_product_proto_rawDescGZIP(), []int{102} } func (x *QueryConditionalSearchResponse) GetConditionalSearch() []*ConditionalSearchResult { @@ -4538,7 +4713,7 @@ type MutationCreateUserRequest struct { func (x *MutationCreateUserRequest) Reset() { *x = MutationCreateUserRequest{} - mi := &file_product_proto_msgTypes[99] + mi := &file_product_proto_msgTypes[103] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4550,7 +4725,7 @@ func (x *MutationCreateUserRequest) String() string { func (*MutationCreateUserRequest) ProtoMessage() {} func (x *MutationCreateUserRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[99] + mi := &file_product_proto_msgTypes[103] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4563,7 +4738,7 @@ func (x *MutationCreateUserRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use MutationCreateUserRequest.ProtoReflect.Descriptor instead. func (*MutationCreateUserRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{99} + return file_product_proto_rawDescGZIP(), []int{103} } func (x *MutationCreateUserRequest) GetInput() *UserInput { @@ -4583,7 +4758,7 @@ type MutationCreateUserResponse struct { func (x *MutationCreateUserResponse) Reset() { *x = MutationCreateUserResponse{} - mi := &file_product_proto_msgTypes[100] + mi := &file_product_proto_msgTypes[104] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4595,7 +4770,7 @@ func (x *MutationCreateUserResponse) String() string { func (*MutationCreateUserResponse) ProtoMessage() {} func (x *MutationCreateUserResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[100] + mi := &file_product_proto_msgTypes[104] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4608,7 +4783,7 @@ func (x *MutationCreateUserResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use MutationCreateUserResponse.ProtoReflect.Descriptor instead. func (*MutationCreateUserResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{100} + return file_product_proto_rawDescGZIP(), []int{104} } func (x *MutationCreateUserResponse) GetCreateUser() *User { @@ -4628,7 +4803,7 @@ type MutationPerformActionRequest struct { func (x *MutationPerformActionRequest) Reset() { *x = MutationPerformActionRequest{} - mi := &file_product_proto_msgTypes[101] + mi := &file_product_proto_msgTypes[105] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4640,7 +4815,7 @@ func (x *MutationPerformActionRequest) String() string { func (*MutationPerformActionRequest) ProtoMessage() {} func (x *MutationPerformActionRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[101] + mi := &file_product_proto_msgTypes[105] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4653,7 +4828,7 @@ func (x *MutationPerformActionRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use MutationPerformActionRequest.ProtoReflect.Descriptor instead. func (*MutationPerformActionRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{101} + return file_product_proto_rawDescGZIP(), []int{105} } func (x *MutationPerformActionRequest) GetInput() *ActionInput { @@ -4673,7 +4848,7 @@ type MutationPerformActionResponse struct { func (x *MutationPerformActionResponse) Reset() { *x = MutationPerformActionResponse{} - mi := &file_product_proto_msgTypes[102] + mi := &file_product_proto_msgTypes[106] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4685,7 +4860,7 @@ func (x *MutationPerformActionResponse) String() string { func (*MutationPerformActionResponse) ProtoMessage() {} func (x *MutationPerformActionResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[102] + mi := &file_product_proto_msgTypes[106] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4698,7 +4873,7 @@ func (x *MutationPerformActionResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use MutationPerformActionResponse.ProtoReflect.Descriptor instead. func (*MutationPerformActionResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{102} + return file_product_proto_rawDescGZIP(), []int{106} } func (x *MutationPerformActionResponse) GetPerformAction() *ActionResult { @@ -4718,7 +4893,7 @@ type MutationCreateNullableFieldsTypeRequest struct { func (x *MutationCreateNullableFieldsTypeRequest) Reset() { *x = MutationCreateNullableFieldsTypeRequest{} - mi := &file_product_proto_msgTypes[103] + mi := &file_product_proto_msgTypes[107] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4730,7 +4905,7 @@ func (x *MutationCreateNullableFieldsTypeRequest) String() string { func (*MutationCreateNullableFieldsTypeRequest) ProtoMessage() {} func (x *MutationCreateNullableFieldsTypeRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[103] + mi := &file_product_proto_msgTypes[107] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4743,7 +4918,7 @@ func (x *MutationCreateNullableFieldsTypeRequest) ProtoReflect() protoreflect.Me // Deprecated: Use MutationCreateNullableFieldsTypeRequest.ProtoReflect.Descriptor instead. func (*MutationCreateNullableFieldsTypeRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{103} + return file_product_proto_rawDescGZIP(), []int{107} } func (x *MutationCreateNullableFieldsTypeRequest) GetInput() *NullableFieldsInput { @@ -4763,7 +4938,7 @@ type MutationCreateNullableFieldsTypeResponse struct { func (x *MutationCreateNullableFieldsTypeResponse) Reset() { *x = MutationCreateNullableFieldsTypeResponse{} - mi := &file_product_proto_msgTypes[104] + mi := &file_product_proto_msgTypes[108] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4775,7 +4950,7 @@ func (x *MutationCreateNullableFieldsTypeResponse) String() string { func (*MutationCreateNullableFieldsTypeResponse) ProtoMessage() {} func (x *MutationCreateNullableFieldsTypeResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[104] + mi := &file_product_proto_msgTypes[108] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4788,7 +4963,7 @@ func (x *MutationCreateNullableFieldsTypeResponse) ProtoReflect() protoreflect.M // Deprecated: Use MutationCreateNullableFieldsTypeResponse.ProtoReflect.Descriptor instead. func (*MutationCreateNullableFieldsTypeResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{104} + return file_product_proto_rawDescGZIP(), []int{108} } func (x *MutationCreateNullableFieldsTypeResponse) GetCreateNullableFieldsType() *NullableFieldsType { @@ -4809,7 +4984,7 @@ type MutationUpdateNullableFieldsTypeRequest struct { func (x *MutationUpdateNullableFieldsTypeRequest) Reset() { *x = MutationUpdateNullableFieldsTypeRequest{} - mi := &file_product_proto_msgTypes[105] + mi := &file_product_proto_msgTypes[109] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4821,7 +4996,7 @@ func (x *MutationUpdateNullableFieldsTypeRequest) String() string { func (*MutationUpdateNullableFieldsTypeRequest) ProtoMessage() {} func (x *MutationUpdateNullableFieldsTypeRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[105] + mi := &file_product_proto_msgTypes[109] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4834,7 +5009,7 @@ func (x *MutationUpdateNullableFieldsTypeRequest) ProtoReflect() protoreflect.Me // Deprecated: Use MutationUpdateNullableFieldsTypeRequest.ProtoReflect.Descriptor instead. func (*MutationUpdateNullableFieldsTypeRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{105} + return file_product_proto_rawDescGZIP(), []int{109} } func (x *MutationUpdateNullableFieldsTypeRequest) GetId() string { @@ -4861,7 +5036,7 @@ type MutationUpdateNullableFieldsTypeResponse struct { func (x *MutationUpdateNullableFieldsTypeResponse) Reset() { *x = MutationUpdateNullableFieldsTypeResponse{} - mi := &file_product_proto_msgTypes[106] + mi := &file_product_proto_msgTypes[110] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4873,7 +5048,7 @@ func (x *MutationUpdateNullableFieldsTypeResponse) String() string { func (*MutationUpdateNullableFieldsTypeResponse) ProtoMessage() {} func (x *MutationUpdateNullableFieldsTypeResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[106] + mi := &file_product_proto_msgTypes[110] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4886,7 +5061,7 @@ func (x *MutationUpdateNullableFieldsTypeResponse) ProtoReflect() protoreflect.M // Deprecated: Use MutationUpdateNullableFieldsTypeResponse.ProtoReflect.Descriptor instead. func (*MutationUpdateNullableFieldsTypeResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{106} + return file_product_proto_rawDescGZIP(), []int{110} } func (x *MutationUpdateNullableFieldsTypeResponse) GetUpdateNullableFieldsType() *NullableFieldsType { @@ -4906,7 +5081,7 @@ type MutationCreateBlogPostRequest struct { func (x *MutationCreateBlogPostRequest) Reset() { *x = MutationCreateBlogPostRequest{} - mi := &file_product_proto_msgTypes[107] + mi := &file_product_proto_msgTypes[111] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4918,7 +5093,7 @@ func (x *MutationCreateBlogPostRequest) String() string { func (*MutationCreateBlogPostRequest) ProtoMessage() {} func (x *MutationCreateBlogPostRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[107] + mi := &file_product_proto_msgTypes[111] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4931,7 +5106,7 @@ func (x *MutationCreateBlogPostRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use MutationCreateBlogPostRequest.ProtoReflect.Descriptor instead. func (*MutationCreateBlogPostRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{107} + return file_product_proto_rawDescGZIP(), []int{111} } func (x *MutationCreateBlogPostRequest) GetInput() *BlogPostInput { @@ -4951,7 +5126,7 @@ type MutationCreateBlogPostResponse struct { func (x *MutationCreateBlogPostResponse) Reset() { *x = MutationCreateBlogPostResponse{} - mi := &file_product_proto_msgTypes[108] + mi := &file_product_proto_msgTypes[112] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4963,7 +5138,7 @@ func (x *MutationCreateBlogPostResponse) String() string { func (*MutationCreateBlogPostResponse) ProtoMessage() {} func (x *MutationCreateBlogPostResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[108] + mi := &file_product_proto_msgTypes[112] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4976,7 +5151,7 @@ func (x *MutationCreateBlogPostResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use MutationCreateBlogPostResponse.ProtoReflect.Descriptor instead. func (*MutationCreateBlogPostResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{108} + return file_product_proto_rawDescGZIP(), []int{112} } func (x *MutationCreateBlogPostResponse) GetCreateBlogPost() *BlogPost { @@ -4997,7 +5172,7 @@ type MutationUpdateBlogPostRequest struct { func (x *MutationUpdateBlogPostRequest) Reset() { *x = MutationUpdateBlogPostRequest{} - mi := &file_product_proto_msgTypes[109] + mi := &file_product_proto_msgTypes[113] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5009,7 +5184,7 @@ func (x *MutationUpdateBlogPostRequest) String() string { func (*MutationUpdateBlogPostRequest) ProtoMessage() {} func (x *MutationUpdateBlogPostRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[109] + mi := &file_product_proto_msgTypes[113] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5022,7 +5197,7 @@ func (x *MutationUpdateBlogPostRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use MutationUpdateBlogPostRequest.ProtoReflect.Descriptor instead. func (*MutationUpdateBlogPostRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{109} + return file_product_proto_rawDescGZIP(), []int{113} } func (x *MutationUpdateBlogPostRequest) GetId() string { @@ -5049,7 +5224,7 @@ type MutationUpdateBlogPostResponse struct { func (x *MutationUpdateBlogPostResponse) Reset() { *x = MutationUpdateBlogPostResponse{} - mi := &file_product_proto_msgTypes[110] + mi := &file_product_proto_msgTypes[114] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5061,7 +5236,7 @@ func (x *MutationUpdateBlogPostResponse) String() string { func (*MutationUpdateBlogPostResponse) ProtoMessage() {} func (x *MutationUpdateBlogPostResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[110] + mi := &file_product_proto_msgTypes[114] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5074,7 +5249,7 @@ func (x *MutationUpdateBlogPostResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use MutationUpdateBlogPostResponse.ProtoReflect.Descriptor instead. func (*MutationUpdateBlogPostResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{110} + return file_product_proto_rawDescGZIP(), []int{114} } func (x *MutationUpdateBlogPostResponse) GetUpdateBlogPost() *BlogPost { @@ -5094,7 +5269,7 @@ type MutationCreateAuthorRequest struct { func (x *MutationCreateAuthorRequest) Reset() { *x = MutationCreateAuthorRequest{} - mi := &file_product_proto_msgTypes[111] + mi := &file_product_proto_msgTypes[115] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5106,7 +5281,7 @@ func (x *MutationCreateAuthorRequest) String() string { func (*MutationCreateAuthorRequest) ProtoMessage() {} func (x *MutationCreateAuthorRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[111] + mi := &file_product_proto_msgTypes[115] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5119,7 +5294,7 @@ func (x *MutationCreateAuthorRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use MutationCreateAuthorRequest.ProtoReflect.Descriptor instead. func (*MutationCreateAuthorRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{111} + return file_product_proto_rawDescGZIP(), []int{115} } func (x *MutationCreateAuthorRequest) GetInput() *AuthorInput { @@ -5139,7 +5314,7 @@ type MutationCreateAuthorResponse struct { func (x *MutationCreateAuthorResponse) Reset() { *x = MutationCreateAuthorResponse{} - mi := &file_product_proto_msgTypes[112] + mi := &file_product_proto_msgTypes[116] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5151,7 +5326,7 @@ func (x *MutationCreateAuthorResponse) String() string { func (*MutationCreateAuthorResponse) ProtoMessage() {} func (x *MutationCreateAuthorResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[112] + mi := &file_product_proto_msgTypes[116] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5164,7 +5339,7 @@ func (x *MutationCreateAuthorResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use MutationCreateAuthorResponse.ProtoReflect.Descriptor instead. func (*MutationCreateAuthorResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{112} + return file_product_proto_rawDescGZIP(), []int{116} } func (x *MutationCreateAuthorResponse) GetCreateAuthor() *Author { @@ -5185,7 +5360,7 @@ type MutationUpdateAuthorRequest struct { func (x *MutationUpdateAuthorRequest) Reset() { *x = MutationUpdateAuthorRequest{} - mi := &file_product_proto_msgTypes[113] + mi := &file_product_proto_msgTypes[117] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5197,7 +5372,7 @@ func (x *MutationUpdateAuthorRequest) String() string { func (*MutationUpdateAuthorRequest) ProtoMessage() {} func (x *MutationUpdateAuthorRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[113] + mi := &file_product_proto_msgTypes[117] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5210,7 +5385,7 @@ func (x *MutationUpdateAuthorRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use MutationUpdateAuthorRequest.ProtoReflect.Descriptor instead. func (*MutationUpdateAuthorRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{113} + return file_product_proto_rawDescGZIP(), []int{117} } func (x *MutationUpdateAuthorRequest) GetId() string { @@ -5237,7 +5412,7 @@ type MutationUpdateAuthorResponse struct { func (x *MutationUpdateAuthorResponse) Reset() { *x = MutationUpdateAuthorResponse{} - mi := &file_product_proto_msgTypes[114] + mi := &file_product_proto_msgTypes[118] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5249,7 +5424,7 @@ func (x *MutationUpdateAuthorResponse) String() string { func (*MutationUpdateAuthorResponse) ProtoMessage() {} func (x *MutationUpdateAuthorResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[114] + mi := &file_product_proto_msgTypes[118] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5262,7 +5437,7 @@ func (x *MutationUpdateAuthorResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use MutationUpdateAuthorResponse.ProtoReflect.Descriptor instead. func (*MutationUpdateAuthorResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{114} + return file_product_proto_rawDescGZIP(), []int{118} } func (x *MutationUpdateAuthorResponse) GetUpdateAuthor() *Author { @@ -5282,7 +5457,7 @@ type MutationBulkCreateAuthorsRequest struct { func (x *MutationBulkCreateAuthorsRequest) Reset() { *x = MutationBulkCreateAuthorsRequest{} - mi := &file_product_proto_msgTypes[115] + mi := &file_product_proto_msgTypes[119] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5294,7 +5469,7 @@ func (x *MutationBulkCreateAuthorsRequest) String() string { func (*MutationBulkCreateAuthorsRequest) ProtoMessage() {} func (x *MutationBulkCreateAuthorsRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[115] + mi := &file_product_proto_msgTypes[119] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5307,7 +5482,7 @@ func (x *MutationBulkCreateAuthorsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use MutationBulkCreateAuthorsRequest.ProtoReflect.Descriptor instead. func (*MutationBulkCreateAuthorsRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{115} + return file_product_proto_rawDescGZIP(), []int{119} } func (x *MutationBulkCreateAuthorsRequest) GetAuthors() *ListOfAuthorInput { @@ -5327,7 +5502,7 @@ type MutationBulkCreateAuthorsResponse struct { func (x *MutationBulkCreateAuthorsResponse) Reset() { *x = MutationBulkCreateAuthorsResponse{} - mi := &file_product_proto_msgTypes[116] + mi := &file_product_proto_msgTypes[120] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5339,7 +5514,7 @@ func (x *MutationBulkCreateAuthorsResponse) String() string { func (*MutationBulkCreateAuthorsResponse) ProtoMessage() {} func (x *MutationBulkCreateAuthorsResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[116] + mi := &file_product_proto_msgTypes[120] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5352,7 +5527,7 @@ func (x *MutationBulkCreateAuthorsResponse) ProtoReflect() protoreflect.Message // Deprecated: Use MutationBulkCreateAuthorsResponse.ProtoReflect.Descriptor instead. func (*MutationBulkCreateAuthorsResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{116} + return file_product_proto_rawDescGZIP(), []int{120} } func (x *MutationBulkCreateAuthorsResponse) GetBulkCreateAuthors() []*Author { @@ -5372,7 +5547,7 @@ type MutationBulkUpdateAuthorsRequest struct { func (x *MutationBulkUpdateAuthorsRequest) Reset() { *x = MutationBulkUpdateAuthorsRequest{} - mi := &file_product_proto_msgTypes[117] + mi := &file_product_proto_msgTypes[121] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5384,7 +5559,7 @@ func (x *MutationBulkUpdateAuthorsRequest) String() string { func (*MutationBulkUpdateAuthorsRequest) ProtoMessage() {} func (x *MutationBulkUpdateAuthorsRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[117] + mi := &file_product_proto_msgTypes[121] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5397,7 +5572,7 @@ func (x *MutationBulkUpdateAuthorsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use MutationBulkUpdateAuthorsRequest.ProtoReflect.Descriptor instead. func (*MutationBulkUpdateAuthorsRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{117} + return file_product_proto_rawDescGZIP(), []int{121} } func (x *MutationBulkUpdateAuthorsRequest) GetAuthors() *ListOfAuthorInput { @@ -5417,7 +5592,7 @@ type MutationBulkUpdateAuthorsResponse struct { func (x *MutationBulkUpdateAuthorsResponse) Reset() { *x = MutationBulkUpdateAuthorsResponse{} - mi := &file_product_proto_msgTypes[118] + mi := &file_product_proto_msgTypes[122] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5429,7 +5604,7 @@ func (x *MutationBulkUpdateAuthorsResponse) String() string { func (*MutationBulkUpdateAuthorsResponse) ProtoMessage() {} func (x *MutationBulkUpdateAuthorsResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[118] + mi := &file_product_proto_msgTypes[122] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5442,7 +5617,7 @@ func (x *MutationBulkUpdateAuthorsResponse) ProtoReflect() protoreflect.Message // Deprecated: Use MutationBulkUpdateAuthorsResponse.ProtoReflect.Descriptor instead. func (*MutationBulkUpdateAuthorsResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{118} + return file_product_proto_rawDescGZIP(), []int{122} } func (x *MutationBulkUpdateAuthorsResponse) GetBulkUpdateAuthors() []*Author { @@ -5462,7 +5637,7 @@ type MutationBulkCreateBlogPostsRequest struct { func (x *MutationBulkCreateBlogPostsRequest) Reset() { *x = MutationBulkCreateBlogPostsRequest{} - mi := &file_product_proto_msgTypes[119] + mi := &file_product_proto_msgTypes[123] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5474,7 +5649,7 @@ func (x *MutationBulkCreateBlogPostsRequest) String() string { func (*MutationBulkCreateBlogPostsRequest) ProtoMessage() {} func (x *MutationBulkCreateBlogPostsRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[119] + mi := &file_product_proto_msgTypes[123] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5487,7 +5662,7 @@ func (x *MutationBulkCreateBlogPostsRequest) ProtoReflect() protoreflect.Message // Deprecated: Use MutationBulkCreateBlogPostsRequest.ProtoReflect.Descriptor instead. func (*MutationBulkCreateBlogPostsRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{119} + return file_product_proto_rawDescGZIP(), []int{123} } func (x *MutationBulkCreateBlogPostsRequest) GetBlogPosts() *ListOfBlogPostInput { @@ -5507,7 +5682,7 @@ type MutationBulkCreateBlogPostsResponse struct { func (x *MutationBulkCreateBlogPostsResponse) Reset() { *x = MutationBulkCreateBlogPostsResponse{} - mi := &file_product_proto_msgTypes[120] + mi := &file_product_proto_msgTypes[124] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5519,7 +5694,7 @@ func (x *MutationBulkCreateBlogPostsResponse) String() string { func (*MutationBulkCreateBlogPostsResponse) ProtoMessage() {} func (x *MutationBulkCreateBlogPostsResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[120] + mi := &file_product_proto_msgTypes[124] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5532,7 +5707,7 @@ func (x *MutationBulkCreateBlogPostsResponse) ProtoReflect() protoreflect.Messag // Deprecated: Use MutationBulkCreateBlogPostsResponse.ProtoReflect.Descriptor instead. func (*MutationBulkCreateBlogPostsResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{120} + return file_product_proto_rawDescGZIP(), []int{124} } func (x *MutationBulkCreateBlogPostsResponse) GetBulkCreateBlogPosts() []*BlogPost { @@ -5552,7 +5727,7 @@ type MutationBulkUpdateBlogPostsRequest struct { func (x *MutationBulkUpdateBlogPostsRequest) Reset() { *x = MutationBulkUpdateBlogPostsRequest{} - mi := &file_product_proto_msgTypes[121] + mi := &file_product_proto_msgTypes[125] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5564,7 +5739,7 @@ func (x *MutationBulkUpdateBlogPostsRequest) String() string { func (*MutationBulkUpdateBlogPostsRequest) ProtoMessage() {} func (x *MutationBulkUpdateBlogPostsRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[121] + mi := &file_product_proto_msgTypes[125] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5577,7 +5752,7 @@ func (x *MutationBulkUpdateBlogPostsRequest) ProtoReflect() protoreflect.Message // Deprecated: Use MutationBulkUpdateBlogPostsRequest.ProtoReflect.Descriptor instead. func (*MutationBulkUpdateBlogPostsRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{121} + return file_product_proto_rawDescGZIP(), []int{125} } func (x *MutationBulkUpdateBlogPostsRequest) GetBlogPosts() *ListOfBlogPostInput { @@ -5597,7 +5772,7 @@ type MutationBulkUpdateBlogPostsResponse struct { func (x *MutationBulkUpdateBlogPostsResponse) Reset() { *x = MutationBulkUpdateBlogPostsResponse{} - mi := &file_product_proto_msgTypes[122] + mi := &file_product_proto_msgTypes[126] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5609,7 +5784,7 @@ func (x *MutationBulkUpdateBlogPostsResponse) String() string { func (*MutationBulkUpdateBlogPostsResponse) ProtoMessage() {} func (x *MutationBulkUpdateBlogPostsResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[122] + mi := &file_product_proto_msgTypes[126] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5622,7 +5797,7 @@ func (x *MutationBulkUpdateBlogPostsResponse) ProtoReflect() protoreflect.Messag // Deprecated: Use MutationBulkUpdateBlogPostsResponse.ProtoReflect.Descriptor instead. func (*MutationBulkUpdateBlogPostsResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{122} + return file_product_proto_rawDescGZIP(), []int{126} } func (x *MutationBulkUpdateBlogPostsResponse) GetBulkUpdateBlogPosts() []*BlogPost { @@ -5641,7 +5816,7 @@ type ResolveProductShippingEstimateArgs struct { func (x *ResolveProductShippingEstimateArgs) Reset() { *x = ResolveProductShippingEstimateArgs{} - mi := &file_product_proto_msgTypes[123] + mi := &file_product_proto_msgTypes[127] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5653,7 +5828,7 @@ func (x *ResolveProductShippingEstimateArgs) String() string { func (*ResolveProductShippingEstimateArgs) ProtoMessage() {} func (x *ResolveProductShippingEstimateArgs) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[123] + mi := &file_product_proto_msgTypes[127] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5666,7 +5841,7 @@ func (x *ResolveProductShippingEstimateArgs) ProtoReflect() protoreflect.Message // Deprecated: Use ResolveProductShippingEstimateArgs.ProtoReflect.Descriptor instead. func (*ResolveProductShippingEstimateArgs) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{123} + return file_product_proto_rawDescGZIP(), []int{127} } func (x *ResolveProductShippingEstimateArgs) GetInput() *ShippingEstimateInput { @@ -5686,7 +5861,7 @@ type ResolveProductShippingEstimateContext struct { func (x *ResolveProductShippingEstimateContext) Reset() { *x = ResolveProductShippingEstimateContext{} - mi := &file_product_proto_msgTypes[124] + mi := &file_product_proto_msgTypes[128] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5698,7 +5873,7 @@ func (x *ResolveProductShippingEstimateContext) String() string { func (*ResolveProductShippingEstimateContext) ProtoMessage() {} func (x *ResolveProductShippingEstimateContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[124] + mi := &file_product_proto_msgTypes[128] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5711,7 +5886,7 @@ func (x *ResolveProductShippingEstimateContext) ProtoReflect() protoreflect.Mess // Deprecated: Use ResolveProductShippingEstimateContext.ProtoReflect.Descriptor instead. func (*ResolveProductShippingEstimateContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{124} + return file_product_proto_rawDescGZIP(), []int{128} } func (x *ResolveProductShippingEstimateContext) GetId() string { @@ -5740,7 +5915,7 @@ type ResolveProductShippingEstimateRequest struct { func (x *ResolveProductShippingEstimateRequest) Reset() { *x = ResolveProductShippingEstimateRequest{} - mi := &file_product_proto_msgTypes[125] + mi := &file_product_proto_msgTypes[129] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5752,7 +5927,7 @@ func (x *ResolveProductShippingEstimateRequest) String() string { func (*ResolveProductShippingEstimateRequest) ProtoMessage() {} func (x *ResolveProductShippingEstimateRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[125] + mi := &file_product_proto_msgTypes[129] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5765,7 +5940,7 @@ func (x *ResolveProductShippingEstimateRequest) ProtoReflect() protoreflect.Mess // Deprecated: Use ResolveProductShippingEstimateRequest.ProtoReflect.Descriptor instead. func (*ResolveProductShippingEstimateRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{125} + return file_product_proto_rawDescGZIP(), []int{129} } func (x *ResolveProductShippingEstimateRequest) GetContext() []*ResolveProductShippingEstimateContext { @@ -5791,7 +5966,7 @@ type ResolveProductShippingEstimateResult struct { func (x *ResolveProductShippingEstimateResult) Reset() { *x = ResolveProductShippingEstimateResult{} - mi := &file_product_proto_msgTypes[126] + mi := &file_product_proto_msgTypes[130] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5803,7 +5978,7 @@ func (x *ResolveProductShippingEstimateResult) String() string { func (*ResolveProductShippingEstimateResult) ProtoMessage() {} func (x *ResolveProductShippingEstimateResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[126] + mi := &file_product_proto_msgTypes[130] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5816,7 +5991,7 @@ func (x *ResolveProductShippingEstimateResult) ProtoReflect() protoreflect.Messa // Deprecated: Use ResolveProductShippingEstimateResult.ProtoReflect.Descriptor instead. func (*ResolveProductShippingEstimateResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{126} + return file_product_proto_rawDescGZIP(), []int{130} } func (x *ResolveProductShippingEstimateResult) GetShippingEstimate() float64 { @@ -5835,7 +6010,7 @@ type ResolveProductShippingEstimateResponse struct { func (x *ResolveProductShippingEstimateResponse) Reset() { *x = ResolveProductShippingEstimateResponse{} - mi := &file_product_proto_msgTypes[127] + mi := &file_product_proto_msgTypes[131] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5847,7 +6022,7 @@ func (x *ResolveProductShippingEstimateResponse) String() string { func (*ResolveProductShippingEstimateResponse) ProtoMessage() {} func (x *ResolveProductShippingEstimateResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[127] + mi := &file_product_proto_msgTypes[131] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5860,7 +6035,7 @@ func (x *ResolveProductShippingEstimateResponse) ProtoReflect() protoreflect.Mes // Deprecated: Use ResolveProductShippingEstimateResponse.ProtoReflect.Descriptor instead. func (*ResolveProductShippingEstimateResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{127} + return file_product_proto_rawDescGZIP(), []int{131} } func (x *ResolveProductShippingEstimateResponse) GetResult() []*ResolveProductShippingEstimateResult { @@ -5879,7 +6054,7 @@ type ResolveProductRecommendedCategoryArgs struct { func (x *ResolveProductRecommendedCategoryArgs) Reset() { *x = ResolveProductRecommendedCategoryArgs{} - mi := &file_product_proto_msgTypes[128] + mi := &file_product_proto_msgTypes[132] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5891,7 +6066,7 @@ func (x *ResolveProductRecommendedCategoryArgs) String() string { func (*ResolveProductRecommendedCategoryArgs) ProtoMessage() {} func (x *ResolveProductRecommendedCategoryArgs) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[128] + mi := &file_product_proto_msgTypes[132] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5904,7 +6079,7 @@ func (x *ResolveProductRecommendedCategoryArgs) ProtoReflect() protoreflect.Mess // Deprecated: Use ResolveProductRecommendedCategoryArgs.ProtoReflect.Descriptor instead. func (*ResolveProductRecommendedCategoryArgs) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{128} + return file_product_proto_rawDescGZIP(), []int{132} } func (x *ResolveProductRecommendedCategoryArgs) GetMaxPrice() int32 { @@ -5925,7 +6100,7 @@ type ResolveProductRecommendedCategoryContext struct { func (x *ResolveProductRecommendedCategoryContext) Reset() { *x = ResolveProductRecommendedCategoryContext{} - mi := &file_product_proto_msgTypes[129] + mi := &file_product_proto_msgTypes[133] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5937,7 +6112,7 @@ func (x *ResolveProductRecommendedCategoryContext) String() string { func (*ResolveProductRecommendedCategoryContext) ProtoMessage() {} func (x *ResolveProductRecommendedCategoryContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[129] + mi := &file_product_proto_msgTypes[133] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5950,7 +6125,7 @@ func (x *ResolveProductRecommendedCategoryContext) ProtoReflect() protoreflect.M // Deprecated: Use ResolveProductRecommendedCategoryContext.ProtoReflect.Descriptor instead. func (*ResolveProductRecommendedCategoryContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{129} + return file_product_proto_rawDescGZIP(), []int{133} } func (x *ResolveProductRecommendedCategoryContext) GetId() string { @@ -5986,7 +6161,7 @@ type ResolveProductRecommendedCategoryRequest struct { func (x *ResolveProductRecommendedCategoryRequest) Reset() { *x = ResolveProductRecommendedCategoryRequest{} - mi := &file_product_proto_msgTypes[130] + mi := &file_product_proto_msgTypes[134] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5998,7 +6173,7 @@ func (x *ResolveProductRecommendedCategoryRequest) String() string { func (*ResolveProductRecommendedCategoryRequest) ProtoMessage() {} func (x *ResolveProductRecommendedCategoryRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[130] + mi := &file_product_proto_msgTypes[134] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6011,7 +6186,7 @@ func (x *ResolveProductRecommendedCategoryRequest) ProtoReflect() protoreflect.M // Deprecated: Use ResolveProductRecommendedCategoryRequest.ProtoReflect.Descriptor instead. func (*ResolveProductRecommendedCategoryRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{130} + return file_product_proto_rawDescGZIP(), []int{134} } func (x *ResolveProductRecommendedCategoryRequest) GetContext() []*ResolveProductRecommendedCategoryContext { @@ -6037,7 +6212,7 @@ type ResolveProductRecommendedCategoryResult struct { func (x *ResolveProductRecommendedCategoryResult) Reset() { *x = ResolveProductRecommendedCategoryResult{} - mi := &file_product_proto_msgTypes[131] + mi := &file_product_proto_msgTypes[135] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6049,7 +6224,7 @@ func (x *ResolveProductRecommendedCategoryResult) String() string { func (*ResolveProductRecommendedCategoryResult) ProtoMessage() {} func (x *ResolveProductRecommendedCategoryResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[131] + mi := &file_product_proto_msgTypes[135] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6062,7 +6237,7 @@ func (x *ResolveProductRecommendedCategoryResult) ProtoReflect() protoreflect.Me // Deprecated: Use ResolveProductRecommendedCategoryResult.ProtoReflect.Descriptor instead. func (*ResolveProductRecommendedCategoryResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{131} + return file_product_proto_rawDescGZIP(), []int{135} } func (x *ResolveProductRecommendedCategoryResult) GetRecommendedCategory() *Category { @@ -6081,7 +6256,7 @@ type ResolveProductRecommendedCategoryResponse struct { func (x *ResolveProductRecommendedCategoryResponse) Reset() { *x = ResolveProductRecommendedCategoryResponse{} - mi := &file_product_proto_msgTypes[132] + mi := &file_product_proto_msgTypes[136] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6093,7 +6268,7 @@ func (x *ResolveProductRecommendedCategoryResponse) String() string { func (*ResolveProductRecommendedCategoryResponse) ProtoMessage() {} func (x *ResolveProductRecommendedCategoryResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[132] + mi := &file_product_proto_msgTypes[136] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6106,7 +6281,7 @@ func (x *ResolveProductRecommendedCategoryResponse) ProtoReflect() protoreflect. // Deprecated: Use ResolveProductRecommendedCategoryResponse.ProtoReflect.Descriptor instead. func (*ResolveProductRecommendedCategoryResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{132} + return file_product_proto_rawDescGZIP(), []int{136} } func (x *ResolveProductRecommendedCategoryResponse) GetResult() []*ResolveProductRecommendedCategoryResult { @@ -6125,7 +6300,7 @@ type ResolveProductMascotRecommendationArgs struct { func (x *ResolveProductMascotRecommendationArgs) Reset() { *x = ResolveProductMascotRecommendationArgs{} - mi := &file_product_proto_msgTypes[133] + mi := &file_product_proto_msgTypes[137] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6137,7 +6312,7 @@ func (x *ResolveProductMascotRecommendationArgs) String() string { func (*ResolveProductMascotRecommendationArgs) ProtoMessage() {} func (x *ResolveProductMascotRecommendationArgs) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[133] + mi := &file_product_proto_msgTypes[137] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6150,7 +6325,7 @@ func (x *ResolveProductMascotRecommendationArgs) ProtoReflect() protoreflect.Mes // Deprecated: Use ResolveProductMascotRecommendationArgs.ProtoReflect.Descriptor instead. func (*ResolveProductMascotRecommendationArgs) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{133} + return file_product_proto_rawDescGZIP(), []int{137} } func (x *ResolveProductMascotRecommendationArgs) GetIncludeDetails() bool { @@ -6170,7 +6345,7 @@ type ResolveProductMascotRecommendationContext struct { func (x *ResolveProductMascotRecommendationContext) Reset() { *x = ResolveProductMascotRecommendationContext{} - mi := &file_product_proto_msgTypes[134] + mi := &file_product_proto_msgTypes[138] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6182,7 +6357,7 @@ func (x *ResolveProductMascotRecommendationContext) String() string { func (*ResolveProductMascotRecommendationContext) ProtoMessage() {} func (x *ResolveProductMascotRecommendationContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[134] + mi := &file_product_proto_msgTypes[138] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6195,7 +6370,7 @@ func (x *ResolveProductMascotRecommendationContext) ProtoReflect() protoreflect. // Deprecated: Use ResolveProductMascotRecommendationContext.ProtoReflect.Descriptor instead. func (*ResolveProductMascotRecommendationContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{134} + return file_product_proto_rawDescGZIP(), []int{138} } func (x *ResolveProductMascotRecommendationContext) GetId() string { @@ -6224,7 +6399,7 @@ type ResolveProductMascotRecommendationRequest struct { func (x *ResolveProductMascotRecommendationRequest) Reset() { *x = ResolveProductMascotRecommendationRequest{} - mi := &file_product_proto_msgTypes[135] + mi := &file_product_proto_msgTypes[139] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6236,7 +6411,7 @@ func (x *ResolveProductMascotRecommendationRequest) String() string { func (*ResolveProductMascotRecommendationRequest) ProtoMessage() {} func (x *ResolveProductMascotRecommendationRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[135] + mi := &file_product_proto_msgTypes[139] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6249,7 +6424,7 @@ func (x *ResolveProductMascotRecommendationRequest) ProtoReflect() protoreflect. // Deprecated: Use ResolveProductMascotRecommendationRequest.ProtoReflect.Descriptor instead. func (*ResolveProductMascotRecommendationRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{135} + return file_product_proto_rawDescGZIP(), []int{139} } func (x *ResolveProductMascotRecommendationRequest) GetContext() []*ResolveProductMascotRecommendationContext { @@ -6275,7 +6450,7 @@ type ResolveProductMascotRecommendationResult struct { func (x *ResolveProductMascotRecommendationResult) Reset() { *x = ResolveProductMascotRecommendationResult{} - mi := &file_product_proto_msgTypes[136] + mi := &file_product_proto_msgTypes[140] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6287,7 +6462,7 @@ func (x *ResolveProductMascotRecommendationResult) String() string { func (*ResolveProductMascotRecommendationResult) ProtoMessage() {} func (x *ResolveProductMascotRecommendationResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[136] + mi := &file_product_proto_msgTypes[140] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6300,7 +6475,7 @@ func (x *ResolveProductMascotRecommendationResult) ProtoReflect() protoreflect.M // Deprecated: Use ResolveProductMascotRecommendationResult.ProtoReflect.Descriptor instead. func (*ResolveProductMascotRecommendationResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{136} + return file_product_proto_rawDescGZIP(), []int{140} } func (x *ResolveProductMascotRecommendationResult) GetMascotRecommendation() *Animal { @@ -6319,7 +6494,7 @@ type ResolveProductMascotRecommendationResponse struct { func (x *ResolveProductMascotRecommendationResponse) Reset() { *x = ResolveProductMascotRecommendationResponse{} - mi := &file_product_proto_msgTypes[137] + mi := &file_product_proto_msgTypes[141] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6331,7 +6506,7 @@ func (x *ResolveProductMascotRecommendationResponse) String() string { func (*ResolveProductMascotRecommendationResponse) ProtoMessage() {} func (x *ResolveProductMascotRecommendationResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[137] + mi := &file_product_proto_msgTypes[141] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6344,7 +6519,7 @@ func (x *ResolveProductMascotRecommendationResponse) ProtoReflect() protoreflect // Deprecated: Use ResolveProductMascotRecommendationResponse.ProtoReflect.Descriptor instead. func (*ResolveProductMascotRecommendationResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{137} + return file_product_proto_rawDescGZIP(), []int{141} } func (x *ResolveProductMascotRecommendationResponse) GetResult() []*ResolveProductMascotRecommendationResult { @@ -6363,7 +6538,7 @@ type ResolveProductStockStatusArgs struct { func (x *ResolveProductStockStatusArgs) Reset() { *x = ResolveProductStockStatusArgs{} - mi := &file_product_proto_msgTypes[138] + mi := &file_product_proto_msgTypes[142] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6375,7 +6550,7 @@ func (x *ResolveProductStockStatusArgs) String() string { func (*ResolveProductStockStatusArgs) ProtoMessage() {} func (x *ResolveProductStockStatusArgs) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[138] + mi := &file_product_proto_msgTypes[142] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6388,7 +6563,7 @@ func (x *ResolveProductStockStatusArgs) ProtoReflect() protoreflect.Message { // Deprecated: Use ResolveProductStockStatusArgs.ProtoReflect.Descriptor instead. func (*ResolveProductStockStatusArgs) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{138} + return file_product_proto_rawDescGZIP(), []int{142} } func (x *ResolveProductStockStatusArgs) GetCheckAvailability() bool { @@ -6409,7 +6584,7 @@ type ResolveProductStockStatusContext struct { func (x *ResolveProductStockStatusContext) Reset() { *x = ResolveProductStockStatusContext{} - mi := &file_product_proto_msgTypes[139] + mi := &file_product_proto_msgTypes[143] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6421,7 +6596,7 @@ func (x *ResolveProductStockStatusContext) String() string { func (*ResolveProductStockStatusContext) ProtoMessage() {} func (x *ResolveProductStockStatusContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[139] + mi := &file_product_proto_msgTypes[143] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6434,7 +6609,7 @@ func (x *ResolveProductStockStatusContext) ProtoReflect() protoreflect.Message { // Deprecated: Use ResolveProductStockStatusContext.ProtoReflect.Descriptor instead. func (*ResolveProductStockStatusContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{139} + return file_product_proto_rawDescGZIP(), []int{143} } func (x *ResolveProductStockStatusContext) GetId() string { @@ -6470,7 +6645,7 @@ type ResolveProductStockStatusRequest struct { func (x *ResolveProductStockStatusRequest) Reset() { *x = ResolveProductStockStatusRequest{} - mi := &file_product_proto_msgTypes[140] + mi := &file_product_proto_msgTypes[144] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6482,7 +6657,7 @@ func (x *ResolveProductStockStatusRequest) String() string { func (*ResolveProductStockStatusRequest) ProtoMessage() {} func (x *ResolveProductStockStatusRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[140] + mi := &file_product_proto_msgTypes[144] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6495,7 +6670,7 @@ func (x *ResolveProductStockStatusRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ResolveProductStockStatusRequest.ProtoReflect.Descriptor instead. func (*ResolveProductStockStatusRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{140} + return file_product_proto_rawDescGZIP(), []int{144} } func (x *ResolveProductStockStatusRequest) GetContext() []*ResolveProductStockStatusContext { @@ -6521,7 +6696,7 @@ type ResolveProductStockStatusResult struct { func (x *ResolveProductStockStatusResult) Reset() { *x = ResolveProductStockStatusResult{} - mi := &file_product_proto_msgTypes[141] + mi := &file_product_proto_msgTypes[145] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6533,7 +6708,7 @@ func (x *ResolveProductStockStatusResult) String() string { func (*ResolveProductStockStatusResult) ProtoMessage() {} func (x *ResolveProductStockStatusResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[141] + mi := &file_product_proto_msgTypes[145] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6546,7 +6721,7 @@ func (x *ResolveProductStockStatusResult) ProtoReflect() protoreflect.Message { // Deprecated: Use ResolveProductStockStatusResult.ProtoReflect.Descriptor instead. func (*ResolveProductStockStatusResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{141} + return file_product_proto_rawDescGZIP(), []int{145} } func (x *ResolveProductStockStatusResult) GetStockStatus() *ActionResult { @@ -6565,7 +6740,7 @@ type ResolveProductStockStatusResponse struct { func (x *ResolveProductStockStatusResponse) Reset() { *x = ResolveProductStockStatusResponse{} - mi := &file_product_proto_msgTypes[142] + mi := &file_product_proto_msgTypes[146] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6577,7 +6752,7 @@ func (x *ResolveProductStockStatusResponse) String() string { func (*ResolveProductStockStatusResponse) ProtoMessage() {} func (x *ResolveProductStockStatusResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[142] + mi := &file_product_proto_msgTypes[146] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6590,7 +6765,7 @@ func (x *ResolveProductStockStatusResponse) ProtoReflect() protoreflect.Message // Deprecated: Use ResolveProductStockStatusResponse.ProtoReflect.Descriptor instead. func (*ResolveProductStockStatusResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{142} + return file_product_proto_rawDescGZIP(), []int{146} } func (x *ResolveProductStockStatusResponse) GetResult() []*ResolveProductStockStatusResult { @@ -6609,7 +6784,7 @@ type ResolveProductProductDetailsArgs struct { func (x *ResolveProductProductDetailsArgs) Reset() { *x = ResolveProductProductDetailsArgs{} - mi := &file_product_proto_msgTypes[143] + mi := &file_product_proto_msgTypes[147] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6621,7 +6796,7 @@ func (x *ResolveProductProductDetailsArgs) String() string { func (*ResolveProductProductDetailsArgs) ProtoMessage() {} func (x *ResolveProductProductDetailsArgs) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[143] + mi := &file_product_proto_msgTypes[147] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6634,7 +6809,7 @@ func (x *ResolveProductProductDetailsArgs) ProtoReflect() protoreflect.Message { // Deprecated: Use ResolveProductProductDetailsArgs.ProtoReflect.Descriptor instead. func (*ResolveProductProductDetailsArgs) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{143} + return file_product_proto_rawDescGZIP(), []int{147} } func (x *ResolveProductProductDetailsArgs) GetIncludeExtended() bool { @@ -6655,7 +6830,7 @@ type ResolveProductProductDetailsContext struct { func (x *ResolveProductProductDetailsContext) Reset() { *x = ResolveProductProductDetailsContext{} - mi := &file_product_proto_msgTypes[144] + mi := &file_product_proto_msgTypes[148] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6667,7 +6842,7 @@ func (x *ResolveProductProductDetailsContext) String() string { func (*ResolveProductProductDetailsContext) ProtoMessage() {} func (x *ResolveProductProductDetailsContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[144] + mi := &file_product_proto_msgTypes[148] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6680,7 +6855,7 @@ func (x *ResolveProductProductDetailsContext) ProtoReflect() protoreflect.Messag // Deprecated: Use ResolveProductProductDetailsContext.ProtoReflect.Descriptor instead. func (*ResolveProductProductDetailsContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{144} + return file_product_proto_rawDescGZIP(), []int{148} } func (x *ResolveProductProductDetailsContext) GetId() string { @@ -6716,7 +6891,7 @@ type ResolveProductProductDetailsRequest struct { func (x *ResolveProductProductDetailsRequest) Reset() { *x = ResolveProductProductDetailsRequest{} - mi := &file_product_proto_msgTypes[145] + mi := &file_product_proto_msgTypes[149] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6728,7 +6903,7 @@ func (x *ResolveProductProductDetailsRequest) String() string { func (*ResolveProductProductDetailsRequest) ProtoMessage() {} func (x *ResolveProductProductDetailsRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[145] + mi := &file_product_proto_msgTypes[149] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6741,7 +6916,7 @@ func (x *ResolveProductProductDetailsRequest) ProtoReflect() protoreflect.Messag // Deprecated: Use ResolveProductProductDetailsRequest.ProtoReflect.Descriptor instead. func (*ResolveProductProductDetailsRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{145} + return file_product_proto_rawDescGZIP(), []int{149} } func (x *ResolveProductProductDetailsRequest) GetContext() []*ResolveProductProductDetailsContext { @@ -6767,7 +6942,7 @@ type ResolveProductProductDetailsResult struct { func (x *ResolveProductProductDetailsResult) Reset() { *x = ResolveProductProductDetailsResult{} - mi := &file_product_proto_msgTypes[146] + mi := &file_product_proto_msgTypes[150] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6779,7 +6954,7 @@ func (x *ResolveProductProductDetailsResult) String() string { func (*ResolveProductProductDetailsResult) ProtoMessage() {} func (x *ResolveProductProductDetailsResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[146] + mi := &file_product_proto_msgTypes[150] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6792,7 +6967,7 @@ func (x *ResolveProductProductDetailsResult) ProtoReflect() protoreflect.Message // Deprecated: Use ResolveProductProductDetailsResult.ProtoReflect.Descriptor instead. func (*ResolveProductProductDetailsResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{146} + return file_product_proto_rawDescGZIP(), []int{150} } func (x *ResolveProductProductDetailsResult) GetProductDetails() *ProductDetails { @@ -6811,7 +6986,7 @@ type ResolveProductProductDetailsResponse struct { func (x *ResolveProductProductDetailsResponse) Reset() { *x = ResolveProductProductDetailsResponse{} - mi := &file_product_proto_msgTypes[147] + mi := &file_product_proto_msgTypes[151] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6823,7 +6998,7 @@ func (x *ResolveProductProductDetailsResponse) String() string { func (*ResolveProductProductDetailsResponse) ProtoMessage() {} func (x *ResolveProductProductDetailsResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[147] + mi := &file_product_proto_msgTypes[151] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6836,7 +7011,7 @@ func (x *ResolveProductProductDetailsResponse) ProtoReflect() protoreflect.Messa // Deprecated: Use ResolveProductProductDetailsResponse.ProtoReflect.Descriptor instead. func (*ResolveProductProductDetailsResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{147} + return file_product_proto_rawDescGZIP(), []int{151} } func (x *ResolveProductProductDetailsResponse) GetResult() []*ResolveProductProductDetailsResult { @@ -6855,7 +7030,7 @@ type ResolveStorageStorageStatusArgs struct { func (x *ResolveStorageStorageStatusArgs) Reset() { *x = ResolveStorageStorageStatusArgs{} - mi := &file_product_proto_msgTypes[148] + mi := &file_product_proto_msgTypes[152] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6867,7 +7042,7 @@ func (x *ResolveStorageStorageStatusArgs) String() string { func (*ResolveStorageStorageStatusArgs) ProtoMessage() {} func (x *ResolveStorageStorageStatusArgs) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[148] + mi := &file_product_proto_msgTypes[152] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6880,7 +7055,7 @@ func (x *ResolveStorageStorageStatusArgs) ProtoReflect() protoreflect.Message { // Deprecated: Use ResolveStorageStorageStatusArgs.ProtoReflect.Descriptor instead. func (*ResolveStorageStorageStatusArgs) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{148} + return file_product_proto_rawDescGZIP(), []int{152} } func (x *ResolveStorageStorageStatusArgs) GetCheckHealth() bool { @@ -6900,7 +7075,7 @@ type ResolveStorageStorageStatusContext struct { func (x *ResolveStorageStorageStatusContext) Reset() { *x = ResolveStorageStorageStatusContext{} - mi := &file_product_proto_msgTypes[149] + mi := &file_product_proto_msgTypes[153] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6912,7 +7087,7 @@ func (x *ResolveStorageStorageStatusContext) String() string { func (*ResolveStorageStorageStatusContext) ProtoMessage() {} func (x *ResolveStorageStorageStatusContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[149] + mi := &file_product_proto_msgTypes[153] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6925,7 +7100,7 @@ func (x *ResolveStorageStorageStatusContext) ProtoReflect() protoreflect.Message // Deprecated: Use ResolveStorageStorageStatusContext.ProtoReflect.Descriptor instead. func (*ResolveStorageStorageStatusContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{149} + return file_product_proto_rawDescGZIP(), []int{153} } func (x *ResolveStorageStorageStatusContext) GetId() string { @@ -6954,7 +7129,7 @@ type ResolveStorageStorageStatusRequest struct { func (x *ResolveStorageStorageStatusRequest) Reset() { *x = ResolveStorageStorageStatusRequest{} - mi := &file_product_proto_msgTypes[150] + mi := &file_product_proto_msgTypes[154] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6966,7 +7141,7 @@ func (x *ResolveStorageStorageStatusRequest) String() string { func (*ResolveStorageStorageStatusRequest) ProtoMessage() {} func (x *ResolveStorageStorageStatusRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[150] + mi := &file_product_proto_msgTypes[154] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6979,7 +7154,7 @@ func (x *ResolveStorageStorageStatusRequest) ProtoReflect() protoreflect.Message // Deprecated: Use ResolveStorageStorageStatusRequest.ProtoReflect.Descriptor instead. func (*ResolveStorageStorageStatusRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{150} + return file_product_proto_rawDescGZIP(), []int{154} } func (x *ResolveStorageStorageStatusRequest) GetContext() []*ResolveStorageStorageStatusContext { @@ -7005,7 +7180,7 @@ type ResolveStorageStorageStatusResult struct { func (x *ResolveStorageStorageStatusResult) Reset() { *x = ResolveStorageStorageStatusResult{} - mi := &file_product_proto_msgTypes[151] + mi := &file_product_proto_msgTypes[155] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7017,7 +7192,7 @@ func (x *ResolveStorageStorageStatusResult) String() string { func (*ResolveStorageStorageStatusResult) ProtoMessage() {} func (x *ResolveStorageStorageStatusResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[151] + mi := &file_product_proto_msgTypes[155] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7030,7 +7205,7 @@ func (x *ResolveStorageStorageStatusResult) ProtoReflect() protoreflect.Message // Deprecated: Use ResolveStorageStorageStatusResult.ProtoReflect.Descriptor instead. func (*ResolveStorageStorageStatusResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{151} + return file_product_proto_rawDescGZIP(), []int{155} } func (x *ResolveStorageStorageStatusResult) GetStorageStatus() *ActionResult { @@ -7049,7 +7224,7 @@ type ResolveStorageStorageStatusResponse struct { func (x *ResolveStorageStorageStatusResponse) Reset() { *x = ResolveStorageStorageStatusResponse{} - mi := &file_product_proto_msgTypes[152] + mi := &file_product_proto_msgTypes[156] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7061,7 +7236,7 @@ func (x *ResolveStorageStorageStatusResponse) String() string { func (*ResolveStorageStorageStatusResponse) ProtoMessage() {} func (x *ResolveStorageStorageStatusResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[152] + mi := &file_product_proto_msgTypes[156] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7074,7 +7249,7 @@ func (x *ResolveStorageStorageStatusResponse) ProtoReflect() protoreflect.Messag // Deprecated: Use ResolveStorageStorageStatusResponse.ProtoReflect.Descriptor instead. func (*ResolveStorageStorageStatusResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{152} + return file_product_proto_rawDescGZIP(), []int{156} } func (x *ResolveStorageStorageStatusResponse) GetResult() []*ResolveStorageStorageStatusResult { @@ -7093,7 +7268,7 @@ type ResolveStorageLinkedStoragesArgs struct { func (x *ResolveStorageLinkedStoragesArgs) Reset() { *x = ResolveStorageLinkedStoragesArgs{} - mi := &file_product_proto_msgTypes[153] + mi := &file_product_proto_msgTypes[157] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7105,7 +7280,7 @@ func (x *ResolveStorageLinkedStoragesArgs) String() string { func (*ResolveStorageLinkedStoragesArgs) ProtoMessage() {} func (x *ResolveStorageLinkedStoragesArgs) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[153] + mi := &file_product_proto_msgTypes[157] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7118,7 +7293,7 @@ func (x *ResolveStorageLinkedStoragesArgs) ProtoReflect() protoreflect.Message { // Deprecated: Use ResolveStorageLinkedStoragesArgs.ProtoReflect.Descriptor instead. func (*ResolveStorageLinkedStoragesArgs) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{153} + return file_product_proto_rawDescGZIP(), []int{157} } func (x *ResolveStorageLinkedStoragesArgs) GetDepth() int32 { @@ -7139,7 +7314,7 @@ type ResolveStorageLinkedStoragesContext struct { func (x *ResolveStorageLinkedStoragesContext) Reset() { *x = ResolveStorageLinkedStoragesContext{} - mi := &file_product_proto_msgTypes[154] + mi := &file_product_proto_msgTypes[158] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7151,7 +7326,7 @@ func (x *ResolveStorageLinkedStoragesContext) String() string { func (*ResolveStorageLinkedStoragesContext) ProtoMessage() {} func (x *ResolveStorageLinkedStoragesContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[154] + mi := &file_product_proto_msgTypes[158] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7164,7 +7339,7 @@ func (x *ResolveStorageLinkedStoragesContext) ProtoReflect() protoreflect.Messag // Deprecated: Use ResolveStorageLinkedStoragesContext.ProtoReflect.Descriptor instead. func (*ResolveStorageLinkedStoragesContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{154} + return file_product_proto_rawDescGZIP(), []int{158} } func (x *ResolveStorageLinkedStoragesContext) GetId() string { @@ -7200,7 +7375,7 @@ type ResolveStorageLinkedStoragesRequest struct { func (x *ResolveStorageLinkedStoragesRequest) Reset() { *x = ResolveStorageLinkedStoragesRequest{} - mi := &file_product_proto_msgTypes[155] + mi := &file_product_proto_msgTypes[159] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7212,7 +7387,7 @@ func (x *ResolveStorageLinkedStoragesRequest) String() string { func (*ResolveStorageLinkedStoragesRequest) ProtoMessage() {} func (x *ResolveStorageLinkedStoragesRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[155] + mi := &file_product_proto_msgTypes[159] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7225,7 +7400,7 @@ func (x *ResolveStorageLinkedStoragesRequest) ProtoReflect() protoreflect.Messag // Deprecated: Use ResolveStorageLinkedStoragesRequest.ProtoReflect.Descriptor instead. func (*ResolveStorageLinkedStoragesRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{155} + return file_product_proto_rawDescGZIP(), []int{159} } func (x *ResolveStorageLinkedStoragesRequest) GetContext() []*ResolveStorageLinkedStoragesContext { @@ -7251,7 +7426,7 @@ type ResolveStorageLinkedStoragesResult struct { func (x *ResolveStorageLinkedStoragesResult) Reset() { *x = ResolveStorageLinkedStoragesResult{} - mi := &file_product_proto_msgTypes[156] + mi := &file_product_proto_msgTypes[160] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7263,7 +7438,7 @@ func (x *ResolveStorageLinkedStoragesResult) String() string { func (*ResolveStorageLinkedStoragesResult) ProtoMessage() {} func (x *ResolveStorageLinkedStoragesResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[156] + mi := &file_product_proto_msgTypes[160] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7276,7 +7451,7 @@ func (x *ResolveStorageLinkedStoragesResult) ProtoReflect() protoreflect.Message // Deprecated: Use ResolveStorageLinkedStoragesResult.ProtoReflect.Descriptor instead. func (*ResolveStorageLinkedStoragesResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{156} + return file_product_proto_rawDescGZIP(), []int{160} } func (x *ResolveStorageLinkedStoragesResult) GetLinkedStorages() []*Storage { @@ -7295,7 +7470,7 @@ type ResolveStorageLinkedStoragesResponse struct { func (x *ResolveStorageLinkedStoragesResponse) Reset() { *x = ResolveStorageLinkedStoragesResponse{} - mi := &file_product_proto_msgTypes[157] + mi := &file_product_proto_msgTypes[161] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7307,7 +7482,7 @@ func (x *ResolveStorageLinkedStoragesResponse) String() string { func (*ResolveStorageLinkedStoragesResponse) ProtoMessage() {} func (x *ResolveStorageLinkedStoragesResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[157] + mi := &file_product_proto_msgTypes[161] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7320,7 +7495,7 @@ func (x *ResolveStorageLinkedStoragesResponse) ProtoReflect() protoreflect.Messa // Deprecated: Use ResolveStorageLinkedStoragesResponse.ProtoReflect.Descriptor instead. func (*ResolveStorageLinkedStoragesResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{157} + return file_product_proto_rawDescGZIP(), []int{161} } func (x *ResolveStorageLinkedStoragesResponse) GetResult() []*ResolveStorageLinkedStoragesResult { @@ -7339,7 +7514,7 @@ type ResolveStorageNearbyStoragesArgs struct { func (x *ResolveStorageNearbyStoragesArgs) Reset() { *x = ResolveStorageNearbyStoragesArgs{} - mi := &file_product_proto_msgTypes[158] + mi := &file_product_proto_msgTypes[162] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7351,7 +7526,7 @@ func (x *ResolveStorageNearbyStoragesArgs) String() string { func (*ResolveStorageNearbyStoragesArgs) ProtoMessage() {} func (x *ResolveStorageNearbyStoragesArgs) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[158] + mi := &file_product_proto_msgTypes[162] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7364,7 +7539,7 @@ func (x *ResolveStorageNearbyStoragesArgs) ProtoReflect() protoreflect.Message { // Deprecated: Use ResolveStorageNearbyStoragesArgs.ProtoReflect.Descriptor instead. func (*ResolveStorageNearbyStoragesArgs) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{158} + return file_product_proto_rawDescGZIP(), []int{162} } func (x *ResolveStorageNearbyStoragesArgs) GetRadius() *wrapperspb.Int32Value { @@ -7384,7 +7559,7 @@ type ResolveStorageNearbyStoragesContext struct { func (x *ResolveStorageNearbyStoragesContext) Reset() { *x = ResolveStorageNearbyStoragesContext{} - mi := &file_product_proto_msgTypes[159] + mi := &file_product_proto_msgTypes[163] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7396,7 +7571,7 @@ func (x *ResolveStorageNearbyStoragesContext) String() string { func (*ResolveStorageNearbyStoragesContext) ProtoMessage() {} func (x *ResolveStorageNearbyStoragesContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[159] + mi := &file_product_proto_msgTypes[163] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7409,7 +7584,7 @@ func (x *ResolveStorageNearbyStoragesContext) ProtoReflect() protoreflect.Messag // Deprecated: Use ResolveStorageNearbyStoragesContext.ProtoReflect.Descriptor instead. func (*ResolveStorageNearbyStoragesContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{159} + return file_product_proto_rawDescGZIP(), []int{163} } func (x *ResolveStorageNearbyStoragesContext) GetId() string { @@ -7438,7 +7613,7 @@ type ResolveStorageNearbyStoragesRequest struct { func (x *ResolveStorageNearbyStoragesRequest) Reset() { *x = ResolveStorageNearbyStoragesRequest{} - mi := &file_product_proto_msgTypes[160] + mi := &file_product_proto_msgTypes[164] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7450,7 +7625,7 @@ func (x *ResolveStorageNearbyStoragesRequest) String() string { func (*ResolveStorageNearbyStoragesRequest) ProtoMessage() {} func (x *ResolveStorageNearbyStoragesRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[160] + mi := &file_product_proto_msgTypes[164] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7463,7 +7638,7 @@ func (x *ResolveStorageNearbyStoragesRequest) ProtoReflect() protoreflect.Messag // Deprecated: Use ResolveStorageNearbyStoragesRequest.ProtoReflect.Descriptor instead. func (*ResolveStorageNearbyStoragesRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{160} + return file_product_proto_rawDescGZIP(), []int{164} } func (x *ResolveStorageNearbyStoragesRequest) GetContext() []*ResolveStorageNearbyStoragesContext { @@ -7489,7 +7664,7 @@ type ResolveStorageNearbyStoragesResult struct { func (x *ResolveStorageNearbyStoragesResult) Reset() { *x = ResolveStorageNearbyStoragesResult{} - mi := &file_product_proto_msgTypes[161] + mi := &file_product_proto_msgTypes[165] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7501,7 +7676,7 @@ func (x *ResolveStorageNearbyStoragesResult) String() string { func (*ResolveStorageNearbyStoragesResult) ProtoMessage() {} func (x *ResolveStorageNearbyStoragesResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[161] + mi := &file_product_proto_msgTypes[165] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7514,7 +7689,7 @@ func (x *ResolveStorageNearbyStoragesResult) ProtoReflect() protoreflect.Message // Deprecated: Use ResolveStorageNearbyStoragesResult.ProtoReflect.Descriptor instead. func (*ResolveStorageNearbyStoragesResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{161} + return file_product_proto_rawDescGZIP(), []int{165} } func (x *ResolveStorageNearbyStoragesResult) GetNearbyStorages() *ListOfStorage { @@ -7533,7 +7708,7 @@ type ResolveStorageNearbyStoragesResponse struct { func (x *ResolveStorageNearbyStoragesResponse) Reset() { *x = ResolveStorageNearbyStoragesResponse{} - mi := &file_product_proto_msgTypes[162] + mi := &file_product_proto_msgTypes[166] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7545,7 +7720,7 @@ func (x *ResolveStorageNearbyStoragesResponse) String() string { func (*ResolveStorageNearbyStoragesResponse) ProtoMessage() {} func (x *ResolveStorageNearbyStoragesResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[162] + mi := &file_product_proto_msgTypes[166] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7558,7 +7733,7 @@ func (x *ResolveStorageNearbyStoragesResponse) ProtoReflect() protoreflect.Messa // Deprecated: Use ResolveStorageNearbyStoragesResponse.ProtoReflect.Descriptor instead. func (*ResolveStorageNearbyStoragesResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{162} + return file_product_proto_rawDescGZIP(), []int{166} } func (x *ResolveStorageNearbyStoragesResponse) GetResult() []*ResolveStorageNearbyStoragesResult { @@ -7577,7 +7752,7 @@ type ResolveCategoryProductCountArgs struct { func (x *ResolveCategoryProductCountArgs) Reset() { *x = ResolveCategoryProductCountArgs{} - mi := &file_product_proto_msgTypes[163] + mi := &file_product_proto_msgTypes[167] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7589,7 +7764,7 @@ func (x *ResolveCategoryProductCountArgs) String() string { func (*ResolveCategoryProductCountArgs) ProtoMessage() {} func (x *ResolveCategoryProductCountArgs) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[163] + mi := &file_product_proto_msgTypes[167] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7602,7 +7777,7 @@ func (x *ResolveCategoryProductCountArgs) ProtoReflect() protoreflect.Message { // Deprecated: Use ResolveCategoryProductCountArgs.ProtoReflect.Descriptor instead. func (*ResolveCategoryProductCountArgs) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{163} + return file_product_proto_rawDescGZIP(), []int{167} } func (x *ResolveCategoryProductCountArgs) GetFilters() *ProductCountFilter { @@ -7622,7 +7797,7 @@ type ResolveCategoryProductCountContext struct { func (x *ResolveCategoryProductCountContext) Reset() { *x = ResolveCategoryProductCountContext{} - mi := &file_product_proto_msgTypes[164] + mi := &file_product_proto_msgTypes[168] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7634,7 +7809,7 @@ func (x *ResolveCategoryProductCountContext) String() string { func (*ResolveCategoryProductCountContext) ProtoMessage() {} func (x *ResolveCategoryProductCountContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[164] + mi := &file_product_proto_msgTypes[168] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7647,7 +7822,7 @@ func (x *ResolveCategoryProductCountContext) ProtoReflect() protoreflect.Message // Deprecated: Use ResolveCategoryProductCountContext.ProtoReflect.Descriptor instead. func (*ResolveCategoryProductCountContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{164} + return file_product_proto_rawDescGZIP(), []int{168} } func (x *ResolveCategoryProductCountContext) GetId() string { @@ -7676,7 +7851,7 @@ type ResolveCategoryProductCountRequest struct { func (x *ResolveCategoryProductCountRequest) Reset() { *x = ResolveCategoryProductCountRequest{} - mi := &file_product_proto_msgTypes[165] + mi := &file_product_proto_msgTypes[169] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7688,7 +7863,7 @@ func (x *ResolveCategoryProductCountRequest) String() string { func (*ResolveCategoryProductCountRequest) ProtoMessage() {} func (x *ResolveCategoryProductCountRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[165] + mi := &file_product_proto_msgTypes[169] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7701,7 +7876,7 @@ func (x *ResolveCategoryProductCountRequest) ProtoReflect() protoreflect.Message // Deprecated: Use ResolveCategoryProductCountRequest.ProtoReflect.Descriptor instead. func (*ResolveCategoryProductCountRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{165} + return file_product_proto_rawDescGZIP(), []int{169} } func (x *ResolveCategoryProductCountRequest) GetContext() []*ResolveCategoryProductCountContext { @@ -7727,7 +7902,7 @@ type ResolveCategoryProductCountResult struct { func (x *ResolveCategoryProductCountResult) Reset() { *x = ResolveCategoryProductCountResult{} - mi := &file_product_proto_msgTypes[166] + mi := &file_product_proto_msgTypes[170] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7739,7 +7914,7 @@ func (x *ResolveCategoryProductCountResult) String() string { func (*ResolveCategoryProductCountResult) ProtoMessage() {} func (x *ResolveCategoryProductCountResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[166] + mi := &file_product_proto_msgTypes[170] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7752,7 +7927,7 @@ func (x *ResolveCategoryProductCountResult) ProtoReflect() protoreflect.Message // Deprecated: Use ResolveCategoryProductCountResult.ProtoReflect.Descriptor instead. func (*ResolveCategoryProductCountResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{166} + return file_product_proto_rawDescGZIP(), []int{170} } func (x *ResolveCategoryProductCountResult) GetProductCount() int32 { @@ -7771,7 +7946,7 @@ type ResolveCategoryProductCountResponse struct { func (x *ResolveCategoryProductCountResponse) Reset() { *x = ResolveCategoryProductCountResponse{} - mi := &file_product_proto_msgTypes[167] + mi := &file_product_proto_msgTypes[171] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7783,7 +7958,7 @@ func (x *ResolveCategoryProductCountResponse) String() string { func (*ResolveCategoryProductCountResponse) ProtoMessage() {} func (x *ResolveCategoryProductCountResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[167] + mi := &file_product_proto_msgTypes[171] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7796,7 +7971,7 @@ func (x *ResolveCategoryProductCountResponse) ProtoReflect() protoreflect.Messag // Deprecated: Use ResolveCategoryProductCountResponse.ProtoReflect.Descriptor instead. func (*ResolveCategoryProductCountResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{167} + return file_product_proto_rawDescGZIP(), []int{171} } func (x *ResolveCategoryProductCountResponse) GetResult() []*ResolveCategoryProductCountResult { @@ -7815,7 +7990,7 @@ type ResolveCategoryPopularityScoreArgs struct { func (x *ResolveCategoryPopularityScoreArgs) Reset() { *x = ResolveCategoryPopularityScoreArgs{} - mi := &file_product_proto_msgTypes[168] + mi := &file_product_proto_msgTypes[172] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7827,7 +8002,7 @@ func (x *ResolveCategoryPopularityScoreArgs) String() string { func (*ResolveCategoryPopularityScoreArgs) ProtoMessage() {} func (x *ResolveCategoryPopularityScoreArgs) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[168] + mi := &file_product_proto_msgTypes[172] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7840,7 +8015,7 @@ func (x *ResolveCategoryPopularityScoreArgs) ProtoReflect() protoreflect.Message // Deprecated: Use ResolveCategoryPopularityScoreArgs.ProtoReflect.Descriptor instead. func (*ResolveCategoryPopularityScoreArgs) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{168} + return file_product_proto_rawDescGZIP(), []int{172} } func (x *ResolveCategoryPopularityScoreArgs) GetThreshold() *wrapperspb.Int32Value { @@ -7859,7 +8034,7 @@ type ResolveCategoryPopularityScoreContext struct { func (x *ResolveCategoryPopularityScoreContext) Reset() { *x = ResolveCategoryPopularityScoreContext{} - mi := &file_product_proto_msgTypes[169] + mi := &file_product_proto_msgTypes[173] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7871,7 +8046,7 @@ func (x *ResolveCategoryPopularityScoreContext) String() string { func (*ResolveCategoryPopularityScoreContext) ProtoMessage() {} func (x *ResolveCategoryPopularityScoreContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[169] + mi := &file_product_proto_msgTypes[173] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7884,7 +8059,7 @@ func (x *ResolveCategoryPopularityScoreContext) ProtoReflect() protoreflect.Mess // Deprecated: Use ResolveCategoryPopularityScoreContext.ProtoReflect.Descriptor instead. func (*ResolveCategoryPopularityScoreContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{169} + return file_product_proto_rawDescGZIP(), []int{173} } func (x *ResolveCategoryPopularityScoreContext) GetId() string { @@ -7906,7 +8081,7 @@ type ResolveCategoryPopularityScoreRequest struct { func (x *ResolveCategoryPopularityScoreRequest) Reset() { *x = ResolveCategoryPopularityScoreRequest{} - mi := &file_product_proto_msgTypes[170] + mi := &file_product_proto_msgTypes[174] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7918,7 +8093,7 @@ func (x *ResolveCategoryPopularityScoreRequest) String() string { func (*ResolveCategoryPopularityScoreRequest) ProtoMessage() {} func (x *ResolveCategoryPopularityScoreRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[170] + mi := &file_product_proto_msgTypes[174] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7931,7 +8106,7 @@ func (x *ResolveCategoryPopularityScoreRequest) ProtoReflect() protoreflect.Mess // Deprecated: Use ResolveCategoryPopularityScoreRequest.ProtoReflect.Descriptor instead. func (*ResolveCategoryPopularityScoreRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{170} + return file_product_proto_rawDescGZIP(), []int{174} } func (x *ResolveCategoryPopularityScoreRequest) GetContext() []*ResolveCategoryPopularityScoreContext { @@ -7957,7 +8132,7 @@ type ResolveCategoryPopularityScoreResult struct { func (x *ResolveCategoryPopularityScoreResult) Reset() { *x = ResolveCategoryPopularityScoreResult{} - mi := &file_product_proto_msgTypes[171] + mi := &file_product_proto_msgTypes[175] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7969,7 +8144,7 @@ func (x *ResolveCategoryPopularityScoreResult) String() string { func (*ResolveCategoryPopularityScoreResult) ProtoMessage() {} func (x *ResolveCategoryPopularityScoreResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[171] + mi := &file_product_proto_msgTypes[175] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7982,7 +8157,7 @@ func (x *ResolveCategoryPopularityScoreResult) ProtoReflect() protoreflect.Messa // Deprecated: Use ResolveCategoryPopularityScoreResult.ProtoReflect.Descriptor instead. func (*ResolveCategoryPopularityScoreResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{171} + return file_product_proto_rawDescGZIP(), []int{175} } func (x *ResolveCategoryPopularityScoreResult) GetPopularityScore() *wrapperspb.Int32Value { @@ -8001,7 +8176,7 @@ type ResolveCategoryPopularityScoreResponse struct { func (x *ResolveCategoryPopularityScoreResponse) Reset() { *x = ResolveCategoryPopularityScoreResponse{} - mi := &file_product_proto_msgTypes[172] + mi := &file_product_proto_msgTypes[176] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8013,7 +8188,7 @@ func (x *ResolveCategoryPopularityScoreResponse) String() string { func (*ResolveCategoryPopularityScoreResponse) ProtoMessage() {} func (x *ResolveCategoryPopularityScoreResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[172] + mi := &file_product_proto_msgTypes[176] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8026,7 +8201,7 @@ func (x *ResolveCategoryPopularityScoreResponse) ProtoReflect() protoreflect.Mes // Deprecated: Use ResolveCategoryPopularityScoreResponse.ProtoReflect.Descriptor instead. func (*ResolveCategoryPopularityScoreResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{172} + return file_product_proto_rawDescGZIP(), []int{176} } func (x *ResolveCategoryPopularityScoreResponse) GetResult() []*ResolveCategoryPopularityScoreResult { @@ -8045,7 +8220,7 @@ type ResolveCategoryCategoryMetricsArgs struct { func (x *ResolveCategoryCategoryMetricsArgs) Reset() { *x = ResolveCategoryCategoryMetricsArgs{} - mi := &file_product_proto_msgTypes[173] + mi := &file_product_proto_msgTypes[177] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8057,7 +8232,7 @@ func (x *ResolveCategoryCategoryMetricsArgs) String() string { func (*ResolveCategoryCategoryMetricsArgs) ProtoMessage() {} func (x *ResolveCategoryCategoryMetricsArgs) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[173] + mi := &file_product_proto_msgTypes[177] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8070,7 +8245,7 @@ func (x *ResolveCategoryCategoryMetricsArgs) ProtoReflect() protoreflect.Message // Deprecated: Use ResolveCategoryCategoryMetricsArgs.ProtoReflect.Descriptor instead. func (*ResolveCategoryCategoryMetricsArgs) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{173} + return file_product_proto_rawDescGZIP(), []int{177} } func (x *ResolveCategoryCategoryMetricsArgs) GetMetricType() string { @@ -8090,7 +8265,7 @@ type ResolveCategoryCategoryMetricsContext struct { func (x *ResolveCategoryCategoryMetricsContext) Reset() { *x = ResolveCategoryCategoryMetricsContext{} - mi := &file_product_proto_msgTypes[174] + mi := &file_product_proto_msgTypes[178] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8102,7 +8277,7 @@ func (x *ResolveCategoryCategoryMetricsContext) String() string { func (*ResolveCategoryCategoryMetricsContext) ProtoMessage() {} func (x *ResolveCategoryCategoryMetricsContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[174] + mi := &file_product_proto_msgTypes[178] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8115,7 +8290,7 @@ func (x *ResolveCategoryCategoryMetricsContext) ProtoReflect() protoreflect.Mess // Deprecated: Use ResolveCategoryCategoryMetricsContext.ProtoReflect.Descriptor instead. func (*ResolveCategoryCategoryMetricsContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{174} + return file_product_proto_rawDescGZIP(), []int{178} } func (x *ResolveCategoryCategoryMetricsContext) GetId() string { @@ -8144,7 +8319,7 @@ type ResolveCategoryCategoryMetricsRequest struct { func (x *ResolveCategoryCategoryMetricsRequest) Reset() { *x = ResolveCategoryCategoryMetricsRequest{} - mi := &file_product_proto_msgTypes[175] + mi := &file_product_proto_msgTypes[179] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8156,7 +8331,7 @@ func (x *ResolveCategoryCategoryMetricsRequest) String() string { func (*ResolveCategoryCategoryMetricsRequest) ProtoMessage() {} func (x *ResolveCategoryCategoryMetricsRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[175] + mi := &file_product_proto_msgTypes[179] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8169,7 +8344,7 @@ func (x *ResolveCategoryCategoryMetricsRequest) ProtoReflect() protoreflect.Mess // Deprecated: Use ResolveCategoryCategoryMetricsRequest.ProtoReflect.Descriptor instead. func (*ResolveCategoryCategoryMetricsRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{175} + return file_product_proto_rawDescGZIP(), []int{179} } func (x *ResolveCategoryCategoryMetricsRequest) GetContext() []*ResolveCategoryCategoryMetricsContext { @@ -8195,7 +8370,7 @@ type ResolveCategoryCategoryMetricsResult struct { func (x *ResolveCategoryCategoryMetricsResult) Reset() { *x = ResolveCategoryCategoryMetricsResult{} - mi := &file_product_proto_msgTypes[176] + mi := &file_product_proto_msgTypes[180] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8207,7 +8382,7 @@ func (x *ResolveCategoryCategoryMetricsResult) String() string { func (*ResolveCategoryCategoryMetricsResult) ProtoMessage() {} func (x *ResolveCategoryCategoryMetricsResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[176] + mi := &file_product_proto_msgTypes[180] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8220,7 +8395,7 @@ func (x *ResolveCategoryCategoryMetricsResult) ProtoReflect() protoreflect.Messa // Deprecated: Use ResolveCategoryCategoryMetricsResult.ProtoReflect.Descriptor instead. func (*ResolveCategoryCategoryMetricsResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{176} + return file_product_proto_rawDescGZIP(), []int{180} } func (x *ResolveCategoryCategoryMetricsResult) GetCategoryMetrics() *CategoryMetrics { @@ -8239,7 +8414,7 @@ type ResolveCategoryCategoryMetricsResponse struct { func (x *ResolveCategoryCategoryMetricsResponse) Reset() { *x = ResolveCategoryCategoryMetricsResponse{} - mi := &file_product_proto_msgTypes[177] + mi := &file_product_proto_msgTypes[181] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8251,7 +8426,7 @@ func (x *ResolveCategoryCategoryMetricsResponse) String() string { func (*ResolveCategoryCategoryMetricsResponse) ProtoMessage() {} func (x *ResolveCategoryCategoryMetricsResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[177] + mi := &file_product_proto_msgTypes[181] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8264,7 +8439,7 @@ func (x *ResolveCategoryCategoryMetricsResponse) ProtoReflect() protoreflect.Mes // Deprecated: Use ResolveCategoryCategoryMetricsResponse.ProtoReflect.Descriptor instead. func (*ResolveCategoryCategoryMetricsResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{177} + return file_product_proto_rawDescGZIP(), []int{181} } func (x *ResolveCategoryCategoryMetricsResponse) GetResult() []*ResolveCategoryCategoryMetricsResult { @@ -8283,7 +8458,7 @@ type ResolveCategoryMascotArgs struct { func (x *ResolveCategoryMascotArgs) Reset() { *x = ResolveCategoryMascotArgs{} - mi := &file_product_proto_msgTypes[178] + mi := &file_product_proto_msgTypes[182] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8295,7 +8470,7 @@ func (x *ResolveCategoryMascotArgs) String() string { func (*ResolveCategoryMascotArgs) ProtoMessage() {} func (x *ResolveCategoryMascotArgs) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[178] + mi := &file_product_proto_msgTypes[182] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8308,7 +8483,7 @@ func (x *ResolveCategoryMascotArgs) ProtoReflect() protoreflect.Message { // Deprecated: Use ResolveCategoryMascotArgs.ProtoReflect.Descriptor instead. func (*ResolveCategoryMascotArgs) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{178} + return file_product_proto_rawDescGZIP(), []int{182} } func (x *ResolveCategoryMascotArgs) GetIncludeVolume() bool { @@ -8328,7 +8503,7 @@ type ResolveCategoryMascotContext struct { func (x *ResolveCategoryMascotContext) Reset() { *x = ResolveCategoryMascotContext{} - mi := &file_product_proto_msgTypes[179] + mi := &file_product_proto_msgTypes[183] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8340,7 +8515,7 @@ func (x *ResolveCategoryMascotContext) String() string { func (*ResolveCategoryMascotContext) ProtoMessage() {} func (x *ResolveCategoryMascotContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[179] + mi := &file_product_proto_msgTypes[183] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8353,7 +8528,7 @@ func (x *ResolveCategoryMascotContext) ProtoReflect() protoreflect.Message { // Deprecated: Use ResolveCategoryMascotContext.ProtoReflect.Descriptor instead. func (*ResolveCategoryMascotContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{179} + return file_product_proto_rawDescGZIP(), []int{183} } func (x *ResolveCategoryMascotContext) GetId() string { @@ -8382,7 +8557,7 @@ type ResolveCategoryMascotRequest struct { func (x *ResolveCategoryMascotRequest) Reset() { *x = ResolveCategoryMascotRequest{} - mi := &file_product_proto_msgTypes[180] + mi := &file_product_proto_msgTypes[184] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8394,7 +8569,7 @@ func (x *ResolveCategoryMascotRequest) String() string { func (*ResolveCategoryMascotRequest) ProtoMessage() {} func (x *ResolveCategoryMascotRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[180] + mi := &file_product_proto_msgTypes[184] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8407,7 +8582,7 @@ func (x *ResolveCategoryMascotRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ResolveCategoryMascotRequest.ProtoReflect.Descriptor instead. func (*ResolveCategoryMascotRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{180} + return file_product_proto_rawDescGZIP(), []int{184} } func (x *ResolveCategoryMascotRequest) GetContext() []*ResolveCategoryMascotContext { @@ -8433,7 +8608,7 @@ type ResolveCategoryMascotResult struct { func (x *ResolveCategoryMascotResult) Reset() { *x = ResolveCategoryMascotResult{} - mi := &file_product_proto_msgTypes[181] + mi := &file_product_proto_msgTypes[185] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8445,7 +8620,7 @@ func (x *ResolveCategoryMascotResult) String() string { func (*ResolveCategoryMascotResult) ProtoMessage() {} func (x *ResolveCategoryMascotResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[181] + mi := &file_product_proto_msgTypes[185] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8458,7 +8633,7 @@ func (x *ResolveCategoryMascotResult) ProtoReflect() protoreflect.Message { // Deprecated: Use ResolveCategoryMascotResult.ProtoReflect.Descriptor instead. func (*ResolveCategoryMascotResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{181} + return file_product_proto_rawDescGZIP(), []int{185} } func (x *ResolveCategoryMascotResult) GetMascot() *Animal { @@ -8477,7 +8652,7 @@ type ResolveCategoryMascotResponse struct { func (x *ResolveCategoryMascotResponse) Reset() { *x = ResolveCategoryMascotResponse{} - mi := &file_product_proto_msgTypes[182] + mi := &file_product_proto_msgTypes[186] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8489,7 +8664,7 @@ func (x *ResolveCategoryMascotResponse) String() string { func (*ResolveCategoryMascotResponse) ProtoMessage() {} func (x *ResolveCategoryMascotResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[182] + mi := &file_product_proto_msgTypes[186] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8502,7 +8677,7 @@ func (x *ResolveCategoryMascotResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ResolveCategoryMascotResponse.ProtoReflect.Descriptor instead. func (*ResolveCategoryMascotResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{182} + return file_product_proto_rawDescGZIP(), []int{186} } func (x *ResolveCategoryMascotResponse) GetResult() []*ResolveCategoryMascotResult { @@ -8521,7 +8696,7 @@ type ResolveCategoryCategoryStatusArgs struct { func (x *ResolveCategoryCategoryStatusArgs) Reset() { *x = ResolveCategoryCategoryStatusArgs{} - mi := &file_product_proto_msgTypes[183] + mi := &file_product_proto_msgTypes[187] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8533,7 +8708,7 @@ func (x *ResolveCategoryCategoryStatusArgs) String() string { func (*ResolveCategoryCategoryStatusArgs) ProtoMessage() {} func (x *ResolveCategoryCategoryStatusArgs) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[183] + mi := &file_product_proto_msgTypes[187] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8546,7 +8721,7 @@ func (x *ResolveCategoryCategoryStatusArgs) ProtoReflect() protoreflect.Message // Deprecated: Use ResolveCategoryCategoryStatusArgs.ProtoReflect.Descriptor instead. func (*ResolveCategoryCategoryStatusArgs) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{183} + return file_product_proto_rawDescGZIP(), []int{187} } func (x *ResolveCategoryCategoryStatusArgs) GetCheckHealth() bool { @@ -8566,7 +8741,7 @@ type ResolveCategoryCategoryStatusContext struct { func (x *ResolveCategoryCategoryStatusContext) Reset() { *x = ResolveCategoryCategoryStatusContext{} - mi := &file_product_proto_msgTypes[184] + mi := &file_product_proto_msgTypes[188] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8578,7 +8753,7 @@ func (x *ResolveCategoryCategoryStatusContext) String() string { func (*ResolveCategoryCategoryStatusContext) ProtoMessage() {} func (x *ResolveCategoryCategoryStatusContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[184] + mi := &file_product_proto_msgTypes[188] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8591,7 +8766,7 @@ func (x *ResolveCategoryCategoryStatusContext) ProtoReflect() protoreflect.Messa // Deprecated: Use ResolveCategoryCategoryStatusContext.ProtoReflect.Descriptor instead. func (*ResolveCategoryCategoryStatusContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{184} + return file_product_proto_rawDescGZIP(), []int{188} } func (x *ResolveCategoryCategoryStatusContext) GetId() string { @@ -8620,7 +8795,7 @@ type ResolveCategoryCategoryStatusRequest struct { func (x *ResolveCategoryCategoryStatusRequest) Reset() { *x = ResolveCategoryCategoryStatusRequest{} - mi := &file_product_proto_msgTypes[185] + mi := &file_product_proto_msgTypes[189] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8632,7 +8807,7 @@ func (x *ResolveCategoryCategoryStatusRequest) String() string { func (*ResolveCategoryCategoryStatusRequest) ProtoMessage() {} func (x *ResolveCategoryCategoryStatusRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[185] + mi := &file_product_proto_msgTypes[189] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8645,7 +8820,7 @@ func (x *ResolveCategoryCategoryStatusRequest) ProtoReflect() protoreflect.Messa // Deprecated: Use ResolveCategoryCategoryStatusRequest.ProtoReflect.Descriptor instead. func (*ResolveCategoryCategoryStatusRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{185} + return file_product_proto_rawDescGZIP(), []int{189} } func (x *ResolveCategoryCategoryStatusRequest) GetContext() []*ResolveCategoryCategoryStatusContext { @@ -8671,7 +8846,7 @@ type ResolveCategoryCategoryStatusResult struct { func (x *ResolveCategoryCategoryStatusResult) Reset() { *x = ResolveCategoryCategoryStatusResult{} - mi := &file_product_proto_msgTypes[186] + mi := &file_product_proto_msgTypes[190] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8683,7 +8858,7 @@ func (x *ResolveCategoryCategoryStatusResult) String() string { func (*ResolveCategoryCategoryStatusResult) ProtoMessage() {} func (x *ResolveCategoryCategoryStatusResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[186] + mi := &file_product_proto_msgTypes[190] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8696,7 +8871,7 @@ func (x *ResolveCategoryCategoryStatusResult) ProtoReflect() protoreflect.Messag // Deprecated: Use ResolveCategoryCategoryStatusResult.ProtoReflect.Descriptor instead. func (*ResolveCategoryCategoryStatusResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{186} + return file_product_proto_rawDescGZIP(), []int{190} } func (x *ResolveCategoryCategoryStatusResult) GetCategoryStatus() *ActionResult { @@ -8715,7 +8890,7 @@ type ResolveCategoryCategoryStatusResponse struct { func (x *ResolveCategoryCategoryStatusResponse) Reset() { *x = ResolveCategoryCategoryStatusResponse{} - mi := &file_product_proto_msgTypes[187] + mi := &file_product_proto_msgTypes[191] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8727,7 +8902,7 @@ func (x *ResolveCategoryCategoryStatusResponse) String() string { func (*ResolveCategoryCategoryStatusResponse) ProtoMessage() {} func (x *ResolveCategoryCategoryStatusResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[187] + mi := &file_product_proto_msgTypes[191] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8740,7 +8915,7 @@ func (x *ResolveCategoryCategoryStatusResponse) ProtoReflect() protoreflect.Mess // Deprecated: Use ResolveCategoryCategoryStatusResponse.ProtoReflect.Descriptor instead. func (*ResolveCategoryCategoryStatusResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{187} + return file_product_proto_rawDescGZIP(), []int{191} } func (x *ResolveCategoryCategoryStatusResponse) GetResult() []*ResolveCategoryCategoryStatusResult { @@ -8759,7 +8934,7 @@ type ResolveCategoryChildCategoriesArgs struct { func (x *ResolveCategoryChildCategoriesArgs) Reset() { *x = ResolveCategoryChildCategoriesArgs{} - mi := &file_product_proto_msgTypes[188] + mi := &file_product_proto_msgTypes[192] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8771,7 +8946,7 @@ func (x *ResolveCategoryChildCategoriesArgs) String() string { func (*ResolveCategoryChildCategoriesArgs) ProtoMessage() {} func (x *ResolveCategoryChildCategoriesArgs) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[188] + mi := &file_product_proto_msgTypes[192] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8784,7 +8959,7 @@ func (x *ResolveCategoryChildCategoriesArgs) ProtoReflect() protoreflect.Message // Deprecated: Use ResolveCategoryChildCategoriesArgs.ProtoReflect.Descriptor instead. func (*ResolveCategoryChildCategoriesArgs) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{188} + return file_product_proto_rawDescGZIP(), []int{192} } func (x *ResolveCategoryChildCategoriesArgs) GetInclude() *wrapperspb.BoolValue { @@ -8804,7 +8979,7 @@ type ResolveCategoryChildCategoriesContext struct { func (x *ResolveCategoryChildCategoriesContext) Reset() { *x = ResolveCategoryChildCategoriesContext{} - mi := &file_product_proto_msgTypes[189] + mi := &file_product_proto_msgTypes[193] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8816,7 +8991,7 @@ func (x *ResolveCategoryChildCategoriesContext) String() string { func (*ResolveCategoryChildCategoriesContext) ProtoMessage() {} func (x *ResolveCategoryChildCategoriesContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[189] + mi := &file_product_proto_msgTypes[193] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8829,7 +9004,7 @@ func (x *ResolveCategoryChildCategoriesContext) ProtoReflect() protoreflect.Mess // Deprecated: Use ResolveCategoryChildCategoriesContext.ProtoReflect.Descriptor instead. func (*ResolveCategoryChildCategoriesContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{189} + return file_product_proto_rawDescGZIP(), []int{193} } func (x *ResolveCategoryChildCategoriesContext) GetId() string { @@ -8858,7 +9033,7 @@ type ResolveCategoryChildCategoriesRequest struct { func (x *ResolveCategoryChildCategoriesRequest) Reset() { *x = ResolveCategoryChildCategoriesRequest{} - mi := &file_product_proto_msgTypes[190] + mi := &file_product_proto_msgTypes[194] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8870,7 +9045,7 @@ func (x *ResolveCategoryChildCategoriesRequest) String() string { func (*ResolveCategoryChildCategoriesRequest) ProtoMessage() {} func (x *ResolveCategoryChildCategoriesRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[190] + mi := &file_product_proto_msgTypes[194] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8883,7 +9058,7 @@ func (x *ResolveCategoryChildCategoriesRequest) ProtoReflect() protoreflect.Mess // Deprecated: Use ResolveCategoryChildCategoriesRequest.ProtoReflect.Descriptor instead. func (*ResolveCategoryChildCategoriesRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{190} + return file_product_proto_rawDescGZIP(), []int{194} } func (x *ResolveCategoryChildCategoriesRequest) GetContext() []*ResolveCategoryChildCategoriesContext { @@ -8909,7 +9084,7 @@ type ResolveCategoryChildCategoriesResult struct { func (x *ResolveCategoryChildCategoriesResult) Reset() { *x = ResolveCategoryChildCategoriesResult{} - mi := &file_product_proto_msgTypes[191] + mi := &file_product_proto_msgTypes[195] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8921,7 +9096,7 @@ func (x *ResolveCategoryChildCategoriesResult) String() string { func (*ResolveCategoryChildCategoriesResult) ProtoMessage() {} func (x *ResolveCategoryChildCategoriesResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[191] + mi := &file_product_proto_msgTypes[195] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8934,7 +9109,7 @@ func (x *ResolveCategoryChildCategoriesResult) ProtoReflect() protoreflect.Messa // Deprecated: Use ResolveCategoryChildCategoriesResult.ProtoReflect.Descriptor instead. func (*ResolveCategoryChildCategoriesResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{191} + return file_product_proto_rawDescGZIP(), []int{195} } func (x *ResolveCategoryChildCategoriesResult) GetChildCategories() []*Category { @@ -8953,7 +9128,7 @@ type ResolveCategoryChildCategoriesResponse struct { func (x *ResolveCategoryChildCategoriesResponse) Reset() { *x = ResolveCategoryChildCategoriesResponse{} - mi := &file_product_proto_msgTypes[192] + mi := &file_product_proto_msgTypes[196] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8965,7 +9140,7 @@ func (x *ResolveCategoryChildCategoriesResponse) String() string { func (*ResolveCategoryChildCategoriesResponse) ProtoMessage() {} func (x *ResolveCategoryChildCategoriesResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[192] + mi := &file_product_proto_msgTypes[196] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8978,7 +9153,7 @@ func (x *ResolveCategoryChildCategoriesResponse) ProtoReflect() protoreflect.Mes // Deprecated: Use ResolveCategoryChildCategoriesResponse.ProtoReflect.Descriptor instead. func (*ResolveCategoryChildCategoriesResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{192} + return file_product_proto_rawDescGZIP(), []int{196} } func (x *ResolveCategoryChildCategoriesResponse) GetResult() []*ResolveCategoryChildCategoriesResult { @@ -8997,7 +9172,7 @@ type ResolveCategoryOptionalCategoriesArgs struct { func (x *ResolveCategoryOptionalCategoriesArgs) Reset() { *x = ResolveCategoryOptionalCategoriesArgs{} - mi := &file_product_proto_msgTypes[193] + mi := &file_product_proto_msgTypes[197] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9009,7 +9184,7 @@ func (x *ResolveCategoryOptionalCategoriesArgs) String() string { func (*ResolveCategoryOptionalCategoriesArgs) ProtoMessage() {} func (x *ResolveCategoryOptionalCategoriesArgs) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[193] + mi := &file_product_proto_msgTypes[197] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9022,7 +9197,7 @@ func (x *ResolveCategoryOptionalCategoriesArgs) ProtoReflect() protoreflect.Mess // Deprecated: Use ResolveCategoryOptionalCategoriesArgs.ProtoReflect.Descriptor instead. func (*ResolveCategoryOptionalCategoriesArgs) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{193} + return file_product_proto_rawDescGZIP(), []int{197} } func (x *ResolveCategoryOptionalCategoriesArgs) GetInclude() *wrapperspb.BoolValue { @@ -9042,7 +9217,7 @@ type ResolveCategoryOptionalCategoriesContext struct { func (x *ResolveCategoryOptionalCategoriesContext) Reset() { *x = ResolveCategoryOptionalCategoriesContext{} - mi := &file_product_proto_msgTypes[194] + mi := &file_product_proto_msgTypes[198] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9054,7 +9229,7 @@ func (x *ResolveCategoryOptionalCategoriesContext) String() string { func (*ResolveCategoryOptionalCategoriesContext) ProtoMessage() {} func (x *ResolveCategoryOptionalCategoriesContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[194] + mi := &file_product_proto_msgTypes[198] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9067,7 +9242,7 @@ func (x *ResolveCategoryOptionalCategoriesContext) ProtoReflect() protoreflect.M // Deprecated: Use ResolveCategoryOptionalCategoriesContext.ProtoReflect.Descriptor instead. func (*ResolveCategoryOptionalCategoriesContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{194} + return file_product_proto_rawDescGZIP(), []int{198} } func (x *ResolveCategoryOptionalCategoriesContext) GetId() string { @@ -9096,7 +9271,7 @@ type ResolveCategoryOptionalCategoriesRequest struct { func (x *ResolveCategoryOptionalCategoriesRequest) Reset() { *x = ResolveCategoryOptionalCategoriesRequest{} - mi := &file_product_proto_msgTypes[195] + mi := &file_product_proto_msgTypes[199] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9108,7 +9283,7 @@ func (x *ResolveCategoryOptionalCategoriesRequest) String() string { func (*ResolveCategoryOptionalCategoriesRequest) ProtoMessage() {} func (x *ResolveCategoryOptionalCategoriesRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[195] + mi := &file_product_proto_msgTypes[199] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9121,7 +9296,7 @@ func (x *ResolveCategoryOptionalCategoriesRequest) ProtoReflect() protoreflect.M // Deprecated: Use ResolveCategoryOptionalCategoriesRequest.ProtoReflect.Descriptor instead. func (*ResolveCategoryOptionalCategoriesRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{195} + return file_product_proto_rawDescGZIP(), []int{199} } func (x *ResolveCategoryOptionalCategoriesRequest) GetContext() []*ResolveCategoryOptionalCategoriesContext { @@ -9147,7 +9322,7 @@ type ResolveCategoryOptionalCategoriesResult struct { func (x *ResolveCategoryOptionalCategoriesResult) Reset() { *x = ResolveCategoryOptionalCategoriesResult{} - mi := &file_product_proto_msgTypes[196] + mi := &file_product_proto_msgTypes[200] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9159,7 +9334,7 @@ func (x *ResolveCategoryOptionalCategoriesResult) String() string { func (*ResolveCategoryOptionalCategoriesResult) ProtoMessage() {} func (x *ResolveCategoryOptionalCategoriesResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[196] + mi := &file_product_proto_msgTypes[200] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9172,7 +9347,7 @@ func (x *ResolveCategoryOptionalCategoriesResult) ProtoReflect() protoreflect.Me // Deprecated: Use ResolveCategoryOptionalCategoriesResult.ProtoReflect.Descriptor instead. func (*ResolveCategoryOptionalCategoriesResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{196} + return file_product_proto_rawDescGZIP(), []int{200} } func (x *ResolveCategoryOptionalCategoriesResult) GetOptionalCategories() *ListOfCategory { @@ -9191,7 +9366,7 @@ type ResolveCategoryOptionalCategoriesResponse struct { func (x *ResolveCategoryOptionalCategoriesResponse) Reset() { *x = ResolveCategoryOptionalCategoriesResponse{} - mi := &file_product_proto_msgTypes[197] + mi := &file_product_proto_msgTypes[201] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9203,7 +9378,7 @@ func (x *ResolveCategoryOptionalCategoriesResponse) String() string { func (*ResolveCategoryOptionalCategoriesResponse) ProtoMessage() {} func (x *ResolveCategoryOptionalCategoriesResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[197] + mi := &file_product_proto_msgTypes[201] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9216,7 +9391,7 @@ func (x *ResolveCategoryOptionalCategoriesResponse) ProtoReflect() protoreflect. // Deprecated: Use ResolveCategoryOptionalCategoriesResponse.ProtoReflect.Descriptor instead. func (*ResolveCategoryOptionalCategoriesResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{197} + return file_product_proto_rawDescGZIP(), []int{201} } func (x *ResolveCategoryOptionalCategoriesResponse) GetResult() []*ResolveCategoryOptionalCategoriesResult { @@ -9235,7 +9410,7 @@ type ResolveCategoryTotalProductsContext struct { func (x *ResolveCategoryTotalProductsContext) Reset() { *x = ResolveCategoryTotalProductsContext{} - mi := &file_product_proto_msgTypes[198] + mi := &file_product_proto_msgTypes[202] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9247,7 +9422,7 @@ func (x *ResolveCategoryTotalProductsContext) String() string { func (*ResolveCategoryTotalProductsContext) ProtoMessage() {} func (x *ResolveCategoryTotalProductsContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[198] + mi := &file_product_proto_msgTypes[202] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9260,7 +9435,7 @@ func (x *ResolveCategoryTotalProductsContext) ProtoReflect() protoreflect.Messag // Deprecated: Use ResolveCategoryTotalProductsContext.ProtoReflect.Descriptor instead. func (*ResolveCategoryTotalProductsContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{198} + return file_product_proto_rawDescGZIP(), []int{202} } func (x *ResolveCategoryTotalProductsContext) GetId() string { @@ -9280,7 +9455,7 @@ type ResolveCategoryTotalProductsRequest struct { func (x *ResolveCategoryTotalProductsRequest) Reset() { *x = ResolveCategoryTotalProductsRequest{} - mi := &file_product_proto_msgTypes[199] + mi := &file_product_proto_msgTypes[203] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9292,7 +9467,7 @@ func (x *ResolveCategoryTotalProductsRequest) String() string { func (*ResolveCategoryTotalProductsRequest) ProtoMessage() {} func (x *ResolveCategoryTotalProductsRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[199] + mi := &file_product_proto_msgTypes[203] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9305,7 +9480,7 @@ func (x *ResolveCategoryTotalProductsRequest) ProtoReflect() protoreflect.Messag // Deprecated: Use ResolveCategoryTotalProductsRequest.ProtoReflect.Descriptor instead. func (*ResolveCategoryTotalProductsRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{199} + return file_product_proto_rawDescGZIP(), []int{203} } func (x *ResolveCategoryTotalProductsRequest) GetContext() []*ResolveCategoryTotalProductsContext { @@ -9324,7 +9499,7 @@ type ResolveCategoryTotalProductsResult struct { func (x *ResolveCategoryTotalProductsResult) Reset() { *x = ResolveCategoryTotalProductsResult{} - mi := &file_product_proto_msgTypes[200] + mi := &file_product_proto_msgTypes[204] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9336,7 +9511,7 @@ func (x *ResolveCategoryTotalProductsResult) String() string { func (*ResolveCategoryTotalProductsResult) ProtoMessage() {} func (x *ResolveCategoryTotalProductsResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[200] + mi := &file_product_proto_msgTypes[204] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9349,7 +9524,7 @@ func (x *ResolveCategoryTotalProductsResult) ProtoReflect() protoreflect.Message // Deprecated: Use ResolveCategoryTotalProductsResult.ProtoReflect.Descriptor instead. func (*ResolveCategoryTotalProductsResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{200} + return file_product_proto_rawDescGZIP(), []int{204} } func (x *ResolveCategoryTotalProductsResult) GetTotalProducts() int32 { @@ -9368,7 +9543,7 @@ type ResolveCategoryTotalProductsResponse struct { func (x *ResolveCategoryTotalProductsResponse) Reset() { *x = ResolveCategoryTotalProductsResponse{} - mi := &file_product_proto_msgTypes[201] + mi := &file_product_proto_msgTypes[205] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9380,7 +9555,7 @@ func (x *ResolveCategoryTotalProductsResponse) String() string { func (*ResolveCategoryTotalProductsResponse) ProtoMessage() {} func (x *ResolveCategoryTotalProductsResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[201] + mi := &file_product_proto_msgTypes[205] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9393,7 +9568,7 @@ func (x *ResolveCategoryTotalProductsResponse) ProtoReflect() protoreflect.Messa // Deprecated: Use ResolveCategoryTotalProductsResponse.ProtoReflect.Descriptor instead. func (*ResolveCategoryTotalProductsResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{201} + return file_product_proto_rawDescGZIP(), []int{205} } func (x *ResolveCategoryTotalProductsResponse) GetResult() []*ResolveCategoryTotalProductsResult { @@ -9413,7 +9588,7 @@ type ResolveCategoryTopSubcategoryContext struct { func (x *ResolveCategoryTopSubcategoryContext) Reset() { *x = ResolveCategoryTopSubcategoryContext{} - mi := &file_product_proto_msgTypes[202] + mi := &file_product_proto_msgTypes[206] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9425,7 +9600,7 @@ func (x *ResolveCategoryTopSubcategoryContext) String() string { func (*ResolveCategoryTopSubcategoryContext) ProtoMessage() {} func (x *ResolveCategoryTopSubcategoryContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[202] + mi := &file_product_proto_msgTypes[206] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9438,7 +9613,7 @@ func (x *ResolveCategoryTopSubcategoryContext) ProtoReflect() protoreflect.Messa // Deprecated: Use ResolveCategoryTopSubcategoryContext.ProtoReflect.Descriptor instead. func (*ResolveCategoryTopSubcategoryContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{202} + return file_product_proto_rawDescGZIP(), []int{206} } func (x *ResolveCategoryTopSubcategoryContext) GetId() string { @@ -9465,7 +9640,7 @@ type ResolveCategoryTopSubcategoryRequest struct { func (x *ResolveCategoryTopSubcategoryRequest) Reset() { *x = ResolveCategoryTopSubcategoryRequest{} - mi := &file_product_proto_msgTypes[203] + mi := &file_product_proto_msgTypes[207] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9477,7 +9652,7 @@ func (x *ResolveCategoryTopSubcategoryRequest) String() string { func (*ResolveCategoryTopSubcategoryRequest) ProtoMessage() {} func (x *ResolveCategoryTopSubcategoryRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[203] + mi := &file_product_proto_msgTypes[207] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9490,7 +9665,7 @@ func (x *ResolveCategoryTopSubcategoryRequest) ProtoReflect() protoreflect.Messa // Deprecated: Use ResolveCategoryTopSubcategoryRequest.ProtoReflect.Descriptor instead. func (*ResolveCategoryTopSubcategoryRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{203} + return file_product_proto_rawDescGZIP(), []int{207} } func (x *ResolveCategoryTopSubcategoryRequest) GetContext() []*ResolveCategoryTopSubcategoryContext { @@ -9509,7 +9684,7 @@ type ResolveCategoryTopSubcategoryResult struct { func (x *ResolveCategoryTopSubcategoryResult) Reset() { *x = ResolveCategoryTopSubcategoryResult{} - mi := &file_product_proto_msgTypes[204] + mi := &file_product_proto_msgTypes[208] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9521,7 +9696,7 @@ func (x *ResolveCategoryTopSubcategoryResult) String() string { func (*ResolveCategoryTopSubcategoryResult) ProtoMessage() {} func (x *ResolveCategoryTopSubcategoryResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[204] + mi := &file_product_proto_msgTypes[208] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9534,7 +9709,7 @@ func (x *ResolveCategoryTopSubcategoryResult) ProtoReflect() protoreflect.Messag // Deprecated: Use ResolveCategoryTopSubcategoryResult.ProtoReflect.Descriptor instead. func (*ResolveCategoryTopSubcategoryResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{204} + return file_product_proto_rawDescGZIP(), []int{208} } func (x *ResolveCategoryTopSubcategoryResult) GetTopSubcategory() *Subcategory { @@ -9553,7 +9728,7 @@ type ResolveCategoryTopSubcategoryResponse struct { func (x *ResolveCategoryTopSubcategoryResponse) Reset() { *x = ResolveCategoryTopSubcategoryResponse{} - mi := &file_product_proto_msgTypes[205] + mi := &file_product_proto_msgTypes[209] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9565,7 +9740,7 @@ func (x *ResolveCategoryTopSubcategoryResponse) String() string { func (*ResolveCategoryTopSubcategoryResponse) ProtoMessage() {} func (x *ResolveCategoryTopSubcategoryResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[205] + mi := &file_product_proto_msgTypes[209] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9578,7 +9753,7 @@ func (x *ResolveCategoryTopSubcategoryResponse) ProtoReflect() protoreflect.Mess // Deprecated: Use ResolveCategoryTopSubcategoryResponse.ProtoReflect.Descriptor instead. func (*ResolveCategoryTopSubcategoryResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{205} + return file_product_proto_rawDescGZIP(), []int{209} } func (x *ResolveCategoryTopSubcategoryResponse) GetResult() []*ResolveCategoryTopSubcategoryResult { @@ -9597,7 +9772,7 @@ type ResolveCategoryActiveSubcategoriesContext struct { func (x *ResolveCategoryActiveSubcategoriesContext) Reset() { *x = ResolveCategoryActiveSubcategoriesContext{} - mi := &file_product_proto_msgTypes[206] + mi := &file_product_proto_msgTypes[210] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9609,7 +9784,7 @@ func (x *ResolveCategoryActiveSubcategoriesContext) String() string { func (*ResolveCategoryActiveSubcategoriesContext) ProtoMessage() {} func (x *ResolveCategoryActiveSubcategoriesContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[206] + mi := &file_product_proto_msgTypes[210] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9622,7 +9797,7 @@ func (x *ResolveCategoryActiveSubcategoriesContext) ProtoReflect() protoreflect. // Deprecated: Use ResolveCategoryActiveSubcategoriesContext.ProtoReflect.Descriptor instead. func (*ResolveCategoryActiveSubcategoriesContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{206} + return file_product_proto_rawDescGZIP(), []int{210} } func (x *ResolveCategoryActiveSubcategoriesContext) GetId() string { @@ -9642,7 +9817,7 @@ type ResolveCategoryActiveSubcategoriesRequest struct { func (x *ResolveCategoryActiveSubcategoriesRequest) Reset() { *x = ResolveCategoryActiveSubcategoriesRequest{} - mi := &file_product_proto_msgTypes[207] + mi := &file_product_proto_msgTypes[211] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9654,7 +9829,7 @@ func (x *ResolveCategoryActiveSubcategoriesRequest) String() string { func (*ResolveCategoryActiveSubcategoriesRequest) ProtoMessage() {} func (x *ResolveCategoryActiveSubcategoriesRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[207] + mi := &file_product_proto_msgTypes[211] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9667,7 +9842,7 @@ func (x *ResolveCategoryActiveSubcategoriesRequest) ProtoReflect() protoreflect. // Deprecated: Use ResolveCategoryActiveSubcategoriesRequest.ProtoReflect.Descriptor instead. func (*ResolveCategoryActiveSubcategoriesRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{207} + return file_product_proto_rawDescGZIP(), []int{211} } func (x *ResolveCategoryActiveSubcategoriesRequest) GetContext() []*ResolveCategoryActiveSubcategoriesContext { @@ -9686,7 +9861,7 @@ type ResolveCategoryActiveSubcategoriesResult struct { func (x *ResolveCategoryActiveSubcategoriesResult) Reset() { *x = ResolveCategoryActiveSubcategoriesResult{} - mi := &file_product_proto_msgTypes[208] + mi := &file_product_proto_msgTypes[212] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9698,7 +9873,7 @@ func (x *ResolveCategoryActiveSubcategoriesResult) String() string { func (*ResolveCategoryActiveSubcategoriesResult) ProtoMessage() {} func (x *ResolveCategoryActiveSubcategoriesResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[208] + mi := &file_product_proto_msgTypes[212] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9711,7 +9886,7 @@ func (x *ResolveCategoryActiveSubcategoriesResult) ProtoReflect() protoreflect.M // Deprecated: Use ResolveCategoryActiveSubcategoriesResult.ProtoReflect.Descriptor instead. func (*ResolveCategoryActiveSubcategoriesResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{208} + return file_product_proto_rawDescGZIP(), []int{212} } func (x *ResolveCategoryActiveSubcategoriesResult) GetActiveSubcategories() []*Subcategory { @@ -9730,7 +9905,7 @@ type ResolveCategoryActiveSubcategoriesResponse struct { func (x *ResolveCategoryActiveSubcategoriesResponse) Reset() { *x = ResolveCategoryActiveSubcategoriesResponse{} - mi := &file_product_proto_msgTypes[209] + mi := &file_product_proto_msgTypes[213] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9742,7 +9917,7 @@ func (x *ResolveCategoryActiveSubcategoriesResponse) String() string { func (*ResolveCategoryActiveSubcategoriesResponse) ProtoMessage() {} func (x *ResolveCategoryActiveSubcategoriesResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[209] + mi := &file_product_proto_msgTypes[213] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9755,7 +9930,7 @@ func (x *ResolveCategoryActiveSubcategoriesResponse) ProtoReflect() protoreflect // Deprecated: Use ResolveCategoryActiveSubcategoriesResponse.ProtoReflect.Descriptor instead. func (*ResolveCategoryActiveSubcategoriesResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{209} + return file_product_proto_rawDescGZIP(), []int{213} } func (x *ResolveCategoryActiveSubcategoriesResponse) GetResult() []*ResolveCategoryActiveSubcategoriesResult { @@ -9774,7 +9949,7 @@ type ResolveSubcategoryItemCountArgs struct { func (x *ResolveSubcategoryItemCountArgs) Reset() { *x = ResolveSubcategoryItemCountArgs{} - mi := &file_product_proto_msgTypes[210] + mi := &file_product_proto_msgTypes[214] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9786,7 +9961,7 @@ func (x *ResolveSubcategoryItemCountArgs) String() string { func (*ResolveSubcategoryItemCountArgs) ProtoMessage() {} func (x *ResolveSubcategoryItemCountArgs) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[210] + mi := &file_product_proto_msgTypes[214] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9799,7 +9974,7 @@ func (x *ResolveSubcategoryItemCountArgs) ProtoReflect() protoreflect.Message { // Deprecated: Use ResolveSubcategoryItemCountArgs.ProtoReflect.Descriptor instead. func (*ResolveSubcategoryItemCountArgs) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{210} + return file_product_proto_rawDescGZIP(), []int{214} } func (x *ResolveSubcategoryItemCountArgs) GetFilters() *SubcategoryItemFilter { @@ -9818,7 +9993,7 @@ type ResolveSubcategoryItemCountContext struct { func (x *ResolveSubcategoryItemCountContext) Reset() { *x = ResolveSubcategoryItemCountContext{} - mi := &file_product_proto_msgTypes[211] + mi := &file_product_proto_msgTypes[215] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9830,7 +10005,7 @@ func (x *ResolveSubcategoryItemCountContext) String() string { func (*ResolveSubcategoryItemCountContext) ProtoMessage() {} func (x *ResolveSubcategoryItemCountContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[211] + mi := &file_product_proto_msgTypes[215] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9843,7 +10018,7 @@ func (x *ResolveSubcategoryItemCountContext) ProtoReflect() protoreflect.Message // Deprecated: Use ResolveSubcategoryItemCountContext.ProtoReflect.Descriptor instead. func (*ResolveSubcategoryItemCountContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{211} + return file_product_proto_rawDescGZIP(), []int{215} } func (x *ResolveSubcategoryItemCountContext) GetId() string { @@ -9865,7 +10040,7 @@ type ResolveSubcategoryItemCountRequest struct { func (x *ResolveSubcategoryItemCountRequest) Reset() { *x = ResolveSubcategoryItemCountRequest{} - mi := &file_product_proto_msgTypes[212] + mi := &file_product_proto_msgTypes[216] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9877,7 +10052,7 @@ func (x *ResolveSubcategoryItemCountRequest) String() string { func (*ResolveSubcategoryItemCountRequest) ProtoMessage() {} func (x *ResolveSubcategoryItemCountRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[212] + mi := &file_product_proto_msgTypes[216] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9890,7 +10065,7 @@ func (x *ResolveSubcategoryItemCountRequest) ProtoReflect() protoreflect.Message // Deprecated: Use ResolveSubcategoryItemCountRequest.ProtoReflect.Descriptor instead. func (*ResolveSubcategoryItemCountRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{212} + return file_product_proto_rawDescGZIP(), []int{216} } func (x *ResolveSubcategoryItemCountRequest) GetContext() []*ResolveSubcategoryItemCountContext { @@ -9916,7 +10091,7 @@ type ResolveSubcategoryItemCountResult struct { func (x *ResolveSubcategoryItemCountResult) Reset() { *x = ResolveSubcategoryItemCountResult{} - mi := &file_product_proto_msgTypes[213] + mi := &file_product_proto_msgTypes[217] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9928,7 +10103,7 @@ func (x *ResolveSubcategoryItemCountResult) String() string { func (*ResolveSubcategoryItemCountResult) ProtoMessage() {} func (x *ResolveSubcategoryItemCountResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[213] + mi := &file_product_proto_msgTypes[217] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9941,7 +10116,7 @@ func (x *ResolveSubcategoryItemCountResult) ProtoReflect() protoreflect.Message // Deprecated: Use ResolveSubcategoryItemCountResult.ProtoReflect.Descriptor instead. func (*ResolveSubcategoryItemCountResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{213} + return file_product_proto_rawDescGZIP(), []int{217} } func (x *ResolveSubcategoryItemCountResult) GetItemCount() int32 { @@ -9960,7 +10135,7 @@ type ResolveSubcategoryItemCountResponse struct { func (x *ResolveSubcategoryItemCountResponse) Reset() { *x = ResolveSubcategoryItemCountResponse{} - mi := &file_product_proto_msgTypes[214] + mi := &file_product_proto_msgTypes[218] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9972,7 +10147,7 @@ func (x *ResolveSubcategoryItemCountResponse) String() string { func (*ResolveSubcategoryItemCountResponse) ProtoMessage() {} func (x *ResolveSubcategoryItemCountResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[214] + mi := &file_product_proto_msgTypes[218] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9985,7 +10160,7 @@ func (x *ResolveSubcategoryItemCountResponse) ProtoReflect() protoreflect.Messag // Deprecated: Use ResolveSubcategoryItemCountResponse.ProtoReflect.Descriptor instead. func (*ResolveSubcategoryItemCountResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{214} + return file_product_proto_rawDescGZIP(), []int{218} } func (x *ResolveSubcategoryItemCountResponse) GetResult() []*ResolveSubcategoryItemCountResult { @@ -10004,7 +10179,7 @@ type ResolveSubcategoryFeaturedCategoryArgs struct { func (x *ResolveSubcategoryFeaturedCategoryArgs) Reset() { *x = ResolveSubcategoryFeaturedCategoryArgs{} - mi := &file_product_proto_msgTypes[215] + mi := &file_product_proto_msgTypes[219] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10016,7 +10191,7 @@ func (x *ResolveSubcategoryFeaturedCategoryArgs) String() string { func (*ResolveSubcategoryFeaturedCategoryArgs) ProtoMessage() {} func (x *ResolveSubcategoryFeaturedCategoryArgs) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[215] + mi := &file_product_proto_msgTypes[219] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10029,7 +10204,7 @@ func (x *ResolveSubcategoryFeaturedCategoryArgs) ProtoReflect() protoreflect.Mes // Deprecated: Use ResolveSubcategoryFeaturedCategoryArgs.ProtoReflect.Descriptor instead. func (*ResolveSubcategoryFeaturedCategoryArgs) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{215} + return file_product_proto_rawDescGZIP(), []int{219} } func (x *ResolveSubcategoryFeaturedCategoryArgs) GetIncludeChildren() bool { @@ -10048,7 +10223,7 @@ type ResolveSubcategoryFeaturedCategoryContext struct { func (x *ResolveSubcategoryFeaturedCategoryContext) Reset() { *x = ResolveSubcategoryFeaturedCategoryContext{} - mi := &file_product_proto_msgTypes[216] + mi := &file_product_proto_msgTypes[220] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10060,7 +10235,7 @@ func (x *ResolveSubcategoryFeaturedCategoryContext) String() string { func (*ResolveSubcategoryFeaturedCategoryContext) ProtoMessage() {} func (x *ResolveSubcategoryFeaturedCategoryContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[216] + mi := &file_product_proto_msgTypes[220] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10073,7 +10248,7 @@ func (x *ResolveSubcategoryFeaturedCategoryContext) ProtoReflect() protoreflect. // Deprecated: Use ResolveSubcategoryFeaturedCategoryContext.ProtoReflect.Descriptor instead. func (*ResolveSubcategoryFeaturedCategoryContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{216} + return file_product_proto_rawDescGZIP(), []int{220} } func (x *ResolveSubcategoryFeaturedCategoryContext) GetId() string { @@ -10095,7 +10270,7 @@ type ResolveSubcategoryFeaturedCategoryRequest struct { func (x *ResolveSubcategoryFeaturedCategoryRequest) Reset() { *x = ResolveSubcategoryFeaturedCategoryRequest{} - mi := &file_product_proto_msgTypes[217] + mi := &file_product_proto_msgTypes[221] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10107,7 +10282,7 @@ func (x *ResolveSubcategoryFeaturedCategoryRequest) String() string { func (*ResolveSubcategoryFeaturedCategoryRequest) ProtoMessage() {} func (x *ResolveSubcategoryFeaturedCategoryRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[217] + mi := &file_product_proto_msgTypes[221] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10120,7 +10295,7 @@ func (x *ResolveSubcategoryFeaturedCategoryRequest) ProtoReflect() protoreflect. // Deprecated: Use ResolveSubcategoryFeaturedCategoryRequest.ProtoReflect.Descriptor instead. func (*ResolveSubcategoryFeaturedCategoryRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{217} + return file_product_proto_rawDescGZIP(), []int{221} } func (x *ResolveSubcategoryFeaturedCategoryRequest) GetContext() []*ResolveSubcategoryFeaturedCategoryContext { @@ -10146,7 +10321,7 @@ type ResolveSubcategoryFeaturedCategoryResult struct { func (x *ResolveSubcategoryFeaturedCategoryResult) Reset() { *x = ResolveSubcategoryFeaturedCategoryResult{} - mi := &file_product_proto_msgTypes[218] + mi := &file_product_proto_msgTypes[222] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10158,7 +10333,7 @@ func (x *ResolveSubcategoryFeaturedCategoryResult) String() string { func (*ResolveSubcategoryFeaturedCategoryResult) ProtoMessage() {} func (x *ResolveSubcategoryFeaturedCategoryResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[218] + mi := &file_product_proto_msgTypes[222] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10171,7 +10346,7 @@ func (x *ResolveSubcategoryFeaturedCategoryResult) ProtoReflect() protoreflect.M // Deprecated: Use ResolveSubcategoryFeaturedCategoryResult.ProtoReflect.Descriptor instead. func (*ResolveSubcategoryFeaturedCategoryResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{218} + return file_product_proto_rawDescGZIP(), []int{222} } func (x *ResolveSubcategoryFeaturedCategoryResult) GetFeaturedCategory() *Category { @@ -10190,7 +10365,7 @@ type ResolveSubcategoryFeaturedCategoryResponse struct { func (x *ResolveSubcategoryFeaturedCategoryResponse) Reset() { *x = ResolveSubcategoryFeaturedCategoryResponse{} - mi := &file_product_proto_msgTypes[219] + mi := &file_product_proto_msgTypes[223] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10202,7 +10377,7 @@ func (x *ResolveSubcategoryFeaturedCategoryResponse) String() string { func (*ResolveSubcategoryFeaturedCategoryResponse) ProtoMessage() {} func (x *ResolveSubcategoryFeaturedCategoryResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[219] + mi := &file_product_proto_msgTypes[223] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10215,7 +10390,7 @@ func (x *ResolveSubcategoryFeaturedCategoryResponse) ProtoReflect() protoreflect // Deprecated: Use ResolveSubcategoryFeaturedCategoryResponse.ProtoReflect.Descriptor instead. func (*ResolveSubcategoryFeaturedCategoryResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{219} + return file_product_proto_rawDescGZIP(), []int{223} } func (x *ResolveSubcategoryFeaturedCategoryResponse) GetResult() []*ResolveSubcategoryFeaturedCategoryResult { @@ -10234,7 +10409,7 @@ type ResolveSubcategoryParentCategoryContext struct { func (x *ResolveSubcategoryParentCategoryContext) Reset() { *x = ResolveSubcategoryParentCategoryContext{} - mi := &file_product_proto_msgTypes[220] + mi := &file_product_proto_msgTypes[224] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10246,7 +10421,7 @@ func (x *ResolveSubcategoryParentCategoryContext) String() string { func (*ResolveSubcategoryParentCategoryContext) ProtoMessage() {} func (x *ResolveSubcategoryParentCategoryContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[220] + mi := &file_product_proto_msgTypes[224] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10259,7 +10434,7 @@ func (x *ResolveSubcategoryParentCategoryContext) ProtoReflect() protoreflect.Me // Deprecated: Use ResolveSubcategoryParentCategoryContext.ProtoReflect.Descriptor instead. func (*ResolveSubcategoryParentCategoryContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{220} + return file_product_proto_rawDescGZIP(), []int{224} } func (x *ResolveSubcategoryParentCategoryContext) GetId() string { @@ -10279,7 +10454,7 @@ type ResolveSubcategoryParentCategoryRequest struct { func (x *ResolveSubcategoryParentCategoryRequest) Reset() { *x = ResolveSubcategoryParentCategoryRequest{} - mi := &file_product_proto_msgTypes[221] + mi := &file_product_proto_msgTypes[225] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10291,7 +10466,7 @@ func (x *ResolveSubcategoryParentCategoryRequest) String() string { func (*ResolveSubcategoryParentCategoryRequest) ProtoMessage() {} func (x *ResolveSubcategoryParentCategoryRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[221] + mi := &file_product_proto_msgTypes[225] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10304,7 +10479,7 @@ func (x *ResolveSubcategoryParentCategoryRequest) ProtoReflect() protoreflect.Me // Deprecated: Use ResolveSubcategoryParentCategoryRequest.ProtoReflect.Descriptor instead. func (*ResolveSubcategoryParentCategoryRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{221} + return file_product_proto_rawDescGZIP(), []int{225} } func (x *ResolveSubcategoryParentCategoryRequest) GetContext() []*ResolveSubcategoryParentCategoryContext { @@ -10323,7 +10498,7 @@ type ResolveSubcategoryParentCategoryResult struct { func (x *ResolveSubcategoryParentCategoryResult) Reset() { *x = ResolveSubcategoryParentCategoryResult{} - mi := &file_product_proto_msgTypes[222] + mi := &file_product_proto_msgTypes[226] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10335,7 +10510,7 @@ func (x *ResolveSubcategoryParentCategoryResult) String() string { func (*ResolveSubcategoryParentCategoryResult) ProtoMessage() {} func (x *ResolveSubcategoryParentCategoryResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[222] + mi := &file_product_proto_msgTypes[226] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10348,7 +10523,7 @@ func (x *ResolveSubcategoryParentCategoryResult) ProtoReflect() protoreflect.Mes // Deprecated: Use ResolveSubcategoryParentCategoryResult.ProtoReflect.Descriptor instead. func (*ResolveSubcategoryParentCategoryResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{222} + return file_product_proto_rawDescGZIP(), []int{226} } func (x *ResolveSubcategoryParentCategoryResult) GetParentCategory() *Category { @@ -10367,7 +10542,7 @@ type ResolveSubcategoryParentCategoryResponse struct { func (x *ResolveSubcategoryParentCategoryResponse) Reset() { *x = ResolveSubcategoryParentCategoryResponse{} - mi := &file_product_proto_msgTypes[223] + mi := &file_product_proto_msgTypes[227] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10379,7 +10554,7 @@ func (x *ResolveSubcategoryParentCategoryResponse) String() string { func (*ResolveSubcategoryParentCategoryResponse) ProtoMessage() {} func (x *ResolveSubcategoryParentCategoryResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[223] + mi := &file_product_proto_msgTypes[227] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10392,7 +10567,7 @@ func (x *ResolveSubcategoryParentCategoryResponse) ProtoReflect() protoreflect.M // Deprecated: Use ResolveSubcategoryParentCategoryResponse.ProtoReflect.Descriptor instead. func (*ResolveSubcategoryParentCategoryResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{223} + return file_product_proto_rawDescGZIP(), []int{227} } func (x *ResolveSubcategoryParentCategoryResponse) GetResult() []*ResolveSubcategoryParentCategoryResult { @@ -10411,7 +10586,7 @@ type ResolveCategoryMetricsNormalizedScoreArgs struct { func (x *ResolveCategoryMetricsNormalizedScoreArgs) Reset() { *x = ResolveCategoryMetricsNormalizedScoreArgs{} - mi := &file_product_proto_msgTypes[224] + mi := &file_product_proto_msgTypes[228] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10423,7 +10598,7 @@ func (x *ResolveCategoryMetricsNormalizedScoreArgs) String() string { func (*ResolveCategoryMetricsNormalizedScoreArgs) ProtoMessage() {} func (x *ResolveCategoryMetricsNormalizedScoreArgs) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[224] + mi := &file_product_proto_msgTypes[228] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10436,7 +10611,7 @@ func (x *ResolveCategoryMetricsNormalizedScoreArgs) ProtoReflect() protoreflect. // Deprecated: Use ResolveCategoryMetricsNormalizedScoreArgs.ProtoReflect.Descriptor instead. func (*ResolveCategoryMetricsNormalizedScoreArgs) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{224} + return file_product_proto_rawDescGZIP(), []int{228} } func (x *ResolveCategoryMetricsNormalizedScoreArgs) GetBaseline() float64 { @@ -10457,7 +10632,7 @@ type ResolveCategoryMetricsNormalizedScoreContext struct { func (x *ResolveCategoryMetricsNormalizedScoreContext) Reset() { *x = ResolveCategoryMetricsNormalizedScoreContext{} - mi := &file_product_proto_msgTypes[225] + mi := &file_product_proto_msgTypes[229] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10469,7 +10644,7 @@ func (x *ResolveCategoryMetricsNormalizedScoreContext) String() string { func (*ResolveCategoryMetricsNormalizedScoreContext) ProtoMessage() {} func (x *ResolveCategoryMetricsNormalizedScoreContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[225] + mi := &file_product_proto_msgTypes[229] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10482,7 +10657,7 @@ func (x *ResolveCategoryMetricsNormalizedScoreContext) ProtoReflect() protorefle // Deprecated: Use ResolveCategoryMetricsNormalizedScoreContext.ProtoReflect.Descriptor instead. func (*ResolveCategoryMetricsNormalizedScoreContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{225} + return file_product_proto_rawDescGZIP(), []int{229} } func (x *ResolveCategoryMetricsNormalizedScoreContext) GetId() string { @@ -10518,7 +10693,7 @@ type ResolveCategoryMetricsNormalizedScoreRequest struct { func (x *ResolveCategoryMetricsNormalizedScoreRequest) Reset() { *x = ResolveCategoryMetricsNormalizedScoreRequest{} - mi := &file_product_proto_msgTypes[226] + mi := &file_product_proto_msgTypes[230] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10530,7 +10705,7 @@ func (x *ResolveCategoryMetricsNormalizedScoreRequest) String() string { func (*ResolveCategoryMetricsNormalizedScoreRequest) ProtoMessage() {} func (x *ResolveCategoryMetricsNormalizedScoreRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[226] + mi := &file_product_proto_msgTypes[230] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10543,7 +10718,7 @@ func (x *ResolveCategoryMetricsNormalizedScoreRequest) ProtoReflect() protorefle // Deprecated: Use ResolveCategoryMetricsNormalizedScoreRequest.ProtoReflect.Descriptor instead. func (*ResolveCategoryMetricsNormalizedScoreRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{226} + return file_product_proto_rawDescGZIP(), []int{230} } func (x *ResolveCategoryMetricsNormalizedScoreRequest) GetContext() []*ResolveCategoryMetricsNormalizedScoreContext { @@ -10569,7 +10744,7 @@ type ResolveCategoryMetricsNormalizedScoreResult struct { func (x *ResolveCategoryMetricsNormalizedScoreResult) Reset() { *x = ResolveCategoryMetricsNormalizedScoreResult{} - mi := &file_product_proto_msgTypes[227] + mi := &file_product_proto_msgTypes[231] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10581,7 +10756,7 @@ func (x *ResolveCategoryMetricsNormalizedScoreResult) String() string { func (*ResolveCategoryMetricsNormalizedScoreResult) ProtoMessage() {} func (x *ResolveCategoryMetricsNormalizedScoreResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[227] + mi := &file_product_proto_msgTypes[231] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10594,7 +10769,7 @@ func (x *ResolveCategoryMetricsNormalizedScoreResult) ProtoReflect() protoreflec // Deprecated: Use ResolveCategoryMetricsNormalizedScoreResult.ProtoReflect.Descriptor instead. func (*ResolveCategoryMetricsNormalizedScoreResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{227} + return file_product_proto_rawDescGZIP(), []int{231} } func (x *ResolveCategoryMetricsNormalizedScoreResult) GetNormalizedScore() float64 { @@ -10613,7 +10788,7 @@ type ResolveCategoryMetricsNormalizedScoreResponse struct { func (x *ResolveCategoryMetricsNormalizedScoreResponse) Reset() { *x = ResolveCategoryMetricsNormalizedScoreResponse{} - mi := &file_product_proto_msgTypes[228] + mi := &file_product_proto_msgTypes[232] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10625,7 +10800,7 @@ func (x *ResolveCategoryMetricsNormalizedScoreResponse) String() string { func (*ResolveCategoryMetricsNormalizedScoreResponse) ProtoMessage() {} func (x *ResolveCategoryMetricsNormalizedScoreResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[228] + mi := &file_product_proto_msgTypes[232] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10638,7 +10813,7 @@ func (x *ResolveCategoryMetricsNormalizedScoreResponse) ProtoReflect() protorefl // Deprecated: Use ResolveCategoryMetricsNormalizedScoreResponse.ProtoReflect.Descriptor instead. func (*ResolveCategoryMetricsNormalizedScoreResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{228} + return file_product_proto_rawDescGZIP(), []int{232} } func (x *ResolveCategoryMetricsNormalizedScoreResponse) GetResult() []*ResolveCategoryMetricsNormalizedScoreResult { @@ -10657,7 +10832,7 @@ type ResolveCategoryMetricsRelatedCategoryArgs struct { func (x *ResolveCategoryMetricsRelatedCategoryArgs) Reset() { *x = ResolveCategoryMetricsRelatedCategoryArgs{} - mi := &file_product_proto_msgTypes[229] + mi := &file_product_proto_msgTypes[233] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10669,7 +10844,7 @@ func (x *ResolveCategoryMetricsRelatedCategoryArgs) String() string { func (*ResolveCategoryMetricsRelatedCategoryArgs) ProtoMessage() {} func (x *ResolveCategoryMetricsRelatedCategoryArgs) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[229] + mi := &file_product_proto_msgTypes[233] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10682,7 +10857,7 @@ func (x *ResolveCategoryMetricsRelatedCategoryArgs) ProtoReflect() protoreflect. // Deprecated: Use ResolveCategoryMetricsRelatedCategoryArgs.ProtoReflect.Descriptor instead. func (*ResolveCategoryMetricsRelatedCategoryArgs) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{229} + return file_product_proto_rawDescGZIP(), []int{233} } func (x *ResolveCategoryMetricsRelatedCategoryArgs) GetInclude() *wrapperspb.BoolValue { @@ -10701,7 +10876,7 @@ type ResolveCategoryMetricsRelatedCategoryContext struct { func (x *ResolveCategoryMetricsRelatedCategoryContext) Reset() { *x = ResolveCategoryMetricsRelatedCategoryContext{} - mi := &file_product_proto_msgTypes[230] + mi := &file_product_proto_msgTypes[234] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10713,7 +10888,7 @@ func (x *ResolveCategoryMetricsRelatedCategoryContext) String() string { func (*ResolveCategoryMetricsRelatedCategoryContext) ProtoMessage() {} func (x *ResolveCategoryMetricsRelatedCategoryContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[230] + mi := &file_product_proto_msgTypes[234] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10726,7 +10901,7 @@ func (x *ResolveCategoryMetricsRelatedCategoryContext) ProtoReflect() protorefle // Deprecated: Use ResolveCategoryMetricsRelatedCategoryContext.ProtoReflect.Descriptor instead. func (*ResolveCategoryMetricsRelatedCategoryContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{230} + return file_product_proto_rawDescGZIP(), []int{234} } func (x *ResolveCategoryMetricsRelatedCategoryContext) GetCategoryId() string { @@ -10748,7 +10923,7 @@ type ResolveCategoryMetricsRelatedCategoryRequest struct { func (x *ResolveCategoryMetricsRelatedCategoryRequest) Reset() { *x = ResolveCategoryMetricsRelatedCategoryRequest{} - mi := &file_product_proto_msgTypes[231] + mi := &file_product_proto_msgTypes[235] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10760,7 +10935,7 @@ func (x *ResolveCategoryMetricsRelatedCategoryRequest) String() string { func (*ResolveCategoryMetricsRelatedCategoryRequest) ProtoMessage() {} func (x *ResolveCategoryMetricsRelatedCategoryRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[231] + mi := &file_product_proto_msgTypes[235] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10773,7 +10948,7 @@ func (x *ResolveCategoryMetricsRelatedCategoryRequest) ProtoReflect() protorefle // Deprecated: Use ResolveCategoryMetricsRelatedCategoryRequest.ProtoReflect.Descriptor instead. func (*ResolveCategoryMetricsRelatedCategoryRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{231} + return file_product_proto_rawDescGZIP(), []int{235} } func (x *ResolveCategoryMetricsRelatedCategoryRequest) GetContext() []*ResolveCategoryMetricsRelatedCategoryContext { @@ -10799,7 +10974,7 @@ type ResolveCategoryMetricsRelatedCategoryResult struct { func (x *ResolveCategoryMetricsRelatedCategoryResult) Reset() { *x = ResolveCategoryMetricsRelatedCategoryResult{} - mi := &file_product_proto_msgTypes[232] + mi := &file_product_proto_msgTypes[236] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10811,7 +10986,7 @@ func (x *ResolveCategoryMetricsRelatedCategoryResult) String() string { func (*ResolveCategoryMetricsRelatedCategoryResult) ProtoMessage() {} func (x *ResolveCategoryMetricsRelatedCategoryResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[232] + mi := &file_product_proto_msgTypes[236] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10824,7 +10999,7 @@ func (x *ResolveCategoryMetricsRelatedCategoryResult) ProtoReflect() protoreflec // Deprecated: Use ResolveCategoryMetricsRelatedCategoryResult.ProtoReflect.Descriptor instead. func (*ResolveCategoryMetricsRelatedCategoryResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{232} + return file_product_proto_rawDescGZIP(), []int{236} } func (x *ResolveCategoryMetricsRelatedCategoryResult) GetRelatedCategory() *Category { @@ -10843,7 +11018,7 @@ type ResolveCategoryMetricsRelatedCategoryResponse struct { func (x *ResolveCategoryMetricsRelatedCategoryResponse) Reset() { *x = ResolveCategoryMetricsRelatedCategoryResponse{} - mi := &file_product_proto_msgTypes[233] + mi := &file_product_proto_msgTypes[237] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10855,7 +11030,7 @@ func (x *ResolveCategoryMetricsRelatedCategoryResponse) String() string { func (*ResolveCategoryMetricsRelatedCategoryResponse) ProtoMessage() {} func (x *ResolveCategoryMetricsRelatedCategoryResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[233] + mi := &file_product_proto_msgTypes[237] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10868,7 +11043,7 @@ func (x *ResolveCategoryMetricsRelatedCategoryResponse) ProtoReflect() protorefl // Deprecated: Use ResolveCategoryMetricsRelatedCategoryResponse.ProtoReflect.Descriptor instead. func (*ResolveCategoryMetricsRelatedCategoryResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{233} + return file_product_proto_rawDescGZIP(), []int{237} } func (x *ResolveCategoryMetricsRelatedCategoryResponse) GetResult() []*ResolveCategoryMetricsRelatedCategoryResult { @@ -10888,7 +11063,7 @@ type ResolveCategoryMetricsAverageScoreContext struct { func (x *ResolveCategoryMetricsAverageScoreContext) Reset() { *x = ResolveCategoryMetricsAverageScoreContext{} - mi := &file_product_proto_msgTypes[234] + mi := &file_product_proto_msgTypes[238] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10900,7 +11075,7 @@ func (x *ResolveCategoryMetricsAverageScoreContext) String() string { func (*ResolveCategoryMetricsAverageScoreContext) ProtoMessage() {} func (x *ResolveCategoryMetricsAverageScoreContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[234] + mi := &file_product_proto_msgTypes[238] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10913,7 +11088,7 @@ func (x *ResolveCategoryMetricsAverageScoreContext) ProtoReflect() protoreflect. // Deprecated: Use ResolveCategoryMetricsAverageScoreContext.ProtoReflect.Descriptor instead. func (*ResolveCategoryMetricsAverageScoreContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{234} + return file_product_proto_rawDescGZIP(), []int{238} } func (x *ResolveCategoryMetricsAverageScoreContext) GetId() string { @@ -10940,7 +11115,7 @@ type ResolveCategoryMetricsAverageScoreRequest struct { func (x *ResolveCategoryMetricsAverageScoreRequest) Reset() { *x = ResolveCategoryMetricsAverageScoreRequest{} - mi := &file_product_proto_msgTypes[235] + mi := &file_product_proto_msgTypes[239] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10952,7 +11127,7 @@ func (x *ResolveCategoryMetricsAverageScoreRequest) String() string { func (*ResolveCategoryMetricsAverageScoreRequest) ProtoMessage() {} func (x *ResolveCategoryMetricsAverageScoreRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[235] + mi := &file_product_proto_msgTypes[239] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10965,7 +11140,7 @@ func (x *ResolveCategoryMetricsAverageScoreRequest) ProtoReflect() protoreflect. // Deprecated: Use ResolveCategoryMetricsAverageScoreRequest.ProtoReflect.Descriptor instead. func (*ResolveCategoryMetricsAverageScoreRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{235} + return file_product_proto_rawDescGZIP(), []int{239} } func (x *ResolveCategoryMetricsAverageScoreRequest) GetContext() []*ResolveCategoryMetricsAverageScoreContext { @@ -10984,7 +11159,7 @@ type ResolveCategoryMetricsAverageScoreResult struct { func (x *ResolveCategoryMetricsAverageScoreResult) Reset() { *x = ResolveCategoryMetricsAverageScoreResult{} - mi := &file_product_proto_msgTypes[236] + mi := &file_product_proto_msgTypes[240] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10996,7 +11171,7 @@ func (x *ResolveCategoryMetricsAverageScoreResult) String() string { func (*ResolveCategoryMetricsAverageScoreResult) ProtoMessage() {} func (x *ResolveCategoryMetricsAverageScoreResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[236] + mi := &file_product_proto_msgTypes[240] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11009,7 +11184,7 @@ func (x *ResolveCategoryMetricsAverageScoreResult) ProtoReflect() protoreflect.M // Deprecated: Use ResolveCategoryMetricsAverageScoreResult.ProtoReflect.Descriptor instead. func (*ResolveCategoryMetricsAverageScoreResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{236} + return file_product_proto_rawDescGZIP(), []int{240} } func (x *ResolveCategoryMetricsAverageScoreResult) GetAverageScore() float64 { @@ -11028,7 +11203,7 @@ type ResolveCategoryMetricsAverageScoreResponse struct { func (x *ResolveCategoryMetricsAverageScoreResponse) Reset() { *x = ResolveCategoryMetricsAverageScoreResponse{} - mi := &file_product_proto_msgTypes[237] + mi := &file_product_proto_msgTypes[241] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11040,7 +11215,7 @@ func (x *ResolveCategoryMetricsAverageScoreResponse) String() string { func (*ResolveCategoryMetricsAverageScoreResponse) ProtoMessage() {} func (x *ResolveCategoryMetricsAverageScoreResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[237] + mi := &file_product_proto_msgTypes[241] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11053,7 +11228,7 @@ func (x *ResolveCategoryMetricsAverageScoreResponse) ProtoReflect() protoreflect // Deprecated: Use ResolveCategoryMetricsAverageScoreResponse.ProtoReflect.Descriptor instead. func (*ResolveCategoryMetricsAverageScoreResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{237} + return file_product_proto_rawDescGZIP(), []int{241} } func (x *ResolveCategoryMetricsAverageScoreResponse) GetResult() []*ResolveCategoryMetricsAverageScoreResult { @@ -11072,7 +11247,7 @@ type ResolveTestContainerDetailsArgs struct { func (x *ResolveTestContainerDetailsArgs) Reset() { *x = ResolveTestContainerDetailsArgs{} - mi := &file_product_proto_msgTypes[238] + mi := &file_product_proto_msgTypes[242] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11084,7 +11259,7 @@ func (x *ResolveTestContainerDetailsArgs) String() string { func (*ResolveTestContainerDetailsArgs) ProtoMessage() {} func (x *ResolveTestContainerDetailsArgs) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[238] + mi := &file_product_proto_msgTypes[242] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11097,7 +11272,7 @@ func (x *ResolveTestContainerDetailsArgs) ProtoReflect() protoreflect.Message { // Deprecated: Use ResolveTestContainerDetailsArgs.ProtoReflect.Descriptor instead. func (*ResolveTestContainerDetailsArgs) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{238} + return file_product_proto_rawDescGZIP(), []int{242} } func (x *ResolveTestContainerDetailsArgs) GetIncludeExtended() bool { @@ -11117,7 +11292,7 @@ type ResolveTestContainerDetailsContext struct { func (x *ResolveTestContainerDetailsContext) Reset() { *x = ResolveTestContainerDetailsContext{} - mi := &file_product_proto_msgTypes[239] + mi := &file_product_proto_msgTypes[243] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11129,7 +11304,7 @@ func (x *ResolveTestContainerDetailsContext) String() string { func (*ResolveTestContainerDetailsContext) ProtoMessage() {} func (x *ResolveTestContainerDetailsContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[239] + mi := &file_product_proto_msgTypes[243] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11142,7 +11317,7 @@ func (x *ResolveTestContainerDetailsContext) ProtoReflect() protoreflect.Message // Deprecated: Use ResolveTestContainerDetailsContext.ProtoReflect.Descriptor instead. func (*ResolveTestContainerDetailsContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{239} + return file_product_proto_rawDescGZIP(), []int{243} } func (x *ResolveTestContainerDetailsContext) GetId() string { @@ -11171,7 +11346,7 @@ type ResolveTestContainerDetailsRequest struct { func (x *ResolveTestContainerDetailsRequest) Reset() { *x = ResolveTestContainerDetailsRequest{} - mi := &file_product_proto_msgTypes[240] + mi := &file_product_proto_msgTypes[244] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11183,7 +11358,7 @@ func (x *ResolveTestContainerDetailsRequest) String() string { func (*ResolveTestContainerDetailsRequest) ProtoMessage() {} func (x *ResolveTestContainerDetailsRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[240] + mi := &file_product_proto_msgTypes[244] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11196,7 +11371,7 @@ func (x *ResolveTestContainerDetailsRequest) ProtoReflect() protoreflect.Message // Deprecated: Use ResolveTestContainerDetailsRequest.ProtoReflect.Descriptor instead. func (*ResolveTestContainerDetailsRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{240} + return file_product_proto_rawDescGZIP(), []int{244} } func (x *ResolveTestContainerDetailsRequest) GetContext() []*ResolveTestContainerDetailsContext { @@ -11222,7 +11397,7 @@ type ResolveTestContainerDetailsResult struct { func (x *ResolveTestContainerDetailsResult) Reset() { *x = ResolveTestContainerDetailsResult{} - mi := &file_product_proto_msgTypes[241] + mi := &file_product_proto_msgTypes[245] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11234,7 +11409,7 @@ func (x *ResolveTestContainerDetailsResult) String() string { func (*ResolveTestContainerDetailsResult) ProtoMessage() {} func (x *ResolveTestContainerDetailsResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[241] + mi := &file_product_proto_msgTypes[245] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11247,7 +11422,7 @@ func (x *ResolveTestContainerDetailsResult) ProtoReflect() protoreflect.Message // Deprecated: Use ResolveTestContainerDetailsResult.ProtoReflect.Descriptor instead. func (*ResolveTestContainerDetailsResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{241} + return file_product_proto_rawDescGZIP(), []int{245} } func (x *ResolveTestContainerDetailsResult) GetDetails() *TestDetails { @@ -11266,7 +11441,7 @@ type ResolveTestContainerDetailsResponse struct { func (x *ResolveTestContainerDetailsResponse) Reset() { *x = ResolveTestContainerDetailsResponse{} - mi := &file_product_proto_msgTypes[242] + mi := &file_product_proto_msgTypes[246] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11278,7 +11453,7 @@ func (x *ResolveTestContainerDetailsResponse) String() string { func (*ResolveTestContainerDetailsResponse) ProtoMessage() {} func (x *ResolveTestContainerDetailsResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[242] + mi := &file_product_proto_msgTypes[246] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11291,7 +11466,7 @@ func (x *ResolveTestContainerDetailsResponse) ProtoReflect() protoreflect.Messag // Deprecated: Use ResolveTestContainerDetailsResponse.ProtoReflect.Descriptor instead. func (*ResolveTestContainerDetailsResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{242} + return file_product_proto_rawDescGZIP(), []int{246} } func (x *ResolveTestContainerDetailsResponse) GetResult() []*ResolveTestContainerDetailsResult { @@ -11311,7 +11486,7 @@ type RequireStorageStockHealthScoreByIdRequest struct { func (x *RequireStorageStockHealthScoreByIdRequest) Reset() { *x = RequireStorageStockHealthScoreByIdRequest{} - mi := &file_product_proto_msgTypes[243] + mi := &file_product_proto_msgTypes[247] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11323,7 +11498,7 @@ func (x *RequireStorageStockHealthScoreByIdRequest) String() string { func (*RequireStorageStockHealthScoreByIdRequest) ProtoMessage() {} func (x *RequireStorageStockHealthScoreByIdRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[243] + mi := &file_product_proto_msgTypes[247] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11336,7 +11511,7 @@ func (x *RequireStorageStockHealthScoreByIdRequest) ProtoReflect() protoreflect. // Deprecated: Use RequireStorageStockHealthScoreByIdRequest.ProtoReflect.Descriptor instead. func (*RequireStorageStockHealthScoreByIdRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{243} + return file_product_proto_rawDescGZIP(), []int{247} } func (x *RequireStorageStockHealthScoreByIdRequest) GetContext() []*RequireStorageStockHealthScoreByIdContext { @@ -11356,7 +11531,7 @@ type RequireStorageStockHealthScoreByIdContext struct { func (x *RequireStorageStockHealthScoreByIdContext) Reset() { *x = RequireStorageStockHealthScoreByIdContext{} - mi := &file_product_proto_msgTypes[244] + mi := &file_product_proto_msgTypes[248] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11368,7 +11543,7 @@ func (x *RequireStorageStockHealthScoreByIdContext) String() string { func (*RequireStorageStockHealthScoreByIdContext) ProtoMessage() {} func (x *RequireStorageStockHealthScoreByIdContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[244] + mi := &file_product_proto_msgTypes[248] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11381,7 +11556,7 @@ func (x *RequireStorageStockHealthScoreByIdContext) ProtoReflect() protoreflect. // Deprecated: Use RequireStorageStockHealthScoreByIdContext.ProtoReflect.Descriptor instead. func (*RequireStorageStockHealthScoreByIdContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{244} + return file_product_proto_rawDescGZIP(), []int{248} } func (x *RequireStorageStockHealthScoreByIdContext) GetKey() *LookupStorageByIdRequestKey { @@ -11408,7 +11583,7 @@ type RequireStorageStockHealthScoreByIdResponse struct { func (x *RequireStorageStockHealthScoreByIdResponse) Reset() { *x = RequireStorageStockHealthScoreByIdResponse{} - mi := &file_product_proto_msgTypes[245] + mi := &file_product_proto_msgTypes[249] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11420,7 +11595,7 @@ func (x *RequireStorageStockHealthScoreByIdResponse) String() string { func (*RequireStorageStockHealthScoreByIdResponse) ProtoMessage() {} func (x *RequireStorageStockHealthScoreByIdResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[245] + mi := &file_product_proto_msgTypes[249] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11433,7 +11608,7 @@ func (x *RequireStorageStockHealthScoreByIdResponse) ProtoReflect() protoreflect // Deprecated: Use RequireStorageStockHealthScoreByIdResponse.ProtoReflect.Descriptor instead. func (*RequireStorageStockHealthScoreByIdResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{245} + return file_product_proto_rawDescGZIP(), []int{249} } func (x *RequireStorageStockHealthScoreByIdResponse) GetResult() []*RequireStorageStockHealthScoreByIdResult { @@ -11452,7 +11627,7 @@ type RequireStorageStockHealthScoreByIdResult struct { func (x *RequireStorageStockHealthScoreByIdResult) Reset() { *x = RequireStorageStockHealthScoreByIdResult{} - mi := &file_product_proto_msgTypes[246] + mi := &file_product_proto_msgTypes[250] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11464,7 +11639,7 @@ func (x *RequireStorageStockHealthScoreByIdResult) String() string { func (*RequireStorageStockHealthScoreByIdResult) ProtoMessage() {} func (x *RequireStorageStockHealthScoreByIdResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[246] + mi := &file_product_proto_msgTypes[250] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11477,7 +11652,7 @@ func (x *RequireStorageStockHealthScoreByIdResult) ProtoReflect() protoreflect.M // Deprecated: Use RequireStorageStockHealthScoreByIdResult.ProtoReflect.Descriptor instead. func (*RequireStorageStockHealthScoreByIdResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{246} + return file_product_proto_rawDescGZIP(), []int{250} } func (x *RequireStorageStockHealthScoreByIdResult) GetStockHealthScore() float64 { @@ -11497,7 +11672,7 @@ type RequireStorageStockHealthScoreByIdFields struct { func (x *RequireStorageStockHealthScoreByIdFields) Reset() { *x = RequireStorageStockHealthScoreByIdFields{} - mi := &file_product_proto_msgTypes[247] + mi := &file_product_proto_msgTypes[251] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11509,7 +11684,7 @@ func (x *RequireStorageStockHealthScoreByIdFields) String() string { func (*RequireStorageStockHealthScoreByIdFields) ProtoMessage() {} func (x *RequireStorageStockHealthScoreByIdFields) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[247] + mi := &file_product_proto_msgTypes[251] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11522,7 +11697,7 @@ func (x *RequireStorageStockHealthScoreByIdFields) ProtoReflect() protoreflect.M // Deprecated: Use RequireStorageStockHealthScoreByIdFields.ProtoReflect.Descriptor instead. func (*RequireStorageStockHealthScoreByIdFields) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{247} + return file_product_proto_rawDescGZIP(), []int{251} } func (x *RequireStorageStockHealthScoreByIdFields) GetItemCount() int32 { @@ -11549,7 +11724,7 @@ type RequireStorageTagSummaryByIdRequest struct { func (x *RequireStorageTagSummaryByIdRequest) Reset() { *x = RequireStorageTagSummaryByIdRequest{} - mi := &file_product_proto_msgTypes[248] + mi := &file_product_proto_msgTypes[252] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11561,7 +11736,7 @@ func (x *RequireStorageTagSummaryByIdRequest) String() string { func (*RequireStorageTagSummaryByIdRequest) ProtoMessage() {} func (x *RequireStorageTagSummaryByIdRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[248] + mi := &file_product_proto_msgTypes[252] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11574,7 +11749,7 @@ func (x *RequireStorageTagSummaryByIdRequest) ProtoReflect() protoreflect.Messag // Deprecated: Use RequireStorageTagSummaryByIdRequest.ProtoReflect.Descriptor instead. func (*RequireStorageTagSummaryByIdRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{248} + return file_product_proto_rawDescGZIP(), []int{252} } func (x *RequireStorageTagSummaryByIdRequest) GetContext() []*RequireStorageTagSummaryByIdContext { @@ -11594,7 +11769,7 @@ type RequireStorageTagSummaryByIdContext struct { func (x *RequireStorageTagSummaryByIdContext) Reset() { *x = RequireStorageTagSummaryByIdContext{} - mi := &file_product_proto_msgTypes[249] + mi := &file_product_proto_msgTypes[253] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11606,7 +11781,7 @@ func (x *RequireStorageTagSummaryByIdContext) String() string { func (*RequireStorageTagSummaryByIdContext) ProtoMessage() {} func (x *RequireStorageTagSummaryByIdContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[249] + mi := &file_product_proto_msgTypes[253] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11619,7 +11794,7 @@ func (x *RequireStorageTagSummaryByIdContext) ProtoReflect() protoreflect.Messag // Deprecated: Use RequireStorageTagSummaryByIdContext.ProtoReflect.Descriptor instead. func (*RequireStorageTagSummaryByIdContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{249} + return file_product_proto_rawDescGZIP(), []int{253} } func (x *RequireStorageTagSummaryByIdContext) GetKey() *LookupStorageByIdRequestKey { @@ -11646,7 +11821,7 @@ type RequireStorageTagSummaryByIdResponse struct { func (x *RequireStorageTagSummaryByIdResponse) Reset() { *x = RequireStorageTagSummaryByIdResponse{} - mi := &file_product_proto_msgTypes[250] + mi := &file_product_proto_msgTypes[254] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11658,7 +11833,7 @@ func (x *RequireStorageTagSummaryByIdResponse) String() string { func (*RequireStorageTagSummaryByIdResponse) ProtoMessage() {} func (x *RequireStorageTagSummaryByIdResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[250] + mi := &file_product_proto_msgTypes[254] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11671,7 +11846,7 @@ func (x *RequireStorageTagSummaryByIdResponse) ProtoReflect() protoreflect.Messa // Deprecated: Use RequireStorageTagSummaryByIdResponse.ProtoReflect.Descriptor instead. func (*RequireStorageTagSummaryByIdResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{250} + return file_product_proto_rawDescGZIP(), []int{254} } func (x *RequireStorageTagSummaryByIdResponse) GetResult() []*RequireStorageTagSummaryByIdResult { @@ -11690,7 +11865,7 @@ type RequireStorageTagSummaryByIdResult struct { func (x *RequireStorageTagSummaryByIdResult) Reset() { *x = RequireStorageTagSummaryByIdResult{} - mi := &file_product_proto_msgTypes[251] + mi := &file_product_proto_msgTypes[255] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11702,7 +11877,7 @@ func (x *RequireStorageTagSummaryByIdResult) String() string { func (*RequireStorageTagSummaryByIdResult) ProtoMessage() {} func (x *RequireStorageTagSummaryByIdResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[251] + mi := &file_product_proto_msgTypes[255] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11715,7 +11890,7 @@ func (x *RequireStorageTagSummaryByIdResult) ProtoReflect() protoreflect.Message // Deprecated: Use RequireStorageTagSummaryByIdResult.ProtoReflect.Descriptor instead. func (*RequireStorageTagSummaryByIdResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{251} + return file_product_proto_rawDescGZIP(), []int{255} } func (x *RequireStorageTagSummaryByIdResult) GetTagSummary() string { @@ -11734,7 +11909,7 @@ type RequireStorageTagSummaryByIdFields struct { func (x *RequireStorageTagSummaryByIdFields) Reset() { *x = RequireStorageTagSummaryByIdFields{} - mi := &file_product_proto_msgTypes[252] + mi := &file_product_proto_msgTypes[256] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11746,7 +11921,7 @@ func (x *RequireStorageTagSummaryByIdFields) String() string { func (*RequireStorageTagSummaryByIdFields) ProtoMessage() {} func (x *RequireStorageTagSummaryByIdFields) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[252] + mi := &file_product_proto_msgTypes[256] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11759,7 +11934,7 @@ func (x *RequireStorageTagSummaryByIdFields) ProtoReflect() protoreflect.Message // Deprecated: Use RequireStorageTagSummaryByIdFields.ProtoReflect.Descriptor instead. func (*RequireStorageTagSummaryByIdFields) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{252} + return file_product_proto_rawDescGZIP(), []int{256} } func (x *RequireStorageTagSummaryByIdFields) GetTags() []string { @@ -11779,7 +11954,7 @@ type RequireStorageOptionalTagSummaryByIdRequest struct { func (x *RequireStorageOptionalTagSummaryByIdRequest) Reset() { *x = RequireStorageOptionalTagSummaryByIdRequest{} - mi := &file_product_proto_msgTypes[253] + mi := &file_product_proto_msgTypes[257] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11791,7 +11966,7 @@ func (x *RequireStorageOptionalTagSummaryByIdRequest) String() string { func (*RequireStorageOptionalTagSummaryByIdRequest) ProtoMessage() {} func (x *RequireStorageOptionalTagSummaryByIdRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[253] + mi := &file_product_proto_msgTypes[257] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11804,7 +11979,7 @@ func (x *RequireStorageOptionalTagSummaryByIdRequest) ProtoReflect() protoreflec // Deprecated: Use RequireStorageOptionalTagSummaryByIdRequest.ProtoReflect.Descriptor instead. func (*RequireStorageOptionalTagSummaryByIdRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{253} + return file_product_proto_rawDescGZIP(), []int{257} } func (x *RequireStorageOptionalTagSummaryByIdRequest) GetContext() []*RequireStorageOptionalTagSummaryByIdContext { @@ -11824,7 +11999,7 @@ type RequireStorageOptionalTagSummaryByIdContext struct { func (x *RequireStorageOptionalTagSummaryByIdContext) Reset() { *x = RequireStorageOptionalTagSummaryByIdContext{} - mi := &file_product_proto_msgTypes[254] + mi := &file_product_proto_msgTypes[258] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11836,7 +12011,7 @@ func (x *RequireStorageOptionalTagSummaryByIdContext) String() string { func (*RequireStorageOptionalTagSummaryByIdContext) ProtoMessage() {} func (x *RequireStorageOptionalTagSummaryByIdContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[254] + mi := &file_product_proto_msgTypes[258] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11849,7 +12024,7 @@ func (x *RequireStorageOptionalTagSummaryByIdContext) ProtoReflect() protoreflec // Deprecated: Use RequireStorageOptionalTagSummaryByIdContext.ProtoReflect.Descriptor instead. func (*RequireStorageOptionalTagSummaryByIdContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{254} + return file_product_proto_rawDescGZIP(), []int{258} } func (x *RequireStorageOptionalTagSummaryByIdContext) GetKey() *LookupStorageByIdRequestKey { @@ -11876,7 +12051,7 @@ type RequireStorageOptionalTagSummaryByIdResponse struct { func (x *RequireStorageOptionalTagSummaryByIdResponse) Reset() { *x = RequireStorageOptionalTagSummaryByIdResponse{} - mi := &file_product_proto_msgTypes[255] + mi := &file_product_proto_msgTypes[259] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11888,7 +12063,7 @@ func (x *RequireStorageOptionalTagSummaryByIdResponse) String() string { func (*RequireStorageOptionalTagSummaryByIdResponse) ProtoMessage() {} func (x *RequireStorageOptionalTagSummaryByIdResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[255] + mi := &file_product_proto_msgTypes[259] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11901,7 +12076,7 @@ func (x *RequireStorageOptionalTagSummaryByIdResponse) ProtoReflect() protorefle // Deprecated: Use RequireStorageOptionalTagSummaryByIdResponse.ProtoReflect.Descriptor instead. func (*RequireStorageOptionalTagSummaryByIdResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{255} + return file_product_proto_rawDescGZIP(), []int{259} } func (x *RequireStorageOptionalTagSummaryByIdResponse) GetResult() []*RequireStorageOptionalTagSummaryByIdResult { @@ -11920,7 +12095,7 @@ type RequireStorageOptionalTagSummaryByIdResult struct { func (x *RequireStorageOptionalTagSummaryByIdResult) Reset() { *x = RequireStorageOptionalTagSummaryByIdResult{} - mi := &file_product_proto_msgTypes[256] + mi := &file_product_proto_msgTypes[260] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11932,7 +12107,7 @@ func (x *RequireStorageOptionalTagSummaryByIdResult) String() string { func (*RequireStorageOptionalTagSummaryByIdResult) ProtoMessage() {} func (x *RequireStorageOptionalTagSummaryByIdResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[256] + mi := &file_product_proto_msgTypes[260] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11945,7 +12120,7 @@ func (x *RequireStorageOptionalTagSummaryByIdResult) ProtoReflect() protoreflect // Deprecated: Use RequireStorageOptionalTagSummaryByIdResult.ProtoReflect.Descriptor instead. func (*RequireStorageOptionalTagSummaryByIdResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{256} + return file_product_proto_rawDescGZIP(), []int{260} } func (x *RequireStorageOptionalTagSummaryByIdResult) GetOptionalTagSummary() *wrapperspb.StringValue { @@ -11964,7 +12139,7 @@ type RequireStorageOptionalTagSummaryByIdFields struct { func (x *RequireStorageOptionalTagSummaryByIdFields) Reset() { *x = RequireStorageOptionalTagSummaryByIdFields{} - mi := &file_product_proto_msgTypes[257] + mi := &file_product_proto_msgTypes[261] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11976,7 +12151,7 @@ func (x *RequireStorageOptionalTagSummaryByIdFields) String() string { func (*RequireStorageOptionalTagSummaryByIdFields) ProtoMessage() {} func (x *RequireStorageOptionalTagSummaryByIdFields) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[257] + mi := &file_product_proto_msgTypes[261] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11989,7 +12164,7 @@ func (x *RequireStorageOptionalTagSummaryByIdFields) ProtoReflect() protoreflect // Deprecated: Use RequireStorageOptionalTagSummaryByIdFields.ProtoReflect.Descriptor instead. func (*RequireStorageOptionalTagSummaryByIdFields) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{257} + return file_product_proto_rawDescGZIP(), []int{261} } func (x *RequireStorageOptionalTagSummaryByIdFields) GetOptionalTags() *ListOfString { @@ -12009,7 +12184,7 @@ type RequireStorageMetadataScoreByIdRequest struct { func (x *RequireStorageMetadataScoreByIdRequest) Reset() { *x = RequireStorageMetadataScoreByIdRequest{} - mi := &file_product_proto_msgTypes[258] + mi := &file_product_proto_msgTypes[262] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12021,7 +12196,7 @@ func (x *RequireStorageMetadataScoreByIdRequest) String() string { func (*RequireStorageMetadataScoreByIdRequest) ProtoMessage() {} func (x *RequireStorageMetadataScoreByIdRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[258] + mi := &file_product_proto_msgTypes[262] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12034,7 +12209,7 @@ func (x *RequireStorageMetadataScoreByIdRequest) ProtoReflect() protoreflect.Mes // Deprecated: Use RequireStorageMetadataScoreByIdRequest.ProtoReflect.Descriptor instead. func (*RequireStorageMetadataScoreByIdRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{258} + return file_product_proto_rawDescGZIP(), []int{262} } func (x *RequireStorageMetadataScoreByIdRequest) GetContext() []*RequireStorageMetadataScoreByIdContext { @@ -12054,7 +12229,7 @@ type RequireStorageMetadataScoreByIdContext struct { func (x *RequireStorageMetadataScoreByIdContext) Reset() { *x = RequireStorageMetadataScoreByIdContext{} - mi := &file_product_proto_msgTypes[259] + mi := &file_product_proto_msgTypes[263] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12066,7 +12241,7 @@ func (x *RequireStorageMetadataScoreByIdContext) String() string { func (*RequireStorageMetadataScoreByIdContext) ProtoMessage() {} func (x *RequireStorageMetadataScoreByIdContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[259] + mi := &file_product_proto_msgTypes[263] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12079,7 +12254,7 @@ func (x *RequireStorageMetadataScoreByIdContext) ProtoReflect() protoreflect.Mes // Deprecated: Use RequireStorageMetadataScoreByIdContext.ProtoReflect.Descriptor instead. func (*RequireStorageMetadataScoreByIdContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{259} + return file_product_proto_rawDescGZIP(), []int{263} } func (x *RequireStorageMetadataScoreByIdContext) GetKey() *LookupStorageByIdRequestKey { @@ -12106,7 +12281,7 @@ type RequireStorageMetadataScoreByIdResponse struct { func (x *RequireStorageMetadataScoreByIdResponse) Reset() { *x = RequireStorageMetadataScoreByIdResponse{} - mi := &file_product_proto_msgTypes[260] + mi := &file_product_proto_msgTypes[264] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12118,7 +12293,7 @@ func (x *RequireStorageMetadataScoreByIdResponse) String() string { func (*RequireStorageMetadataScoreByIdResponse) ProtoMessage() {} func (x *RequireStorageMetadataScoreByIdResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[260] + mi := &file_product_proto_msgTypes[264] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12131,7 +12306,7 @@ func (x *RequireStorageMetadataScoreByIdResponse) ProtoReflect() protoreflect.Me // Deprecated: Use RequireStorageMetadataScoreByIdResponse.ProtoReflect.Descriptor instead. func (*RequireStorageMetadataScoreByIdResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{260} + return file_product_proto_rawDescGZIP(), []int{264} } func (x *RequireStorageMetadataScoreByIdResponse) GetResult() []*RequireStorageMetadataScoreByIdResult { @@ -12150,7 +12325,7 @@ type RequireStorageMetadataScoreByIdResult struct { func (x *RequireStorageMetadataScoreByIdResult) Reset() { *x = RequireStorageMetadataScoreByIdResult{} - mi := &file_product_proto_msgTypes[261] + mi := &file_product_proto_msgTypes[265] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12162,7 +12337,7 @@ func (x *RequireStorageMetadataScoreByIdResult) String() string { func (*RequireStorageMetadataScoreByIdResult) ProtoMessage() {} func (x *RequireStorageMetadataScoreByIdResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[261] + mi := &file_product_proto_msgTypes[265] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12175,7 +12350,7 @@ func (x *RequireStorageMetadataScoreByIdResult) ProtoReflect() protoreflect.Mess // Deprecated: Use RequireStorageMetadataScoreByIdResult.ProtoReflect.Descriptor instead. func (*RequireStorageMetadataScoreByIdResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{261} + return file_product_proto_rawDescGZIP(), []int{265} } func (x *RequireStorageMetadataScoreByIdResult) GetMetadataScore() float64 { @@ -12194,7 +12369,7 @@ type RequireStorageMetadataScoreByIdFields struct { func (x *RequireStorageMetadataScoreByIdFields) Reset() { *x = RequireStorageMetadataScoreByIdFields{} - mi := &file_product_proto_msgTypes[262] + mi := &file_product_proto_msgTypes[266] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12206,7 +12381,7 @@ func (x *RequireStorageMetadataScoreByIdFields) String() string { func (*RequireStorageMetadataScoreByIdFields) ProtoMessage() {} func (x *RequireStorageMetadataScoreByIdFields) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[262] + mi := &file_product_proto_msgTypes[266] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12219,7 +12394,7 @@ func (x *RequireStorageMetadataScoreByIdFields) ProtoReflect() protoreflect.Mess // Deprecated: Use RequireStorageMetadataScoreByIdFields.ProtoReflect.Descriptor instead. func (*RequireStorageMetadataScoreByIdFields) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{262} + return file_product_proto_rawDescGZIP(), []int{266} } func (x *RequireStorageMetadataScoreByIdFields) GetMetadata() *RequireStorageMetadataScoreByIdFields_StorageMetadata { @@ -12239,7 +12414,7 @@ type RequireStorageProcessedMetadataByIdRequest struct { func (x *RequireStorageProcessedMetadataByIdRequest) Reset() { *x = RequireStorageProcessedMetadataByIdRequest{} - mi := &file_product_proto_msgTypes[263] + mi := &file_product_proto_msgTypes[267] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12251,7 +12426,7 @@ func (x *RequireStorageProcessedMetadataByIdRequest) String() string { func (*RequireStorageProcessedMetadataByIdRequest) ProtoMessage() {} func (x *RequireStorageProcessedMetadataByIdRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[263] + mi := &file_product_proto_msgTypes[267] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12264,7 +12439,7 @@ func (x *RequireStorageProcessedMetadataByIdRequest) ProtoReflect() protoreflect // Deprecated: Use RequireStorageProcessedMetadataByIdRequest.ProtoReflect.Descriptor instead. func (*RequireStorageProcessedMetadataByIdRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{263} + return file_product_proto_rawDescGZIP(), []int{267} } func (x *RequireStorageProcessedMetadataByIdRequest) GetContext() []*RequireStorageProcessedMetadataByIdContext { @@ -12284,7 +12459,7 @@ type RequireStorageProcessedMetadataByIdContext struct { func (x *RequireStorageProcessedMetadataByIdContext) Reset() { *x = RequireStorageProcessedMetadataByIdContext{} - mi := &file_product_proto_msgTypes[264] + mi := &file_product_proto_msgTypes[268] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12296,7 +12471,7 @@ func (x *RequireStorageProcessedMetadataByIdContext) String() string { func (*RequireStorageProcessedMetadataByIdContext) ProtoMessage() {} func (x *RequireStorageProcessedMetadataByIdContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[264] + mi := &file_product_proto_msgTypes[268] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12309,7 +12484,7 @@ func (x *RequireStorageProcessedMetadataByIdContext) ProtoReflect() protoreflect // Deprecated: Use RequireStorageProcessedMetadataByIdContext.ProtoReflect.Descriptor instead. func (*RequireStorageProcessedMetadataByIdContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{264} + return file_product_proto_rawDescGZIP(), []int{268} } func (x *RequireStorageProcessedMetadataByIdContext) GetKey() *LookupStorageByIdRequestKey { @@ -12336,7 +12511,7 @@ type RequireStorageProcessedMetadataByIdResponse struct { func (x *RequireStorageProcessedMetadataByIdResponse) Reset() { *x = RequireStorageProcessedMetadataByIdResponse{} - mi := &file_product_proto_msgTypes[265] + mi := &file_product_proto_msgTypes[269] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12348,7 +12523,7 @@ func (x *RequireStorageProcessedMetadataByIdResponse) String() string { func (*RequireStorageProcessedMetadataByIdResponse) ProtoMessage() {} func (x *RequireStorageProcessedMetadataByIdResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[265] + mi := &file_product_proto_msgTypes[269] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12361,7 +12536,7 @@ func (x *RequireStorageProcessedMetadataByIdResponse) ProtoReflect() protoreflec // Deprecated: Use RequireStorageProcessedMetadataByIdResponse.ProtoReflect.Descriptor instead. func (*RequireStorageProcessedMetadataByIdResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{265} + return file_product_proto_rawDescGZIP(), []int{269} } func (x *RequireStorageProcessedMetadataByIdResponse) GetResult() []*RequireStorageProcessedMetadataByIdResult { @@ -12380,7 +12555,7 @@ type RequireStorageProcessedMetadataByIdResult struct { func (x *RequireStorageProcessedMetadataByIdResult) Reset() { *x = RequireStorageProcessedMetadataByIdResult{} - mi := &file_product_proto_msgTypes[266] + mi := &file_product_proto_msgTypes[270] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12392,7 +12567,7 @@ func (x *RequireStorageProcessedMetadataByIdResult) String() string { func (*RequireStorageProcessedMetadataByIdResult) ProtoMessage() {} func (x *RequireStorageProcessedMetadataByIdResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[266] + mi := &file_product_proto_msgTypes[270] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12405,7 +12580,7 @@ func (x *RequireStorageProcessedMetadataByIdResult) ProtoReflect() protoreflect. // Deprecated: Use RequireStorageProcessedMetadataByIdResult.ProtoReflect.Descriptor instead. func (*RequireStorageProcessedMetadataByIdResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{266} + return file_product_proto_rawDescGZIP(), []int{270} } func (x *RequireStorageProcessedMetadataByIdResult) GetProcessedMetadata() *StorageMetadata { @@ -12424,7 +12599,7 @@ type RequireStorageProcessedMetadataByIdFields struct { func (x *RequireStorageProcessedMetadataByIdFields) Reset() { *x = RequireStorageProcessedMetadataByIdFields{} - mi := &file_product_proto_msgTypes[267] + mi := &file_product_proto_msgTypes[271] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12436,7 +12611,7 @@ func (x *RequireStorageProcessedMetadataByIdFields) String() string { func (*RequireStorageProcessedMetadataByIdFields) ProtoMessage() {} func (x *RequireStorageProcessedMetadataByIdFields) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[267] + mi := &file_product_proto_msgTypes[271] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12449,7 +12624,7 @@ func (x *RequireStorageProcessedMetadataByIdFields) ProtoReflect() protoreflect. // Deprecated: Use RequireStorageProcessedMetadataByIdFields.ProtoReflect.Descriptor instead. func (*RequireStorageProcessedMetadataByIdFields) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{267} + return file_product_proto_rawDescGZIP(), []int{271} } func (x *RequireStorageProcessedMetadataByIdFields) GetMetadata() *RequireStorageProcessedMetadataByIdFields_StorageMetadata { @@ -12469,7 +12644,7 @@ type RequireStorageOptionalProcessedMetadataByIdRequest struct { func (x *RequireStorageOptionalProcessedMetadataByIdRequest) Reset() { *x = RequireStorageOptionalProcessedMetadataByIdRequest{} - mi := &file_product_proto_msgTypes[268] + mi := &file_product_proto_msgTypes[272] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12481,7 +12656,7 @@ func (x *RequireStorageOptionalProcessedMetadataByIdRequest) String() string { func (*RequireStorageOptionalProcessedMetadataByIdRequest) ProtoMessage() {} func (x *RequireStorageOptionalProcessedMetadataByIdRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[268] + mi := &file_product_proto_msgTypes[272] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12494,7 +12669,7 @@ func (x *RequireStorageOptionalProcessedMetadataByIdRequest) ProtoReflect() prot // Deprecated: Use RequireStorageOptionalProcessedMetadataByIdRequest.ProtoReflect.Descriptor instead. func (*RequireStorageOptionalProcessedMetadataByIdRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{268} + return file_product_proto_rawDescGZIP(), []int{272} } func (x *RequireStorageOptionalProcessedMetadataByIdRequest) GetContext() []*RequireStorageOptionalProcessedMetadataByIdContext { @@ -12514,7 +12689,7 @@ type RequireStorageOptionalProcessedMetadataByIdContext struct { func (x *RequireStorageOptionalProcessedMetadataByIdContext) Reset() { *x = RequireStorageOptionalProcessedMetadataByIdContext{} - mi := &file_product_proto_msgTypes[269] + mi := &file_product_proto_msgTypes[273] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12526,7 +12701,7 @@ func (x *RequireStorageOptionalProcessedMetadataByIdContext) String() string { func (*RequireStorageOptionalProcessedMetadataByIdContext) ProtoMessage() {} func (x *RequireStorageOptionalProcessedMetadataByIdContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[269] + mi := &file_product_proto_msgTypes[273] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12539,7 +12714,7 @@ func (x *RequireStorageOptionalProcessedMetadataByIdContext) ProtoReflect() prot // Deprecated: Use RequireStorageOptionalProcessedMetadataByIdContext.ProtoReflect.Descriptor instead. func (*RequireStorageOptionalProcessedMetadataByIdContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{269} + return file_product_proto_rawDescGZIP(), []int{273} } func (x *RequireStorageOptionalProcessedMetadataByIdContext) GetKey() *LookupStorageByIdRequestKey { @@ -12566,7 +12741,7 @@ type RequireStorageOptionalProcessedMetadataByIdResponse struct { func (x *RequireStorageOptionalProcessedMetadataByIdResponse) Reset() { *x = RequireStorageOptionalProcessedMetadataByIdResponse{} - mi := &file_product_proto_msgTypes[270] + mi := &file_product_proto_msgTypes[274] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12578,7 +12753,7 @@ func (x *RequireStorageOptionalProcessedMetadataByIdResponse) String() string { func (*RequireStorageOptionalProcessedMetadataByIdResponse) ProtoMessage() {} func (x *RequireStorageOptionalProcessedMetadataByIdResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[270] + mi := &file_product_proto_msgTypes[274] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12591,7 +12766,7 @@ func (x *RequireStorageOptionalProcessedMetadataByIdResponse) ProtoReflect() pro // Deprecated: Use RequireStorageOptionalProcessedMetadataByIdResponse.ProtoReflect.Descriptor instead. func (*RequireStorageOptionalProcessedMetadataByIdResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{270} + return file_product_proto_rawDescGZIP(), []int{274} } func (x *RequireStorageOptionalProcessedMetadataByIdResponse) GetResult() []*RequireStorageOptionalProcessedMetadataByIdResult { @@ -12610,7 +12785,7 @@ type RequireStorageOptionalProcessedMetadataByIdResult struct { func (x *RequireStorageOptionalProcessedMetadataByIdResult) Reset() { *x = RequireStorageOptionalProcessedMetadataByIdResult{} - mi := &file_product_proto_msgTypes[271] + mi := &file_product_proto_msgTypes[275] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12622,7 +12797,7 @@ func (x *RequireStorageOptionalProcessedMetadataByIdResult) String() string { func (*RequireStorageOptionalProcessedMetadataByIdResult) ProtoMessage() {} func (x *RequireStorageOptionalProcessedMetadataByIdResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[271] + mi := &file_product_proto_msgTypes[275] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12635,7 +12810,7 @@ func (x *RequireStorageOptionalProcessedMetadataByIdResult) ProtoReflect() proto // Deprecated: Use RequireStorageOptionalProcessedMetadataByIdResult.ProtoReflect.Descriptor instead. func (*RequireStorageOptionalProcessedMetadataByIdResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{271} + return file_product_proto_rawDescGZIP(), []int{275} } func (x *RequireStorageOptionalProcessedMetadataByIdResult) GetOptionalProcessedMetadata() *StorageMetadata { @@ -12654,7 +12829,7 @@ type RequireStorageOptionalProcessedMetadataByIdFields struct { func (x *RequireStorageOptionalProcessedMetadataByIdFields) Reset() { *x = RequireStorageOptionalProcessedMetadataByIdFields{} - mi := &file_product_proto_msgTypes[272] + mi := &file_product_proto_msgTypes[276] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12666,7 +12841,7 @@ func (x *RequireStorageOptionalProcessedMetadataByIdFields) String() string { func (*RequireStorageOptionalProcessedMetadataByIdFields) ProtoMessage() {} func (x *RequireStorageOptionalProcessedMetadataByIdFields) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[272] + mi := &file_product_proto_msgTypes[276] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12679,7 +12854,7 @@ func (x *RequireStorageOptionalProcessedMetadataByIdFields) ProtoReflect() proto // Deprecated: Use RequireStorageOptionalProcessedMetadataByIdFields.ProtoReflect.Descriptor instead. func (*RequireStorageOptionalProcessedMetadataByIdFields) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{272} + return file_product_proto_rawDescGZIP(), []int{276} } func (x *RequireStorageOptionalProcessedMetadataByIdFields) GetMetadata() *RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata { @@ -12699,7 +12874,7 @@ type RequireStorageProcessedTagsByIdRequest struct { func (x *RequireStorageProcessedTagsByIdRequest) Reset() { *x = RequireStorageProcessedTagsByIdRequest{} - mi := &file_product_proto_msgTypes[273] + mi := &file_product_proto_msgTypes[277] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12711,7 +12886,7 @@ func (x *RequireStorageProcessedTagsByIdRequest) String() string { func (*RequireStorageProcessedTagsByIdRequest) ProtoMessage() {} func (x *RequireStorageProcessedTagsByIdRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[273] + mi := &file_product_proto_msgTypes[277] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12724,7 +12899,7 @@ func (x *RequireStorageProcessedTagsByIdRequest) ProtoReflect() protoreflect.Mes // Deprecated: Use RequireStorageProcessedTagsByIdRequest.ProtoReflect.Descriptor instead. func (*RequireStorageProcessedTagsByIdRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{273} + return file_product_proto_rawDescGZIP(), []int{277} } func (x *RequireStorageProcessedTagsByIdRequest) GetContext() []*RequireStorageProcessedTagsByIdContext { @@ -12744,7 +12919,7 @@ type RequireStorageProcessedTagsByIdContext struct { func (x *RequireStorageProcessedTagsByIdContext) Reset() { *x = RequireStorageProcessedTagsByIdContext{} - mi := &file_product_proto_msgTypes[274] + mi := &file_product_proto_msgTypes[278] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12756,7 +12931,7 @@ func (x *RequireStorageProcessedTagsByIdContext) String() string { func (*RequireStorageProcessedTagsByIdContext) ProtoMessage() {} func (x *RequireStorageProcessedTagsByIdContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[274] + mi := &file_product_proto_msgTypes[278] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12769,7 +12944,7 @@ func (x *RequireStorageProcessedTagsByIdContext) ProtoReflect() protoreflect.Mes // Deprecated: Use RequireStorageProcessedTagsByIdContext.ProtoReflect.Descriptor instead. func (*RequireStorageProcessedTagsByIdContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{274} + return file_product_proto_rawDescGZIP(), []int{278} } func (x *RequireStorageProcessedTagsByIdContext) GetKey() *LookupStorageByIdRequestKey { @@ -12796,7 +12971,7 @@ type RequireStorageProcessedTagsByIdResponse struct { func (x *RequireStorageProcessedTagsByIdResponse) Reset() { *x = RequireStorageProcessedTagsByIdResponse{} - mi := &file_product_proto_msgTypes[275] + mi := &file_product_proto_msgTypes[279] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12808,7 +12983,7 @@ func (x *RequireStorageProcessedTagsByIdResponse) String() string { func (*RequireStorageProcessedTagsByIdResponse) ProtoMessage() {} func (x *RequireStorageProcessedTagsByIdResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[275] + mi := &file_product_proto_msgTypes[279] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12821,7 +12996,7 @@ func (x *RequireStorageProcessedTagsByIdResponse) ProtoReflect() protoreflect.Me // Deprecated: Use RequireStorageProcessedTagsByIdResponse.ProtoReflect.Descriptor instead. func (*RequireStorageProcessedTagsByIdResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{275} + return file_product_proto_rawDescGZIP(), []int{279} } func (x *RequireStorageProcessedTagsByIdResponse) GetResult() []*RequireStorageProcessedTagsByIdResult { @@ -12840,7 +13015,7 @@ type RequireStorageProcessedTagsByIdResult struct { func (x *RequireStorageProcessedTagsByIdResult) Reset() { *x = RequireStorageProcessedTagsByIdResult{} - mi := &file_product_proto_msgTypes[276] + mi := &file_product_proto_msgTypes[280] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12852,7 +13027,7 @@ func (x *RequireStorageProcessedTagsByIdResult) String() string { func (*RequireStorageProcessedTagsByIdResult) ProtoMessage() {} func (x *RequireStorageProcessedTagsByIdResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[276] + mi := &file_product_proto_msgTypes[280] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12865,7 +13040,7 @@ func (x *RequireStorageProcessedTagsByIdResult) ProtoReflect() protoreflect.Mess // Deprecated: Use RequireStorageProcessedTagsByIdResult.ProtoReflect.Descriptor instead. func (*RequireStorageProcessedTagsByIdResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{276} + return file_product_proto_rawDescGZIP(), []int{280} } func (x *RequireStorageProcessedTagsByIdResult) GetProcessedTags() []string { @@ -12884,7 +13059,7 @@ type RequireStorageProcessedTagsByIdFields struct { func (x *RequireStorageProcessedTagsByIdFields) Reset() { *x = RequireStorageProcessedTagsByIdFields{} - mi := &file_product_proto_msgTypes[277] + mi := &file_product_proto_msgTypes[281] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12896,7 +13071,7 @@ func (x *RequireStorageProcessedTagsByIdFields) String() string { func (*RequireStorageProcessedTagsByIdFields) ProtoMessage() {} func (x *RequireStorageProcessedTagsByIdFields) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[277] + mi := &file_product_proto_msgTypes[281] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12909,7 +13084,7 @@ func (x *RequireStorageProcessedTagsByIdFields) ProtoReflect() protoreflect.Mess // Deprecated: Use RequireStorageProcessedTagsByIdFields.ProtoReflect.Descriptor instead. func (*RequireStorageProcessedTagsByIdFields) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{277} + return file_product_proto_rawDescGZIP(), []int{281} } func (x *RequireStorageProcessedTagsByIdFields) GetTags() []string { @@ -12929,7 +13104,7 @@ type RequireStorageOptionalProcessedTagsByIdRequest struct { func (x *RequireStorageOptionalProcessedTagsByIdRequest) Reset() { *x = RequireStorageOptionalProcessedTagsByIdRequest{} - mi := &file_product_proto_msgTypes[278] + mi := &file_product_proto_msgTypes[282] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12941,7 +13116,7 @@ func (x *RequireStorageOptionalProcessedTagsByIdRequest) String() string { func (*RequireStorageOptionalProcessedTagsByIdRequest) ProtoMessage() {} func (x *RequireStorageOptionalProcessedTagsByIdRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[278] + mi := &file_product_proto_msgTypes[282] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12954,7 +13129,7 @@ func (x *RequireStorageOptionalProcessedTagsByIdRequest) ProtoReflect() protoref // Deprecated: Use RequireStorageOptionalProcessedTagsByIdRequest.ProtoReflect.Descriptor instead. func (*RequireStorageOptionalProcessedTagsByIdRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{278} + return file_product_proto_rawDescGZIP(), []int{282} } func (x *RequireStorageOptionalProcessedTagsByIdRequest) GetContext() []*RequireStorageOptionalProcessedTagsByIdContext { @@ -12974,7 +13149,7 @@ type RequireStorageOptionalProcessedTagsByIdContext struct { func (x *RequireStorageOptionalProcessedTagsByIdContext) Reset() { *x = RequireStorageOptionalProcessedTagsByIdContext{} - mi := &file_product_proto_msgTypes[279] + mi := &file_product_proto_msgTypes[283] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12986,7 +13161,7 @@ func (x *RequireStorageOptionalProcessedTagsByIdContext) String() string { func (*RequireStorageOptionalProcessedTagsByIdContext) ProtoMessage() {} func (x *RequireStorageOptionalProcessedTagsByIdContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[279] + mi := &file_product_proto_msgTypes[283] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12999,7 +13174,7 @@ func (x *RequireStorageOptionalProcessedTagsByIdContext) ProtoReflect() protoref // Deprecated: Use RequireStorageOptionalProcessedTagsByIdContext.ProtoReflect.Descriptor instead. func (*RequireStorageOptionalProcessedTagsByIdContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{279} + return file_product_proto_rawDescGZIP(), []int{283} } func (x *RequireStorageOptionalProcessedTagsByIdContext) GetKey() *LookupStorageByIdRequestKey { @@ -13026,7 +13201,7 @@ type RequireStorageOptionalProcessedTagsByIdResponse struct { func (x *RequireStorageOptionalProcessedTagsByIdResponse) Reset() { *x = RequireStorageOptionalProcessedTagsByIdResponse{} - mi := &file_product_proto_msgTypes[280] + mi := &file_product_proto_msgTypes[284] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13038,7 +13213,7 @@ func (x *RequireStorageOptionalProcessedTagsByIdResponse) String() string { func (*RequireStorageOptionalProcessedTagsByIdResponse) ProtoMessage() {} func (x *RequireStorageOptionalProcessedTagsByIdResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[280] + mi := &file_product_proto_msgTypes[284] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13051,7 +13226,7 @@ func (x *RequireStorageOptionalProcessedTagsByIdResponse) ProtoReflect() protore // Deprecated: Use RequireStorageOptionalProcessedTagsByIdResponse.ProtoReflect.Descriptor instead. func (*RequireStorageOptionalProcessedTagsByIdResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{280} + return file_product_proto_rawDescGZIP(), []int{284} } func (x *RequireStorageOptionalProcessedTagsByIdResponse) GetResult() []*RequireStorageOptionalProcessedTagsByIdResult { @@ -13070,7 +13245,7 @@ type RequireStorageOptionalProcessedTagsByIdResult struct { func (x *RequireStorageOptionalProcessedTagsByIdResult) Reset() { *x = RequireStorageOptionalProcessedTagsByIdResult{} - mi := &file_product_proto_msgTypes[281] + mi := &file_product_proto_msgTypes[285] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13082,7 +13257,7 @@ func (x *RequireStorageOptionalProcessedTagsByIdResult) String() string { func (*RequireStorageOptionalProcessedTagsByIdResult) ProtoMessage() {} func (x *RequireStorageOptionalProcessedTagsByIdResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[281] + mi := &file_product_proto_msgTypes[285] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13095,7 +13270,7 @@ func (x *RequireStorageOptionalProcessedTagsByIdResult) ProtoReflect() protorefl // Deprecated: Use RequireStorageOptionalProcessedTagsByIdResult.ProtoReflect.Descriptor instead. func (*RequireStorageOptionalProcessedTagsByIdResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{281} + return file_product_proto_rawDescGZIP(), []int{285} } func (x *RequireStorageOptionalProcessedTagsByIdResult) GetOptionalProcessedTags() *ListOfString { @@ -13114,7 +13289,7 @@ type RequireStorageOptionalProcessedTagsByIdFields struct { func (x *RequireStorageOptionalProcessedTagsByIdFields) Reset() { *x = RequireStorageOptionalProcessedTagsByIdFields{} - mi := &file_product_proto_msgTypes[282] + mi := &file_product_proto_msgTypes[286] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13126,7 +13301,7 @@ func (x *RequireStorageOptionalProcessedTagsByIdFields) String() string { func (*RequireStorageOptionalProcessedTagsByIdFields) ProtoMessage() {} func (x *RequireStorageOptionalProcessedTagsByIdFields) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[282] + mi := &file_product_proto_msgTypes[286] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13139,7 +13314,7 @@ func (x *RequireStorageOptionalProcessedTagsByIdFields) ProtoReflect() protorefl // Deprecated: Use RequireStorageOptionalProcessedTagsByIdFields.ProtoReflect.Descriptor instead. func (*RequireStorageOptionalProcessedTagsByIdFields) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{282} + return file_product_proto_rawDescGZIP(), []int{286} } func (x *RequireStorageOptionalProcessedTagsByIdFields) GetOptionalTags() *ListOfString { @@ -13159,7 +13334,7 @@ type RequireStorageProcessedMetadataHistoryByIdRequest struct { func (x *RequireStorageProcessedMetadataHistoryByIdRequest) Reset() { *x = RequireStorageProcessedMetadataHistoryByIdRequest{} - mi := &file_product_proto_msgTypes[283] + mi := &file_product_proto_msgTypes[287] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13171,7 +13346,7 @@ func (x *RequireStorageProcessedMetadataHistoryByIdRequest) String() string { func (*RequireStorageProcessedMetadataHistoryByIdRequest) ProtoMessage() {} func (x *RequireStorageProcessedMetadataHistoryByIdRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[283] + mi := &file_product_proto_msgTypes[287] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13184,7 +13359,7 @@ func (x *RequireStorageProcessedMetadataHistoryByIdRequest) ProtoReflect() proto // Deprecated: Use RequireStorageProcessedMetadataHistoryByIdRequest.ProtoReflect.Descriptor instead. func (*RequireStorageProcessedMetadataHistoryByIdRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{283} + return file_product_proto_rawDescGZIP(), []int{287} } func (x *RequireStorageProcessedMetadataHistoryByIdRequest) GetContext() []*RequireStorageProcessedMetadataHistoryByIdContext { @@ -13204,7 +13379,7 @@ type RequireStorageProcessedMetadataHistoryByIdContext struct { func (x *RequireStorageProcessedMetadataHistoryByIdContext) Reset() { *x = RequireStorageProcessedMetadataHistoryByIdContext{} - mi := &file_product_proto_msgTypes[284] + mi := &file_product_proto_msgTypes[288] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13216,7 +13391,7 @@ func (x *RequireStorageProcessedMetadataHistoryByIdContext) String() string { func (*RequireStorageProcessedMetadataHistoryByIdContext) ProtoMessage() {} func (x *RequireStorageProcessedMetadataHistoryByIdContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[284] + mi := &file_product_proto_msgTypes[288] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13229,7 +13404,7 @@ func (x *RequireStorageProcessedMetadataHistoryByIdContext) ProtoReflect() proto // Deprecated: Use RequireStorageProcessedMetadataHistoryByIdContext.ProtoReflect.Descriptor instead. func (*RequireStorageProcessedMetadataHistoryByIdContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{284} + return file_product_proto_rawDescGZIP(), []int{288} } func (x *RequireStorageProcessedMetadataHistoryByIdContext) GetKey() *LookupStorageByIdRequestKey { @@ -13256,7 +13431,7 @@ type RequireStorageProcessedMetadataHistoryByIdResponse struct { func (x *RequireStorageProcessedMetadataHistoryByIdResponse) Reset() { *x = RequireStorageProcessedMetadataHistoryByIdResponse{} - mi := &file_product_proto_msgTypes[285] + mi := &file_product_proto_msgTypes[289] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13268,7 +13443,7 @@ func (x *RequireStorageProcessedMetadataHistoryByIdResponse) String() string { func (*RequireStorageProcessedMetadataHistoryByIdResponse) ProtoMessage() {} func (x *RequireStorageProcessedMetadataHistoryByIdResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[285] + mi := &file_product_proto_msgTypes[289] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13281,7 +13456,7 @@ func (x *RequireStorageProcessedMetadataHistoryByIdResponse) ProtoReflect() prot // Deprecated: Use RequireStorageProcessedMetadataHistoryByIdResponse.ProtoReflect.Descriptor instead. func (*RequireStorageProcessedMetadataHistoryByIdResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{285} + return file_product_proto_rawDescGZIP(), []int{289} } func (x *RequireStorageProcessedMetadataHistoryByIdResponse) GetResult() []*RequireStorageProcessedMetadataHistoryByIdResult { @@ -13300,7 +13475,7 @@ type RequireStorageProcessedMetadataHistoryByIdResult struct { func (x *RequireStorageProcessedMetadataHistoryByIdResult) Reset() { *x = RequireStorageProcessedMetadataHistoryByIdResult{} - mi := &file_product_proto_msgTypes[286] + mi := &file_product_proto_msgTypes[290] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13312,7 +13487,7 @@ func (x *RequireStorageProcessedMetadataHistoryByIdResult) String() string { func (*RequireStorageProcessedMetadataHistoryByIdResult) ProtoMessage() {} func (x *RequireStorageProcessedMetadataHistoryByIdResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[286] + mi := &file_product_proto_msgTypes[290] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13325,7 +13500,7 @@ func (x *RequireStorageProcessedMetadataHistoryByIdResult) ProtoReflect() protor // Deprecated: Use RequireStorageProcessedMetadataHistoryByIdResult.ProtoReflect.Descriptor instead. func (*RequireStorageProcessedMetadataHistoryByIdResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{286} + return file_product_proto_rawDescGZIP(), []int{290} } func (x *RequireStorageProcessedMetadataHistoryByIdResult) GetProcessedMetadataHistory() []*StorageMetadata { @@ -13344,7 +13519,7 @@ type RequireStorageProcessedMetadataHistoryByIdFields struct { func (x *RequireStorageProcessedMetadataHistoryByIdFields) Reset() { *x = RequireStorageProcessedMetadataHistoryByIdFields{} - mi := &file_product_proto_msgTypes[287] + mi := &file_product_proto_msgTypes[291] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13356,7 +13531,7 @@ func (x *RequireStorageProcessedMetadataHistoryByIdFields) String() string { func (*RequireStorageProcessedMetadataHistoryByIdFields) ProtoMessage() {} func (x *RequireStorageProcessedMetadataHistoryByIdFields) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[287] + mi := &file_product_proto_msgTypes[291] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13369,7 +13544,7 @@ func (x *RequireStorageProcessedMetadataHistoryByIdFields) ProtoReflect() protor // Deprecated: Use RequireStorageProcessedMetadataHistoryByIdFields.ProtoReflect.Descriptor instead. func (*RequireStorageProcessedMetadataHistoryByIdFields) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{287} + return file_product_proto_rawDescGZIP(), []int{291} } func (x *RequireStorageProcessedMetadataHistoryByIdFields) GetMetadataHistory() []*RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata { @@ -13379,29 +13554,29 @@ func (x *RequireStorageProcessedMetadataHistoryByIdFields) GetMetadataHistory() return nil } -type RequireStorageKindSummaryByIdRequest struct { +type RequireStorageOptionalProcessedMetadataHistoryByIdRequest 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"` + // RequireStorageOptionalProcessedMetadataHistoryByIdContext provides the context for the required fields method RequireStorageOptionalProcessedMetadataHistoryById. + Context []*RequireStorageOptionalProcessedMetadataHistoryByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageKindSummaryByIdRequest) Reset() { - *x = RequireStorageKindSummaryByIdRequest{} - mi := &file_product_proto_msgTypes[288] +func (x *RequireStorageOptionalProcessedMetadataHistoryByIdRequest) Reset() { + *x = RequireStorageOptionalProcessedMetadataHistoryByIdRequest{} + mi := &file_product_proto_msgTypes[292] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageKindSummaryByIdRequest) String() string { +func (x *RequireStorageOptionalProcessedMetadataHistoryByIdRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageKindSummaryByIdRequest) ProtoMessage() {} +func (*RequireStorageOptionalProcessedMetadataHistoryByIdRequest) ProtoMessage() {} -func (x *RequireStorageKindSummaryByIdRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[288] +func (x *RequireStorageOptionalProcessedMetadataHistoryByIdRequest) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[292] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13412,41 +13587,41 @@ func (x *RequireStorageKindSummaryByIdRequest) ProtoReflect() protoreflect.Messa return mi.MessageOf(x) } -// Deprecated: Use RequireStorageKindSummaryByIdRequest.ProtoReflect.Descriptor instead. -func (*RequireStorageKindSummaryByIdRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{288} +// Deprecated: Use RequireStorageOptionalProcessedMetadataHistoryByIdRequest.ProtoReflect.Descriptor instead. +func (*RequireStorageOptionalProcessedMetadataHistoryByIdRequest) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{292} } -func (x *RequireStorageKindSummaryByIdRequest) GetContext() []*RequireStorageKindSummaryByIdContext { +func (x *RequireStorageOptionalProcessedMetadataHistoryByIdRequest) GetContext() []*RequireStorageOptionalProcessedMetadataHistoryByIdContext { 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 RequireStorageOptionalProcessedMetadataHistoryByIdContext struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Fields *RequireStorageOptionalProcessedMetadataHistoryByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageKindSummaryByIdContext) Reset() { - *x = RequireStorageKindSummaryByIdContext{} - mi := &file_product_proto_msgTypes[289] +func (x *RequireStorageOptionalProcessedMetadataHistoryByIdContext) Reset() { + *x = RequireStorageOptionalProcessedMetadataHistoryByIdContext{} + mi := &file_product_proto_msgTypes[293] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageKindSummaryByIdContext) String() string { +func (x *RequireStorageOptionalProcessedMetadataHistoryByIdContext) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageKindSummaryByIdContext) ProtoMessage() {} +func (*RequireStorageOptionalProcessedMetadataHistoryByIdContext) ProtoMessage() {} -func (x *RequireStorageKindSummaryByIdContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[289] +func (x *RequireStorageOptionalProcessedMetadataHistoryByIdContext) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[293] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13457,48 +13632,48 @@ func (x *RequireStorageKindSummaryByIdContext) ProtoReflect() protoreflect.Messa return mi.MessageOf(x) } -// Deprecated: Use RequireStorageKindSummaryByIdContext.ProtoReflect.Descriptor instead. -func (*RequireStorageKindSummaryByIdContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{289} +// Deprecated: Use RequireStorageOptionalProcessedMetadataHistoryByIdContext.ProtoReflect.Descriptor instead. +func (*RequireStorageOptionalProcessedMetadataHistoryByIdContext) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{293} } -func (x *RequireStorageKindSummaryByIdContext) GetKey() *LookupStorageByIdRequestKey { +func (x *RequireStorageOptionalProcessedMetadataHistoryByIdContext) GetKey() *LookupStorageByIdRequestKey { if x != nil { return x.Key } return nil } -func (x *RequireStorageKindSummaryByIdContext) GetFields() *RequireStorageKindSummaryByIdFields { +func (x *RequireStorageOptionalProcessedMetadataHistoryByIdContext) GetFields() *RequireStorageOptionalProcessedMetadataHistoryByIdFields { if x != nil { return x.Fields } return nil } -type RequireStorageKindSummaryByIdResponse struct { +type RequireStorageOptionalProcessedMetadataHistoryByIdResponse 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"` + // RequireStorageOptionalProcessedMetadataHistoryByIdResult provides the result for the required fields method RequireStorageOptionalProcessedMetadataHistoryById. + Result []*RequireStorageOptionalProcessedMetadataHistoryByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageKindSummaryByIdResponse) Reset() { - *x = RequireStorageKindSummaryByIdResponse{} - mi := &file_product_proto_msgTypes[290] +func (x *RequireStorageOptionalProcessedMetadataHistoryByIdResponse) Reset() { + *x = RequireStorageOptionalProcessedMetadataHistoryByIdResponse{} + mi := &file_product_proto_msgTypes[294] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageKindSummaryByIdResponse) String() string { +func (x *RequireStorageOptionalProcessedMetadataHistoryByIdResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageKindSummaryByIdResponse) ProtoMessage() {} +func (*RequireStorageOptionalProcessedMetadataHistoryByIdResponse) ProtoMessage() {} -func (x *RequireStorageKindSummaryByIdResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[290] +func (x *RequireStorageOptionalProcessedMetadataHistoryByIdResponse) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[294] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13509,40 +13684,40 @@ func (x *RequireStorageKindSummaryByIdResponse) ProtoReflect() protoreflect.Mess return mi.MessageOf(x) } -// Deprecated: Use RequireStorageKindSummaryByIdResponse.ProtoReflect.Descriptor instead. -func (*RequireStorageKindSummaryByIdResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{290} +// Deprecated: Use RequireStorageOptionalProcessedMetadataHistoryByIdResponse.ProtoReflect.Descriptor instead. +func (*RequireStorageOptionalProcessedMetadataHistoryByIdResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{294} } -func (x *RequireStorageKindSummaryByIdResponse) GetResult() []*RequireStorageKindSummaryByIdResult { +func (x *RequireStorageOptionalProcessedMetadataHistoryByIdResponse) GetResult() []*RequireStorageOptionalProcessedMetadataHistoryByIdResult { 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 RequireStorageOptionalProcessedMetadataHistoryByIdResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + OptionalProcessedMetadataHistory *ListOfStorageMetadata `protobuf:"bytes,1,opt,name=optional_processed_metadata_history,json=optionalProcessedMetadataHistory,proto3" json:"optional_processed_metadata_history,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *RequireStorageKindSummaryByIdResult) Reset() { - *x = RequireStorageKindSummaryByIdResult{} - mi := &file_product_proto_msgTypes[291] +func (x *RequireStorageOptionalProcessedMetadataHistoryByIdResult) Reset() { + *x = RequireStorageOptionalProcessedMetadataHistoryByIdResult{} + mi := &file_product_proto_msgTypes[295] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageKindSummaryByIdResult) String() string { +func (x *RequireStorageOptionalProcessedMetadataHistoryByIdResult) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageKindSummaryByIdResult) ProtoMessage() {} +func (*RequireStorageOptionalProcessedMetadataHistoryByIdResult) ProtoMessage() {} -func (x *RequireStorageKindSummaryByIdResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[291] +func (x *RequireStorageOptionalProcessedMetadataHistoryByIdResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[295] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13553,40 +13728,40 @@ func (x *RequireStorageKindSummaryByIdResult) ProtoReflect() protoreflect.Messag return mi.MessageOf(x) } -// Deprecated: Use RequireStorageKindSummaryByIdResult.ProtoReflect.Descriptor instead. -func (*RequireStorageKindSummaryByIdResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{291} +// Deprecated: Use RequireStorageOptionalProcessedMetadataHistoryByIdResult.ProtoReflect.Descriptor instead. +func (*RequireStorageOptionalProcessedMetadataHistoryByIdResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{295} } -func (x *RequireStorageKindSummaryByIdResult) GetKindSummary() string { +func (x *RequireStorageOptionalProcessedMetadataHistoryByIdResult) GetOptionalProcessedMetadataHistory() *ListOfStorageMetadata { if x != nil { - return x.KindSummary + return x.OptionalProcessedMetadataHistory } - 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"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type RequireStorageOptionalProcessedMetadataHistoryByIdFields struct { + state protoimpl.MessageState `protogen:"open.v1"` + MetadataHistory []*RequireStorageOptionalProcessedMetadataHistoryByIdFields_StorageMetadata `protobuf:"bytes,1,rep,name=metadata_history,json=metadataHistory,proto3" json:"metadata_history,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *RequireStorageKindSummaryByIdFields) Reset() { - *x = RequireStorageKindSummaryByIdFields{} - mi := &file_product_proto_msgTypes[292] +func (x *RequireStorageOptionalProcessedMetadataHistoryByIdFields) Reset() { + *x = RequireStorageOptionalProcessedMetadataHistoryByIdFields{} + mi := &file_product_proto_msgTypes[296] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageKindSummaryByIdFields) String() string { +func (x *RequireStorageOptionalProcessedMetadataHistoryByIdFields) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageKindSummaryByIdFields) ProtoMessage() {} +func (*RequireStorageOptionalProcessedMetadataHistoryByIdFields) ProtoMessage() {} -func (x *RequireStorageKindSummaryByIdFields) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[292] +func (x *RequireStorageOptionalProcessedMetadataHistoryByIdFields) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[296] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13597,41 +13772,43 @@ func (x *RequireStorageKindSummaryByIdFields) ProtoReflect() protoreflect.Messag return mi.MessageOf(x) } -// Deprecated: Use RequireStorageKindSummaryByIdFields.ProtoReflect.Descriptor instead. -func (*RequireStorageKindSummaryByIdFields) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{292} +// Deprecated: Use RequireStorageOptionalProcessedMetadataHistoryByIdFields.ProtoReflect.Descriptor instead. +func (*RequireStorageOptionalProcessedMetadataHistoryByIdFields) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{296} } -func (x *RequireStorageKindSummaryByIdFields) GetStorageKind() CategoryKind { +func (x *RequireStorageOptionalProcessedMetadataHistoryByIdFields) GetMetadataHistory() []*RequireStorageOptionalProcessedMetadataHistoryByIdFields_StorageMetadata { if x != nil { - return x.StorageKind + return x.MetadataHistory } - return CategoryKind_CATEGORY_KIND_UNSPECIFIED + return nil } -type RequireStorageCategoryInfoSummaryByIdRequest struct { +type RequireStorageTagsByLengthsByIdRequest 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"` + // RequireStorageTagsByLengthsByIdContext provides the context for the required fields method RequireStorageTagsByLengthsById. + Context []*RequireStorageTagsByLengthsByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` + // RequireStorageTagsByLengthsByIdArgs provides the field arguments for the required field with method RequireStorageTagsByLengthsById. + FieldArgs *RequireStorageTagsByLengthsByIdArgs `protobuf:"bytes,2,opt,name=field_args,json=fieldArgs,proto3" json:"field_args,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageCategoryInfoSummaryByIdRequest) Reset() { - *x = RequireStorageCategoryInfoSummaryByIdRequest{} - mi := &file_product_proto_msgTypes[293] +func (x *RequireStorageTagsByLengthsByIdRequest) Reset() { + *x = RequireStorageTagsByLengthsByIdRequest{} + mi := &file_product_proto_msgTypes[297] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageCategoryInfoSummaryByIdRequest) String() string { +func (x *RequireStorageTagsByLengthsByIdRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageCategoryInfoSummaryByIdRequest) ProtoMessage() {} +func (*RequireStorageTagsByLengthsByIdRequest) ProtoMessage() {} -func (x *RequireStorageCategoryInfoSummaryByIdRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[293] +func (x *RequireStorageTagsByLengthsByIdRequest) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[297] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13642,41 +13819,48 @@ func (x *RequireStorageCategoryInfoSummaryByIdRequest) ProtoReflect() protorefle return mi.MessageOf(x) } -// Deprecated: Use RequireStorageCategoryInfoSummaryByIdRequest.ProtoReflect.Descriptor instead. -func (*RequireStorageCategoryInfoSummaryByIdRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{293} +// Deprecated: Use RequireStorageTagsByLengthsByIdRequest.ProtoReflect.Descriptor instead. +func (*RequireStorageTagsByLengthsByIdRequest) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{297} } -func (x *RequireStorageCategoryInfoSummaryByIdRequest) GetContext() []*RequireStorageCategoryInfoSummaryByIdContext { +func (x *RequireStorageTagsByLengthsByIdRequest) GetContext() []*RequireStorageTagsByLengthsByIdContext { 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"` +func (x *RequireStorageTagsByLengthsByIdRequest) GetFieldArgs() *RequireStorageTagsByLengthsByIdArgs { + if x != nil { + return x.FieldArgs + } + return nil +} + +type RequireStorageTagsByLengthsByIdContext struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Fields *RequireStorageTagsByLengthsByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageCategoryInfoSummaryByIdContext) Reset() { - *x = RequireStorageCategoryInfoSummaryByIdContext{} - mi := &file_product_proto_msgTypes[294] +func (x *RequireStorageTagsByLengthsByIdContext) Reset() { + *x = RequireStorageTagsByLengthsByIdContext{} + mi := &file_product_proto_msgTypes[298] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageCategoryInfoSummaryByIdContext) String() string { +func (x *RequireStorageTagsByLengthsByIdContext) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageCategoryInfoSummaryByIdContext) ProtoMessage() {} +func (*RequireStorageTagsByLengthsByIdContext) ProtoMessage() {} -func (x *RequireStorageCategoryInfoSummaryByIdContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[294] +func (x *RequireStorageTagsByLengthsByIdContext) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[298] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13687,48 +13871,47 @@ func (x *RequireStorageCategoryInfoSummaryByIdContext) ProtoReflect() protorefle return mi.MessageOf(x) } -// Deprecated: Use RequireStorageCategoryInfoSummaryByIdContext.ProtoReflect.Descriptor instead. -func (*RequireStorageCategoryInfoSummaryByIdContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{294} +// Deprecated: Use RequireStorageTagsByLengthsByIdContext.ProtoReflect.Descriptor instead. +func (*RequireStorageTagsByLengthsByIdContext) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{298} } -func (x *RequireStorageCategoryInfoSummaryByIdContext) GetKey() *LookupStorageByIdRequestKey { +func (x *RequireStorageTagsByLengthsByIdContext) GetKey() *LookupStorageByIdRequestKey { if x != nil { return x.Key } return nil } -func (x *RequireStorageCategoryInfoSummaryByIdContext) GetFields() *RequireStorageCategoryInfoSummaryByIdFields { +func (x *RequireStorageTagsByLengthsByIdContext) GetFields() *RequireStorageTagsByLengthsByIdFields { if x != nil { return x.Fields } return nil } -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"` +type RequireStorageTagsByLengthsByIdArgs struct { + state protoimpl.MessageState `protogen:"open.v1"` + Lengths *ListOfInt `protobuf:"bytes,1,opt,name=lengths,proto3" json:"lengths,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageCategoryInfoSummaryByIdResponse) Reset() { - *x = RequireStorageCategoryInfoSummaryByIdResponse{} - mi := &file_product_proto_msgTypes[295] +func (x *RequireStorageTagsByLengthsByIdArgs) Reset() { + *x = RequireStorageTagsByLengthsByIdArgs{} + mi := &file_product_proto_msgTypes[299] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageCategoryInfoSummaryByIdResponse) String() string { +func (x *RequireStorageTagsByLengthsByIdArgs) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageCategoryInfoSummaryByIdResponse) ProtoMessage() {} +func (*RequireStorageTagsByLengthsByIdArgs) ProtoMessage() {} -func (x *RequireStorageCategoryInfoSummaryByIdResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[295] +func (x *RequireStorageTagsByLengthsByIdArgs) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[299] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13739,40 +13922,41 @@ func (x *RequireStorageCategoryInfoSummaryByIdResponse) ProtoReflect() protorefl return mi.MessageOf(x) } -// Deprecated: Use RequireStorageCategoryInfoSummaryByIdResponse.ProtoReflect.Descriptor instead. -func (*RequireStorageCategoryInfoSummaryByIdResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{295} +// Deprecated: Use RequireStorageTagsByLengthsByIdArgs.ProtoReflect.Descriptor instead. +func (*RequireStorageTagsByLengthsByIdArgs) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{299} } -func (x *RequireStorageCategoryInfoSummaryByIdResponse) GetResult() []*RequireStorageCategoryInfoSummaryByIdResult { +func (x *RequireStorageTagsByLengthsByIdArgs) GetLengths() *ListOfInt { if x != nil { - return x.Result + return x.Lengths } 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 RequireStorageTagsByLengthsByIdResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // RequireStorageTagsByLengthsByIdResult provides the result for the required fields method RequireStorageTagsByLengthsById. + Result []*RequireStorageTagsByLengthsByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *RequireStorageCategoryInfoSummaryByIdResult) Reset() { - *x = RequireStorageCategoryInfoSummaryByIdResult{} - mi := &file_product_proto_msgTypes[296] +func (x *RequireStorageTagsByLengthsByIdResponse) Reset() { + *x = RequireStorageTagsByLengthsByIdResponse{} + mi := &file_product_proto_msgTypes[300] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageCategoryInfoSummaryByIdResult) String() string { +func (x *RequireStorageTagsByLengthsByIdResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageCategoryInfoSummaryByIdResult) ProtoMessage() {} +func (*RequireStorageTagsByLengthsByIdResponse) ProtoMessage() {} -func (x *RequireStorageCategoryInfoSummaryByIdResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[296] +func (x *RequireStorageTagsByLengthsByIdResponse) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[300] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13783,40 +13967,40 @@ func (x *RequireStorageCategoryInfoSummaryByIdResult) ProtoReflect() protoreflec return mi.MessageOf(x) } -// Deprecated: Use RequireStorageCategoryInfoSummaryByIdResult.ProtoReflect.Descriptor instead. -func (*RequireStorageCategoryInfoSummaryByIdResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{296} +// Deprecated: Use RequireStorageTagsByLengthsByIdResponse.ProtoReflect.Descriptor instead. +func (*RequireStorageTagsByLengthsByIdResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{300} } -func (x *RequireStorageCategoryInfoSummaryByIdResult) GetCategoryInfoSummary() string { +func (x *RequireStorageTagsByLengthsByIdResponse) GetResult() []*RequireStorageTagsByLengthsByIdResult { if x != nil { - return x.CategoryInfoSummary + return x.Result } - 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 RequireStorageTagsByLengthsByIdResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + TagsByLengths *ListOfString `protobuf:"bytes,1,opt,name=tags_by_lengths,json=tagsByLengths,proto3" json:"tags_by_lengths,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageCategoryInfoSummaryByIdFields) Reset() { - *x = RequireStorageCategoryInfoSummaryByIdFields{} - mi := &file_product_proto_msgTypes[297] +func (x *RequireStorageTagsByLengthsByIdResult) Reset() { + *x = RequireStorageTagsByLengthsByIdResult{} + mi := &file_product_proto_msgTypes[301] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageCategoryInfoSummaryByIdFields) String() string { +func (x *RequireStorageTagsByLengthsByIdResult) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageCategoryInfoSummaryByIdFields) ProtoMessage() {} +func (*RequireStorageTagsByLengthsByIdResult) ProtoMessage() {} -func (x *RequireStorageCategoryInfoSummaryByIdFields) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[297] +func (x *RequireStorageTagsByLengthsByIdResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[301] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13827,41 +14011,40 @@ func (x *RequireStorageCategoryInfoSummaryByIdFields) ProtoReflect() protoreflec return mi.MessageOf(x) } -// Deprecated: Use RequireStorageCategoryInfoSummaryByIdFields.ProtoReflect.Descriptor instead. -func (*RequireStorageCategoryInfoSummaryByIdFields) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{297} +// Deprecated: Use RequireStorageTagsByLengthsByIdResult.ProtoReflect.Descriptor instead. +func (*RequireStorageTagsByLengthsByIdResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{301} } -func (x *RequireStorageCategoryInfoSummaryByIdFields) GetCategoryInfo() *RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo { +func (x *RequireStorageTagsByLengthsByIdResult) GetTagsByLengths() *ListOfString { if x != nil { - return x.CategoryInfo + return x.TagsByLengths } return nil } -type RequireStorageItemInfoByIdRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - // RequireStorageItemInfoByIdContext provides the context for the required fields method RequireStorageItemInfoById. - Context []*RequireStorageItemInfoByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` +type RequireStorageTagsByLengthsByIdFields 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 *RequireStorageItemInfoByIdRequest) Reset() { - *x = RequireStorageItemInfoByIdRequest{} - mi := &file_product_proto_msgTypes[298] +func (x *RequireStorageTagsByLengthsByIdFields) Reset() { + *x = RequireStorageTagsByLengthsByIdFields{} + mi := &file_product_proto_msgTypes[302] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageItemInfoByIdRequest) String() string { +func (x *RequireStorageTagsByLengthsByIdFields) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageItemInfoByIdRequest) ProtoMessage() {} +func (*RequireStorageTagsByLengthsByIdFields) ProtoMessage() {} -func (x *RequireStorageItemInfoByIdRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[298] +func (x *RequireStorageTagsByLengthsByIdFields) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[302] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13872,41 +14055,41 @@ func (x *RequireStorageItemInfoByIdRequest) ProtoReflect() protoreflect.Message return mi.MessageOf(x) } -// Deprecated: Use RequireStorageItemInfoByIdRequest.ProtoReflect.Descriptor instead. -func (*RequireStorageItemInfoByIdRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{298} +// Deprecated: Use RequireStorageTagsByLengthsByIdFields.ProtoReflect.Descriptor instead. +func (*RequireStorageTagsByLengthsByIdFields) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{302} } -func (x *RequireStorageItemInfoByIdRequest) GetContext() []*RequireStorageItemInfoByIdContext { +func (x *RequireStorageTagsByLengthsByIdFields) GetTags() []string { if x != nil { - return x.Context + return x.Tags } return nil } -type RequireStorageItemInfoByIdContext struct { - state protoimpl.MessageState `protogen:"open.v1"` - Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` - Fields *RequireStorageItemInfoByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` +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 *RequireStorageItemInfoByIdContext) Reset() { - *x = RequireStorageItemInfoByIdContext{} - mi := &file_product_proto_msgTypes[299] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) +func (x *RequireStorageKindSummaryByIdRequest) Reset() { + *x = RequireStorageKindSummaryByIdRequest{} + mi := &file_product_proto_msgTypes[303] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageItemInfoByIdContext) String() string { +func (x *RequireStorageKindSummaryByIdRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageItemInfoByIdContext) ProtoMessage() {} +func (*RequireStorageKindSummaryByIdRequest) ProtoMessage() {} -func (x *RequireStorageItemInfoByIdContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[299] +func (x *RequireStorageKindSummaryByIdRequest) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[303] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13917,48 +14100,93 @@ func (x *RequireStorageItemInfoByIdContext) ProtoReflect() protoreflect.Message return mi.MessageOf(x) } -// Deprecated: Use RequireStorageItemInfoByIdContext.ProtoReflect.Descriptor instead. -func (*RequireStorageItemInfoByIdContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{299} +// Deprecated: Use RequireStorageKindSummaryByIdRequest.ProtoReflect.Descriptor instead. +func (*RequireStorageKindSummaryByIdRequest) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{303} } -func (x *RequireStorageItemInfoByIdContext) GetKey() *LookupStorageByIdRequestKey { +func (x *RequireStorageKindSummaryByIdRequest) GetContext() []*RequireStorageKindSummaryByIdContext { + 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"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RequireStorageKindSummaryByIdContext) Reset() { + *x = RequireStorageKindSummaryByIdContext{} + mi := &file_product_proto_msgTypes[304] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireStorageKindSummaryByIdContext) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageKindSummaryByIdContext) ProtoMessage() {} + +func (x *RequireStorageKindSummaryByIdContext) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[304] + 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 RequireStorageKindSummaryByIdContext.ProtoReflect.Descriptor instead. +func (*RequireStorageKindSummaryByIdContext) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{304} +} + +func (x *RequireStorageKindSummaryByIdContext) GetKey() *LookupStorageByIdRequestKey { if x != nil { return x.Key } return nil } -func (x *RequireStorageItemInfoByIdContext) GetFields() *RequireStorageItemInfoByIdFields { +func (x *RequireStorageKindSummaryByIdContext) GetFields() *RequireStorageKindSummaryByIdFields { if x != nil { return x.Fields } return nil } -type RequireStorageItemInfoByIdResponse struct { +type RequireStorageKindSummaryByIdResponse struct { state protoimpl.MessageState `protogen:"open.v1"` - // RequireStorageItemInfoByIdResult provides the result for the required fields method RequireStorageItemInfoById. - Result []*RequireStorageItemInfoByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` + // 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 *RequireStorageItemInfoByIdResponse) Reset() { - *x = RequireStorageItemInfoByIdResponse{} - mi := &file_product_proto_msgTypes[300] +func (x *RequireStorageKindSummaryByIdResponse) Reset() { + *x = RequireStorageKindSummaryByIdResponse{} + mi := &file_product_proto_msgTypes[305] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageItemInfoByIdResponse) String() string { +func (x *RequireStorageKindSummaryByIdResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageItemInfoByIdResponse) ProtoMessage() {} +func (*RequireStorageKindSummaryByIdResponse) ProtoMessage() {} -func (x *RequireStorageItemInfoByIdResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[300] +func (x *RequireStorageKindSummaryByIdResponse) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[305] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13969,40 +14197,40 @@ func (x *RequireStorageItemInfoByIdResponse) ProtoReflect() protoreflect.Message return mi.MessageOf(x) } -// Deprecated: Use RequireStorageItemInfoByIdResponse.ProtoReflect.Descriptor instead. -func (*RequireStorageItemInfoByIdResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{300} +// Deprecated: Use RequireStorageKindSummaryByIdResponse.ProtoReflect.Descriptor instead. +func (*RequireStorageKindSummaryByIdResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{305} } -func (x *RequireStorageItemInfoByIdResponse) GetResult() []*RequireStorageItemInfoByIdResult { +func (x *RequireStorageKindSummaryByIdResponse) GetResult() []*RequireStorageKindSummaryByIdResult { if x != nil { return x.Result } return nil } -type RequireStorageItemInfoByIdResult struct { +type RequireStorageKindSummaryByIdResult struct { state protoimpl.MessageState `protogen:"open.v1"` - ItemInfo string `protobuf:"bytes,1,opt,name=item_info,json=itemInfo,proto3" json:"item_info,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 *RequireStorageItemInfoByIdResult) Reset() { - *x = RequireStorageItemInfoByIdResult{} - mi := &file_product_proto_msgTypes[301] +func (x *RequireStorageKindSummaryByIdResult) Reset() { + *x = RequireStorageKindSummaryByIdResult{} + mi := &file_product_proto_msgTypes[306] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageItemInfoByIdResult) String() string { +func (x *RequireStorageKindSummaryByIdResult) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageItemInfoByIdResult) ProtoMessage() {} +func (*RequireStorageKindSummaryByIdResult) ProtoMessage() {} -func (x *RequireStorageItemInfoByIdResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[301] +func (x *RequireStorageKindSummaryByIdResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[306] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14013,40 +14241,960 @@ func (x *RequireStorageItemInfoByIdResult) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use RequireStorageItemInfoByIdResult.ProtoReflect.Descriptor instead. -func (*RequireStorageItemInfoByIdResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{301} +// Deprecated: Use RequireStorageKindSummaryByIdResult.ProtoReflect.Descriptor instead. +func (*RequireStorageKindSummaryByIdResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{306} +} + +func (x *RequireStorageKindSummaryByIdResult) GetKindSummary() string { + if x != nil { + return x.KindSummary + } + return "" +} + +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"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RequireStorageKindSummaryByIdFields) Reset() { + *x = RequireStorageKindSummaryByIdFields{} + mi := &file_product_proto_msgTypes[307] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireStorageKindSummaryByIdFields) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageKindSummaryByIdFields) ProtoMessage() {} + +func (x *RequireStorageKindSummaryByIdFields) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[307] + 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 RequireStorageKindSummaryByIdFields.ProtoReflect.Descriptor instead. +func (*RequireStorageKindSummaryByIdFields) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{307} +} + +func (x *RequireStorageKindSummaryByIdFields) GetStorageKind() CategoryKind { + if x != nil { + return x.StorageKind + } + return CategoryKind_CATEGORY_KIND_UNSPECIFIED +} + +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 *RequireStorageCategoryInfoSummaryByIdRequest) Reset() { + *x = RequireStorageCategoryInfoSummaryByIdRequest{} + mi := &file_product_proto_msgTypes[308] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireStorageCategoryInfoSummaryByIdRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageCategoryInfoSummaryByIdRequest) ProtoMessage() {} + +func (x *RequireStorageCategoryInfoSummaryByIdRequest) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[308] + 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 RequireStorageCategoryInfoSummaryByIdRequest.ProtoReflect.Descriptor instead. +func (*RequireStorageCategoryInfoSummaryByIdRequest) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{308} +} + +func (x *RequireStorageCategoryInfoSummaryByIdRequest) GetContext() []*RequireStorageCategoryInfoSummaryByIdContext { + 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"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RequireStorageCategoryInfoSummaryByIdContext) Reset() { + *x = RequireStorageCategoryInfoSummaryByIdContext{} + mi := &file_product_proto_msgTypes[309] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireStorageCategoryInfoSummaryByIdContext) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageCategoryInfoSummaryByIdContext) ProtoMessage() {} + +func (x *RequireStorageCategoryInfoSummaryByIdContext) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[309] + 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 RequireStorageCategoryInfoSummaryByIdContext.ProtoReflect.Descriptor instead. +func (*RequireStorageCategoryInfoSummaryByIdContext) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{309} +} + +func (x *RequireStorageCategoryInfoSummaryByIdContext) GetKey() *LookupStorageByIdRequestKey { + if x != nil { + return x.Key + } + return nil +} + +func (x *RequireStorageCategoryInfoSummaryByIdContext) GetFields() *RequireStorageCategoryInfoSummaryByIdFields { + if x != nil { + return x.Fields + } + return nil +} + +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 *RequireStorageCategoryInfoSummaryByIdResponse) Reset() { + *x = RequireStorageCategoryInfoSummaryByIdResponse{} + mi := &file_product_proto_msgTypes[310] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireStorageCategoryInfoSummaryByIdResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageCategoryInfoSummaryByIdResponse) ProtoMessage() {} + +func (x *RequireStorageCategoryInfoSummaryByIdResponse) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[310] + 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 RequireStorageCategoryInfoSummaryByIdResponse.ProtoReflect.Descriptor instead. +func (*RequireStorageCategoryInfoSummaryByIdResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{310} +} + +func (x *RequireStorageCategoryInfoSummaryByIdResponse) GetResult() []*RequireStorageCategoryInfoSummaryByIdResult { + 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 +} + +func (x *RequireStorageCategoryInfoSummaryByIdResult) Reset() { + *x = RequireStorageCategoryInfoSummaryByIdResult{} + mi := &file_product_proto_msgTypes[311] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireStorageCategoryInfoSummaryByIdResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageCategoryInfoSummaryByIdResult) ProtoMessage() {} + +func (x *RequireStorageCategoryInfoSummaryByIdResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[311] + 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 RequireStorageCategoryInfoSummaryByIdResult.ProtoReflect.Descriptor instead. +func (*RequireStorageCategoryInfoSummaryByIdResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{311} +} + +func (x *RequireStorageCategoryInfoSummaryByIdResult) GetCategoryInfoSummary() string { + if x != nil { + return x.CategoryInfoSummary + } + return "" +} + +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 *RequireStorageCategoryInfoSummaryByIdFields) Reset() { + *x = RequireStorageCategoryInfoSummaryByIdFields{} + mi := &file_product_proto_msgTypes[312] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireStorageCategoryInfoSummaryByIdFields) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageCategoryInfoSummaryByIdFields) ProtoMessage() {} + +func (x *RequireStorageCategoryInfoSummaryByIdFields) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[312] + 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 RequireStorageCategoryInfoSummaryByIdFields.ProtoReflect.Descriptor instead. +func (*RequireStorageCategoryInfoSummaryByIdFields) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{312} +} + +func (x *RequireStorageCategoryInfoSummaryByIdFields) GetCategoryInfo() *RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo { + if x != nil { + return x.CategoryInfo + } + return nil +} + +type RequireStorageItemInfoByIdRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // RequireStorageItemInfoByIdContext provides the context for the required fields method RequireStorageItemInfoById. + Context []*RequireStorageItemInfoByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RequireStorageItemInfoByIdRequest) Reset() { + *x = RequireStorageItemInfoByIdRequest{} + mi := &file_product_proto_msgTypes[313] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireStorageItemInfoByIdRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageItemInfoByIdRequest) ProtoMessage() {} + +func (x *RequireStorageItemInfoByIdRequest) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[313] + 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 RequireStorageItemInfoByIdRequest.ProtoReflect.Descriptor instead. +func (*RequireStorageItemInfoByIdRequest) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{313} +} + +func (x *RequireStorageItemInfoByIdRequest) GetContext() []*RequireStorageItemInfoByIdContext { + if x != nil { + return x.Context + } + return nil +} + +type RequireStorageItemInfoByIdContext struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Fields *RequireStorageItemInfoByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RequireStorageItemInfoByIdContext) Reset() { + *x = RequireStorageItemInfoByIdContext{} + mi := &file_product_proto_msgTypes[314] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireStorageItemInfoByIdContext) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageItemInfoByIdContext) ProtoMessage() {} + +func (x *RequireStorageItemInfoByIdContext) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[314] + 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 RequireStorageItemInfoByIdContext.ProtoReflect.Descriptor instead. +func (*RequireStorageItemInfoByIdContext) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{314} +} + +func (x *RequireStorageItemInfoByIdContext) GetKey() *LookupStorageByIdRequestKey { + if x != nil { + return x.Key + } + return nil +} + +func (x *RequireStorageItemInfoByIdContext) GetFields() *RequireStorageItemInfoByIdFields { + if x != nil { + return x.Fields + } + return nil +} + +type RequireStorageItemInfoByIdResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // RequireStorageItemInfoByIdResult provides the result for the required fields method RequireStorageItemInfoById. + Result []*RequireStorageItemInfoByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RequireStorageItemInfoByIdResponse) Reset() { + *x = RequireStorageItemInfoByIdResponse{} + mi := &file_product_proto_msgTypes[315] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireStorageItemInfoByIdResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageItemInfoByIdResponse) ProtoMessage() {} + +func (x *RequireStorageItemInfoByIdResponse) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[315] + 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 RequireStorageItemInfoByIdResponse.ProtoReflect.Descriptor instead. +func (*RequireStorageItemInfoByIdResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{315} +} + +func (x *RequireStorageItemInfoByIdResponse) GetResult() []*RequireStorageItemInfoByIdResult { + if x != nil { + return x.Result + } + return nil +} + +type RequireStorageItemInfoByIdResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + ItemInfo string `protobuf:"bytes,1,opt,name=item_info,json=itemInfo,proto3" json:"item_info,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RequireStorageItemInfoByIdResult) Reset() { + *x = RequireStorageItemInfoByIdResult{} + mi := &file_product_proto_msgTypes[316] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireStorageItemInfoByIdResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageItemInfoByIdResult) ProtoMessage() {} + +func (x *RequireStorageItemInfoByIdResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[316] + 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 RequireStorageItemInfoByIdResult.ProtoReflect.Descriptor instead. +func (*RequireStorageItemInfoByIdResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{316} +} + +func (x *RequireStorageItemInfoByIdResult) GetItemInfo() string { + if x != nil { + return x.ItemInfo + } + return "" +} + +type RequireStorageItemInfoByIdFields struct { + state protoimpl.MessageState `protogen:"open.v1"` + PrimaryItem *RequireStorageItemInfoByIdFields_StorageItem `protobuf:"bytes,1,opt,name=primary_item,json=primaryItem,proto3" json:"primary_item,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RequireStorageItemInfoByIdFields) Reset() { + *x = RequireStorageItemInfoByIdFields{} + mi := &file_product_proto_msgTypes[317] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireStorageItemInfoByIdFields) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageItemInfoByIdFields) ProtoMessage() {} + +func (x *RequireStorageItemInfoByIdFields) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[317] + 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 RequireStorageItemInfoByIdFields.ProtoReflect.Descriptor instead. +func (*RequireStorageItemInfoByIdFields) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{317} +} + +func (x *RequireStorageItemInfoByIdFields) GetPrimaryItem() *RequireStorageItemInfoByIdFields_StorageItem { + if x != nil { + return x.PrimaryItem + } + return nil +} + +type RequireStorageOperationReportByIdRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // RequireStorageOperationReportByIdContext provides the context for the required fields method RequireStorageOperationReportById. + Context []*RequireStorageOperationReportByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RequireStorageOperationReportByIdRequest) Reset() { + *x = RequireStorageOperationReportByIdRequest{} + mi := &file_product_proto_msgTypes[318] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireStorageOperationReportByIdRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageOperationReportByIdRequest) ProtoMessage() {} + +func (x *RequireStorageOperationReportByIdRequest) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[318] + 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 RequireStorageOperationReportByIdRequest.ProtoReflect.Descriptor instead. +func (*RequireStorageOperationReportByIdRequest) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{318} +} + +func (x *RequireStorageOperationReportByIdRequest) GetContext() []*RequireStorageOperationReportByIdContext { + if x != nil { + return x.Context + } + return nil +} + +type RequireStorageOperationReportByIdContext struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Fields *RequireStorageOperationReportByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RequireStorageOperationReportByIdContext) Reset() { + *x = RequireStorageOperationReportByIdContext{} + mi := &file_product_proto_msgTypes[319] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireStorageOperationReportByIdContext) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageOperationReportByIdContext) ProtoMessage() {} + +func (x *RequireStorageOperationReportByIdContext) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[319] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RequireStorageOperationReportByIdContext.ProtoReflect.Descriptor instead. +func (*RequireStorageOperationReportByIdContext) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{319} +} + +func (x *RequireStorageOperationReportByIdContext) GetKey() *LookupStorageByIdRequestKey { + if x != nil { + return x.Key + } + return nil +} + +func (x *RequireStorageOperationReportByIdContext) GetFields() *RequireStorageOperationReportByIdFields { + if x != nil { + return x.Fields + } + return nil +} + +type RequireStorageOperationReportByIdResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // RequireStorageOperationReportByIdResult provides the result for the required fields method RequireStorageOperationReportById. + Result []*RequireStorageOperationReportByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RequireStorageOperationReportByIdResponse) Reset() { + *x = RequireStorageOperationReportByIdResponse{} + mi := &file_product_proto_msgTypes[320] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireStorageOperationReportByIdResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageOperationReportByIdResponse) ProtoMessage() {} + +func (x *RequireStorageOperationReportByIdResponse) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[320] + 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 RequireStorageOperationReportByIdResponse.ProtoReflect.Descriptor instead. +func (*RequireStorageOperationReportByIdResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{320} +} + +func (x *RequireStorageOperationReportByIdResponse) GetResult() []*RequireStorageOperationReportByIdResult { + if x != nil { + return x.Result + } + return nil +} + +type RequireStorageOperationReportByIdResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + OperationReport string `protobuf:"bytes,1,opt,name=operation_report,json=operationReport,proto3" json:"operation_report,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RequireStorageOperationReportByIdResult) Reset() { + *x = RequireStorageOperationReportByIdResult{} + mi := &file_product_proto_msgTypes[321] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireStorageOperationReportByIdResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageOperationReportByIdResult) ProtoMessage() {} + +func (x *RequireStorageOperationReportByIdResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[321] + 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 RequireStorageOperationReportByIdResult.ProtoReflect.Descriptor instead. +func (*RequireStorageOperationReportByIdResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{321} +} + +func (x *RequireStorageOperationReportByIdResult) GetOperationReport() string { + if x != nil { + return x.OperationReport + } + return "" +} + +type RequireStorageOperationReportByIdFields struct { + state protoimpl.MessageState `protogen:"open.v1"` + LastStorageOperation *RequireStorageOperationReportByIdFields_StorageOperationResult `protobuf:"bytes,1,opt,name=last_storage_operation,json=lastStorageOperation,proto3" json:"last_storage_operation,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RequireStorageOperationReportByIdFields) Reset() { + *x = RequireStorageOperationReportByIdFields{} + mi := &file_product_proto_msgTypes[322] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireStorageOperationReportByIdFields) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageOperationReportByIdFields) ProtoMessage() {} + +func (x *RequireStorageOperationReportByIdFields) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[322] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RequireStorageOperationReportByIdFields.ProtoReflect.Descriptor instead. +func (*RequireStorageOperationReportByIdFields) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{322} +} + +func (x *RequireStorageOperationReportByIdFields) GetLastStorageOperation() *RequireStorageOperationReportByIdFields_StorageOperationResult { + if x != nil { + return x.LastStorageOperation + } + return nil +} + +type RequireStorageSecuritySummaryByIdRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // RequireStorageSecuritySummaryByIdContext provides the context for the required fields method RequireStorageSecuritySummaryById. + Context []*RequireStorageSecuritySummaryByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RequireStorageSecuritySummaryByIdRequest) Reset() { + *x = RequireStorageSecuritySummaryByIdRequest{} + mi := &file_product_proto_msgTypes[323] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireStorageSecuritySummaryByIdRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageSecuritySummaryByIdRequest) ProtoMessage() {} + +func (x *RequireStorageSecuritySummaryByIdRequest) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[323] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RequireStorageSecuritySummaryByIdRequest.ProtoReflect.Descriptor instead. +func (*RequireStorageSecuritySummaryByIdRequest) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{323} +} + +func (x *RequireStorageSecuritySummaryByIdRequest) GetContext() []*RequireStorageSecuritySummaryByIdContext { + if x != nil { + return x.Context + } + return nil +} + +type RequireStorageSecuritySummaryByIdContext struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Fields *RequireStorageSecuritySummaryByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RequireStorageSecuritySummaryByIdContext) Reset() { + *x = RequireStorageSecuritySummaryByIdContext{} + mi := &file_product_proto_msgTypes[324] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireStorageSecuritySummaryByIdContext) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageSecuritySummaryByIdContext) ProtoMessage() {} + +func (x *RequireStorageSecuritySummaryByIdContext) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[324] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RequireStorageSecuritySummaryByIdContext.ProtoReflect.Descriptor instead. +func (*RequireStorageSecuritySummaryByIdContext) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{324} +} + +func (x *RequireStorageSecuritySummaryByIdContext) GetKey() *LookupStorageByIdRequestKey { + if x != nil { + return x.Key + } + return nil +} + +func (x *RequireStorageSecuritySummaryByIdContext) GetFields() *RequireStorageSecuritySummaryByIdFields { + if x != nil { + return x.Fields + } + return nil +} + +type RequireStorageSecuritySummaryByIdResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // RequireStorageSecuritySummaryByIdResult provides the result for the required fields method RequireStorageSecuritySummaryById. + Result []*RequireStorageSecuritySummaryByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RequireStorageSecuritySummaryByIdResponse) Reset() { + *x = RequireStorageSecuritySummaryByIdResponse{} + mi := &file_product_proto_msgTypes[325] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireStorageSecuritySummaryByIdResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageSecuritySummaryByIdResponse) ProtoMessage() {} + +func (x *RequireStorageSecuritySummaryByIdResponse) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[325] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RequireStorageSecuritySummaryByIdResponse.ProtoReflect.Descriptor instead. +func (*RequireStorageSecuritySummaryByIdResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{325} +} + +func (x *RequireStorageSecuritySummaryByIdResponse) GetResult() []*RequireStorageSecuritySummaryByIdResult { + if x != nil { + return x.Result + } + return nil +} + +type RequireStorageSecuritySummaryByIdResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + SecuritySummary string `protobuf:"bytes,1,opt,name=security_summary,json=securitySummary,proto3" json:"security_summary,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RequireStorageSecuritySummaryByIdResult) Reset() { + *x = RequireStorageSecuritySummaryByIdResult{} + mi := &file_product_proto_msgTypes[326] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireStorageSecuritySummaryByIdResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageSecuritySummaryByIdResult) ProtoMessage() {} + +func (x *RequireStorageSecuritySummaryByIdResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[326] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RequireStorageSecuritySummaryByIdResult.ProtoReflect.Descriptor instead. +func (*RequireStorageSecuritySummaryByIdResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{326} } -func (x *RequireStorageItemInfoByIdResult) GetItemInfo() string { +func (x *RequireStorageSecuritySummaryByIdResult) GetSecuritySummary() string { if x != nil { - return x.ItemInfo + return x.SecuritySummary } return "" } -type RequireStorageItemInfoByIdFields struct { - state protoimpl.MessageState `protogen:"open.v1"` - PrimaryItem *RequireStorageItemInfoByIdFields_StorageItem `protobuf:"bytes,1,opt,name=primary_item,json=primaryItem,proto3" json:"primary_item,omitempty"` +type RequireStorageSecuritySummaryByIdFields struct { + state protoimpl.MessageState `protogen:"open.v1"` + SecuritySetup *RequireStorageSecuritySummaryByIdFields_SecuritySetup `protobuf:"bytes,1,opt,name=security_setup,json=securitySetup,proto3" json:"security_setup,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageItemInfoByIdFields) Reset() { - *x = RequireStorageItemInfoByIdFields{} - mi := &file_product_proto_msgTypes[302] +func (x *RequireStorageSecuritySummaryByIdFields) Reset() { + *x = RequireStorageSecuritySummaryByIdFields{} + mi := &file_product_proto_msgTypes[327] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageItemInfoByIdFields) String() string { +func (x *RequireStorageSecuritySummaryByIdFields) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageItemInfoByIdFields) ProtoMessage() {} +func (*RequireStorageSecuritySummaryByIdFields) ProtoMessage() {} -func (x *RequireStorageItemInfoByIdFields) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[302] +func (x *RequireStorageSecuritySummaryByIdFields) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[327] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14057,41 +15205,41 @@ func (x *RequireStorageItemInfoByIdFields) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use RequireStorageItemInfoByIdFields.ProtoReflect.Descriptor instead. -func (*RequireStorageItemInfoByIdFields) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{302} +// Deprecated: Use RequireStorageSecuritySummaryByIdFields.ProtoReflect.Descriptor instead. +func (*RequireStorageSecuritySummaryByIdFields) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{327} } -func (x *RequireStorageItemInfoByIdFields) GetPrimaryItem() *RequireStorageItemInfoByIdFields_StorageItem { +func (x *RequireStorageSecuritySummaryByIdFields) GetSecuritySetup() *RequireStorageSecuritySummaryByIdFields_SecuritySetup { if x != nil { - return x.PrimaryItem + return x.SecuritySetup } return nil } -type RequireStorageOperationReportByIdRequest struct { +type RequireStorageItemHandlerInfoByIdRequest struct { state protoimpl.MessageState `protogen:"open.v1"` - // RequireStorageOperationReportByIdContext provides the context for the required fields method RequireStorageOperationReportById. - Context []*RequireStorageOperationReportByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` + // RequireStorageItemHandlerInfoByIdContext provides the context for the required fields method RequireStorageItemHandlerInfoById. + Context []*RequireStorageItemHandlerInfoByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageOperationReportByIdRequest) Reset() { - *x = RequireStorageOperationReportByIdRequest{} - mi := &file_product_proto_msgTypes[303] +func (x *RequireStorageItemHandlerInfoByIdRequest) Reset() { + *x = RequireStorageItemHandlerInfoByIdRequest{} + mi := &file_product_proto_msgTypes[328] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageOperationReportByIdRequest) String() string { +func (x *RequireStorageItemHandlerInfoByIdRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageOperationReportByIdRequest) ProtoMessage() {} +func (*RequireStorageItemHandlerInfoByIdRequest) ProtoMessage() {} -func (x *RequireStorageOperationReportByIdRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[303] +func (x *RequireStorageItemHandlerInfoByIdRequest) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[328] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14102,41 +15250,41 @@ func (x *RequireStorageOperationReportByIdRequest) ProtoReflect() protoreflect.M return mi.MessageOf(x) } -// Deprecated: Use RequireStorageOperationReportByIdRequest.ProtoReflect.Descriptor instead. -func (*RequireStorageOperationReportByIdRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{303} +// Deprecated: Use RequireStorageItemHandlerInfoByIdRequest.ProtoReflect.Descriptor instead. +func (*RequireStorageItemHandlerInfoByIdRequest) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{328} } -func (x *RequireStorageOperationReportByIdRequest) GetContext() []*RequireStorageOperationReportByIdContext { +func (x *RequireStorageItemHandlerInfoByIdRequest) GetContext() []*RequireStorageItemHandlerInfoByIdContext { if x != nil { return x.Context } return nil } -type RequireStorageOperationReportByIdContext struct { +type RequireStorageItemHandlerInfoByIdContext struct { state protoimpl.MessageState `protogen:"open.v1"` Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` - Fields *RequireStorageOperationReportByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` + Fields *RequireStorageItemHandlerInfoByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageOperationReportByIdContext) Reset() { - *x = RequireStorageOperationReportByIdContext{} - mi := &file_product_proto_msgTypes[304] +func (x *RequireStorageItemHandlerInfoByIdContext) Reset() { + *x = RequireStorageItemHandlerInfoByIdContext{} + mi := &file_product_proto_msgTypes[329] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageOperationReportByIdContext) String() string { +func (x *RequireStorageItemHandlerInfoByIdContext) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageOperationReportByIdContext) ProtoMessage() {} +func (*RequireStorageItemHandlerInfoByIdContext) ProtoMessage() {} -func (x *RequireStorageOperationReportByIdContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[304] +func (x *RequireStorageItemHandlerInfoByIdContext) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[329] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14147,48 +15295,48 @@ func (x *RequireStorageOperationReportByIdContext) ProtoReflect() protoreflect.M return mi.MessageOf(x) } -// Deprecated: Use RequireStorageOperationReportByIdContext.ProtoReflect.Descriptor instead. -func (*RequireStorageOperationReportByIdContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{304} +// Deprecated: Use RequireStorageItemHandlerInfoByIdContext.ProtoReflect.Descriptor instead. +func (*RequireStorageItemHandlerInfoByIdContext) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{329} } -func (x *RequireStorageOperationReportByIdContext) GetKey() *LookupStorageByIdRequestKey { +func (x *RequireStorageItemHandlerInfoByIdContext) GetKey() *LookupStorageByIdRequestKey { if x != nil { return x.Key } return nil } -func (x *RequireStorageOperationReportByIdContext) GetFields() *RequireStorageOperationReportByIdFields { +func (x *RequireStorageItemHandlerInfoByIdContext) GetFields() *RequireStorageItemHandlerInfoByIdFields { if x != nil { return x.Fields } return nil } -type RequireStorageOperationReportByIdResponse struct { +type RequireStorageItemHandlerInfoByIdResponse struct { state protoimpl.MessageState `protogen:"open.v1"` - // RequireStorageOperationReportByIdResult provides the result for the required fields method RequireStorageOperationReportById. - Result []*RequireStorageOperationReportByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` + // RequireStorageItemHandlerInfoByIdResult provides the result for the required fields method RequireStorageItemHandlerInfoById. + Result []*RequireStorageItemHandlerInfoByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageOperationReportByIdResponse) Reset() { - *x = RequireStorageOperationReportByIdResponse{} - mi := &file_product_proto_msgTypes[305] +func (x *RequireStorageItemHandlerInfoByIdResponse) Reset() { + *x = RequireStorageItemHandlerInfoByIdResponse{} + mi := &file_product_proto_msgTypes[330] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageOperationReportByIdResponse) String() string { +func (x *RequireStorageItemHandlerInfoByIdResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageOperationReportByIdResponse) ProtoMessage() {} +func (*RequireStorageItemHandlerInfoByIdResponse) ProtoMessage() {} -func (x *RequireStorageOperationReportByIdResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[305] +func (x *RequireStorageItemHandlerInfoByIdResponse) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[330] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14199,40 +15347,40 @@ func (x *RequireStorageOperationReportByIdResponse) ProtoReflect() protoreflect. return mi.MessageOf(x) } -// Deprecated: Use RequireStorageOperationReportByIdResponse.ProtoReflect.Descriptor instead. -func (*RequireStorageOperationReportByIdResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{305} +// Deprecated: Use RequireStorageItemHandlerInfoByIdResponse.ProtoReflect.Descriptor instead. +func (*RequireStorageItemHandlerInfoByIdResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{330} } -func (x *RequireStorageOperationReportByIdResponse) GetResult() []*RequireStorageOperationReportByIdResult { +func (x *RequireStorageItemHandlerInfoByIdResponse) GetResult() []*RequireStorageItemHandlerInfoByIdResult { if x != nil { return x.Result } return nil } -type RequireStorageOperationReportByIdResult struct { +type RequireStorageItemHandlerInfoByIdResult struct { state protoimpl.MessageState `protogen:"open.v1"` - OperationReport string `protobuf:"bytes,1,opt,name=operation_report,json=operationReport,proto3" json:"operation_report,omitempty"` + ItemHandlerInfo string `protobuf:"bytes,1,opt,name=item_handler_info,json=itemHandlerInfo,proto3" json:"item_handler_info,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageOperationReportByIdResult) Reset() { - *x = RequireStorageOperationReportByIdResult{} - mi := &file_product_proto_msgTypes[306] +func (x *RequireStorageItemHandlerInfoByIdResult) Reset() { + *x = RequireStorageItemHandlerInfoByIdResult{} + mi := &file_product_proto_msgTypes[331] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageOperationReportByIdResult) String() string { +func (x *RequireStorageItemHandlerInfoByIdResult) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageOperationReportByIdResult) ProtoMessage() {} +func (*RequireStorageItemHandlerInfoByIdResult) ProtoMessage() {} -func (x *RequireStorageOperationReportByIdResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[306] +func (x *RequireStorageItemHandlerInfoByIdResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[331] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14243,40 +15391,40 @@ func (x *RequireStorageOperationReportByIdResult) ProtoReflect() protoreflect.Me return mi.MessageOf(x) } -// Deprecated: Use RequireStorageOperationReportByIdResult.ProtoReflect.Descriptor instead. -func (*RequireStorageOperationReportByIdResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{306} +// Deprecated: Use RequireStorageItemHandlerInfoByIdResult.ProtoReflect.Descriptor instead. +func (*RequireStorageItemHandlerInfoByIdResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{331} } -func (x *RequireStorageOperationReportByIdResult) GetOperationReport() string { +func (x *RequireStorageItemHandlerInfoByIdResult) GetItemHandlerInfo() string { if x != nil { - return x.OperationReport + return x.ItemHandlerInfo } return "" } -type RequireStorageOperationReportByIdFields struct { - state protoimpl.MessageState `protogen:"open.v1"` - LastStorageOperation *RequireStorageOperationReportByIdFields_StorageOperationResult `protobuf:"bytes,1,opt,name=last_storage_operation,json=lastStorageOperation,proto3" json:"last_storage_operation,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type RequireStorageItemHandlerInfoByIdFields struct { + state protoimpl.MessageState `protogen:"open.v1"` + PrimaryItem *RequireStorageItemHandlerInfoByIdFields_StorageItem `protobuf:"bytes,1,opt,name=primary_item,json=primaryItem,proto3" json:"primary_item,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *RequireStorageOperationReportByIdFields) Reset() { - *x = RequireStorageOperationReportByIdFields{} - mi := &file_product_proto_msgTypes[307] +func (x *RequireStorageItemHandlerInfoByIdFields) Reset() { + *x = RequireStorageItemHandlerInfoByIdFields{} + mi := &file_product_proto_msgTypes[332] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageOperationReportByIdFields) String() string { +func (x *RequireStorageItemHandlerInfoByIdFields) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageOperationReportByIdFields) ProtoMessage() {} +func (*RequireStorageItemHandlerInfoByIdFields) ProtoMessage() {} -func (x *RequireStorageOperationReportByIdFields) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[307] +func (x *RequireStorageItemHandlerInfoByIdFields) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[332] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14287,41 +15435,41 @@ func (x *RequireStorageOperationReportByIdFields) ProtoReflect() protoreflect.Me return mi.MessageOf(x) } -// Deprecated: Use RequireStorageOperationReportByIdFields.ProtoReflect.Descriptor instead. -func (*RequireStorageOperationReportByIdFields) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{307} +// Deprecated: Use RequireStorageItemHandlerInfoByIdFields.ProtoReflect.Descriptor instead. +func (*RequireStorageItemHandlerInfoByIdFields) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{332} } -func (x *RequireStorageOperationReportByIdFields) GetLastStorageOperation() *RequireStorageOperationReportByIdFields_StorageOperationResult { +func (x *RequireStorageItemHandlerInfoByIdFields) GetPrimaryItem() *RequireStorageItemHandlerInfoByIdFields_StorageItem { if x != nil { - return x.LastStorageOperation + return x.PrimaryItem } return nil } -type RequireStorageSecuritySummaryByIdRequest struct { +type RequireStorageItemSpecsInfoByIdRequest struct { state protoimpl.MessageState `protogen:"open.v1"` - // RequireStorageSecuritySummaryByIdContext provides the context for the required fields method RequireStorageSecuritySummaryById. - Context []*RequireStorageSecuritySummaryByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` + // RequireStorageItemSpecsInfoByIdContext provides the context for the required fields method RequireStorageItemSpecsInfoById. + Context []*RequireStorageItemSpecsInfoByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageSecuritySummaryByIdRequest) Reset() { - *x = RequireStorageSecuritySummaryByIdRequest{} - mi := &file_product_proto_msgTypes[308] +func (x *RequireStorageItemSpecsInfoByIdRequest) Reset() { + *x = RequireStorageItemSpecsInfoByIdRequest{} + mi := &file_product_proto_msgTypes[333] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageSecuritySummaryByIdRequest) String() string { +func (x *RequireStorageItemSpecsInfoByIdRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageSecuritySummaryByIdRequest) ProtoMessage() {} +func (*RequireStorageItemSpecsInfoByIdRequest) ProtoMessage() {} -func (x *RequireStorageSecuritySummaryByIdRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[308] +func (x *RequireStorageItemSpecsInfoByIdRequest) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[333] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14332,41 +15480,41 @@ func (x *RequireStorageSecuritySummaryByIdRequest) ProtoReflect() protoreflect.M return mi.MessageOf(x) } -// Deprecated: Use RequireStorageSecuritySummaryByIdRequest.ProtoReflect.Descriptor instead. -func (*RequireStorageSecuritySummaryByIdRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{308} +// Deprecated: Use RequireStorageItemSpecsInfoByIdRequest.ProtoReflect.Descriptor instead. +func (*RequireStorageItemSpecsInfoByIdRequest) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{333} } -func (x *RequireStorageSecuritySummaryByIdRequest) GetContext() []*RequireStorageSecuritySummaryByIdContext { +func (x *RequireStorageItemSpecsInfoByIdRequest) GetContext() []*RequireStorageItemSpecsInfoByIdContext { if x != nil { return x.Context } return nil } -type RequireStorageSecuritySummaryByIdContext struct { - state protoimpl.MessageState `protogen:"open.v1"` - Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` - Fields *RequireStorageSecuritySummaryByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` +type RequireStorageItemSpecsInfoByIdContext struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Fields *RequireStorageItemSpecsInfoByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageSecuritySummaryByIdContext) Reset() { - *x = RequireStorageSecuritySummaryByIdContext{} - mi := &file_product_proto_msgTypes[309] +func (x *RequireStorageItemSpecsInfoByIdContext) Reset() { + *x = RequireStorageItemSpecsInfoByIdContext{} + mi := &file_product_proto_msgTypes[334] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageSecuritySummaryByIdContext) String() string { +func (x *RequireStorageItemSpecsInfoByIdContext) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageSecuritySummaryByIdContext) ProtoMessage() {} +func (*RequireStorageItemSpecsInfoByIdContext) ProtoMessage() {} -func (x *RequireStorageSecuritySummaryByIdContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[309] +func (x *RequireStorageItemSpecsInfoByIdContext) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[334] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14377,48 +15525,48 @@ func (x *RequireStorageSecuritySummaryByIdContext) ProtoReflect() protoreflect.M return mi.MessageOf(x) } -// Deprecated: Use RequireStorageSecuritySummaryByIdContext.ProtoReflect.Descriptor instead. -func (*RequireStorageSecuritySummaryByIdContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{309} +// Deprecated: Use RequireStorageItemSpecsInfoByIdContext.ProtoReflect.Descriptor instead. +func (*RequireStorageItemSpecsInfoByIdContext) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{334} } -func (x *RequireStorageSecuritySummaryByIdContext) GetKey() *LookupStorageByIdRequestKey { +func (x *RequireStorageItemSpecsInfoByIdContext) GetKey() *LookupStorageByIdRequestKey { if x != nil { return x.Key } return nil } -func (x *RequireStorageSecuritySummaryByIdContext) GetFields() *RequireStorageSecuritySummaryByIdFields { +func (x *RequireStorageItemSpecsInfoByIdContext) GetFields() *RequireStorageItemSpecsInfoByIdFields { if x != nil { return x.Fields } return nil } -type RequireStorageSecuritySummaryByIdResponse struct { +type RequireStorageItemSpecsInfoByIdResponse struct { state protoimpl.MessageState `protogen:"open.v1"` - // RequireStorageSecuritySummaryByIdResult provides the result for the required fields method RequireStorageSecuritySummaryById. - Result []*RequireStorageSecuritySummaryByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` + // RequireStorageItemSpecsInfoByIdResult provides the result for the required fields method RequireStorageItemSpecsInfoById. + Result []*RequireStorageItemSpecsInfoByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageSecuritySummaryByIdResponse) Reset() { - *x = RequireStorageSecuritySummaryByIdResponse{} - mi := &file_product_proto_msgTypes[310] +func (x *RequireStorageItemSpecsInfoByIdResponse) Reset() { + *x = RequireStorageItemSpecsInfoByIdResponse{} + mi := &file_product_proto_msgTypes[335] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageSecuritySummaryByIdResponse) String() string { +func (x *RequireStorageItemSpecsInfoByIdResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageSecuritySummaryByIdResponse) ProtoMessage() {} +func (*RequireStorageItemSpecsInfoByIdResponse) ProtoMessage() {} -func (x *RequireStorageSecuritySummaryByIdResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[310] +func (x *RequireStorageItemSpecsInfoByIdResponse) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[335] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14429,40 +15577,40 @@ func (x *RequireStorageSecuritySummaryByIdResponse) ProtoReflect() protoreflect. return mi.MessageOf(x) } -// Deprecated: Use RequireStorageSecuritySummaryByIdResponse.ProtoReflect.Descriptor instead. -func (*RequireStorageSecuritySummaryByIdResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{310} +// Deprecated: Use RequireStorageItemSpecsInfoByIdResponse.ProtoReflect.Descriptor instead. +func (*RequireStorageItemSpecsInfoByIdResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{335} } -func (x *RequireStorageSecuritySummaryByIdResponse) GetResult() []*RequireStorageSecuritySummaryByIdResult { +func (x *RequireStorageItemSpecsInfoByIdResponse) GetResult() []*RequireStorageItemSpecsInfoByIdResult { if x != nil { return x.Result } return nil } -type RequireStorageSecuritySummaryByIdResult struct { - state protoimpl.MessageState `protogen:"open.v1"` - SecuritySummary string `protobuf:"bytes,1,opt,name=security_summary,json=securitySummary,proto3" json:"security_summary,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type RequireStorageItemSpecsInfoByIdResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + ItemSpecsInfo string `protobuf:"bytes,1,opt,name=item_specs_info,json=itemSpecsInfo,proto3" json:"item_specs_info,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *RequireStorageSecuritySummaryByIdResult) Reset() { - *x = RequireStorageSecuritySummaryByIdResult{} - mi := &file_product_proto_msgTypes[311] +func (x *RequireStorageItemSpecsInfoByIdResult) Reset() { + *x = RequireStorageItemSpecsInfoByIdResult{} + mi := &file_product_proto_msgTypes[336] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageSecuritySummaryByIdResult) String() string { +func (x *RequireStorageItemSpecsInfoByIdResult) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageSecuritySummaryByIdResult) ProtoMessage() {} +func (*RequireStorageItemSpecsInfoByIdResult) ProtoMessage() {} -func (x *RequireStorageSecuritySummaryByIdResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[311] +func (x *RequireStorageItemSpecsInfoByIdResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[336] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14473,40 +15621,40 @@ func (x *RequireStorageSecuritySummaryByIdResult) ProtoReflect() protoreflect.Me return mi.MessageOf(x) } -// Deprecated: Use RequireStorageSecuritySummaryByIdResult.ProtoReflect.Descriptor instead. -func (*RequireStorageSecuritySummaryByIdResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{311} +// Deprecated: Use RequireStorageItemSpecsInfoByIdResult.ProtoReflect.Descriptor instead. +func (*RequireStorageItemSpecsInfoByIdResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{336} } -func (x *RequireStorageSecuritySummaryByIdResult) GetSecuritySummary() string { +func (x *RequireStorageItemSpecsInfoByIdResult) GetItemSpecsInfo() string { if x != nil { - return x.SecuritySummary + return x.ItemSpecsInfo } return "" } -type RequireStorageSecuritySummaryByIdFields struct { - state protoimpl.MessageState `protogen:"open.v1"` - SecuritySetup *RequireStorageSecuritySummaryByIdFields_SecuritySetup `protobuf:"bytes,1,opt,name=security_setup,json=securitySetup,proto3" json:"security_setup,omitempty"` +type RequireStorageItemSpecsInfoByIdFields struct { + state protoimpl.MessageState `protogen:"open.v1"` + PrimaryItem *RequireStorageItemSpecsInfoByIdFields_StorageItem `protobuf:"bytes,1,opt,name=primary_item,json=primaryItem,proto3" json:"primary_item,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageSecuritySummaryByIdFields) Reset() { - *x = RequireStorageSecuritySummaryByIdFields{} - mi := &file_product_proto_msgTypes[312] +func (x *RequireStorageItemSpecsInfoByIdFields) Reset() { + *x = RequireStorageItemSpecsInfoByIdFields{} + mi := &file_product_proto_msgTypes[337] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageSecuritySummaryByIdFields) String() string { +func (x *RequireStorageItemSpecsInfoByIdFields) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageSecuritySummaryByIdFields) ProtoMessage() {} +func (*RequireStorageItemSpecsInfoByIdFields) ProtoMessage() {} -func (x *RequireStorageSecuritySummaryByIdFields) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[312] +func (x *RequireStorageItemSpecsInfoByIdFields) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[337] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14517,41 +15665,41 @@ func (x *RequireStorageSecuritySummaryByIdFields) ProtoReflect() protoreflect.Me return mi.MessageOf(x) } -// Deprecated: Use RequireStorageSecuritySummaryByIdFields.ProtoReflect.Descriptor instead. -func (*RequireStorageSecuritySummaryByIdFields) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{312} +// Deprecated: Use RequireStorageItemSpecsInfoByIdFields.ProtoReflect.Descriptor instead. +func (*RequireStorageItemSpecsInfoByIdFields) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{337} } -func (x *RequireStorageSecuritySummaryByIdFields) GetSecuritySetup() *RequireStorageSecuritySummaryByIdFields_SecuritySetup { +func (x *RequireStorageItemSpecsInfoByIdFields) GetPrimaryItem() *RequireStorageItemSpecsInfoByIdFields_StorageItem { if x != nil { - return x.SecuritySetup + return x.PrimaryItem } return nil } -type RequireStorageItemHandlerInfoByIdRequest struct { +type RequireStorageDeepItemInfoByIdRequest struct { state protoimpl.MessageState `protogen:"open.v1"` - // RequireStorageItemHandlerInfoByIdContext provides the context for the required fields method RequireStorageItemHandlerInfoById. - Context []*RequireStorageItemHandlerInfoByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` + // RequireStorageDeepItemInfoByIdContext provides the context for the required fields method RequireStorageDeepItemInfoById. + Context []*RequireStorageDeepItemInfoByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageItemHandlerInfoByIdRequest) Reset() { - *x = RequireStorageItemHandlerInfoByIdRequest{} - mi := &file_product_proto_msgTypes[313] +func (x *RequireStorageDeepItemInfoByIdRequest) Reset() { + *x = RequireStorageDeepItemInfoByIdRequest{} + mi := &file_product_proto_msgTypes[338] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageItemHandlerInfoByIdRequest) String() string { +func (x *RequireStorageDeepItemInfoByIdRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageItemHandlerInfoByIdRequest) ProtoMessage() {} +func (*RequireStorageDeepItemInfoByIdRequest) ProtoMessage() {} -func (x *RequireStorageItemHandlerInfoByIdRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[313] +func (x *RequireStorageDeepItemInfoByIdRequest) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[338] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14562,41 +15710,41 @@ func (x *RequireStorageItemHandlerInfoByIdRequest) ProtoReflect() protoreflect.M return mi.MessageOf(x) } -// Deprecated: Use RequireStorageItemHandlerInfoByIdRequest.ProtoReflect.Descriptor instead. -func (*RequireStorageItemHandlerInfoByIdRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{313} +// Deprecated: Use RequireStorageDeepItemInfoByIdRequest.ProtoReflect.Descriptor instead. +func (*RequireStorageDeepItemInfoByIdRequest) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{338} } -func (x *RequireStorageItemHandlerInfoByIdRequest) GetContext() []*RequireStorageItemHandlerInfoByIdContext { +func (x *RequireStorageDeepItemInfoByIdRequest) GetContext() []*RequireStorageDeepItemInfoByIdContext { if x != nil { return x.Context } return nil } -type RequireStorageItemHandlerInfoByIdContext struct { - state protoimpl.MessageState `protogen:"open.v1"` - Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` - Fields *RequireStorageItemHandlerInfoByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` +type RequireStorageDeepItemInfoByIdContext struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Fields *RequireStorageDeepItemInfoByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageItemHandlerInfoByIdContext) Reset() { - *x = RequireStorageItemHandlerInfoByIdContext{} - mi := &file_product_proto_msgTypes[314] +func (x *RequireStorageDeepItemInfoByIdContext) Reset() { + *x = RequireStorageDeepItemInfoByIdContext{} + mi := &file_product_proto_msgTypes[339] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageItemHandlerInfoByIdContext) String() string { +func (x *RequireStorageDeepItemInfoByIdContext) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageItemHandlerInfoByIdContext) ProtoMessage() {} +func (*RequireStorageDeepItemInfoByIdContext) ProtoMessage() {} -func (x *RequireStorageItemHandlerInfoByIdContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[314] +func (x *RequireStorageDeepItemInfoByIdContext) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[339] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14607,48 +15755,48 @@ func (x *RequireStorageItemHandlerInfoByIdContext) ProtoReflect() protoreflect.M return mi.MessageOf(x) } -// Deprecated: Use RequireStorageItemHandlerInfoByIdContext.ProtoReflect.Descriptor instead. -func (*RequireStorageItemHandlerInfoByIdContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{314} +// Deprecated: Use RequireStorageDeepItemInfoByIdContext.ProtoReflect.Descriptor instead. +func (*RequireStorageDeepItemInfoByIdContext) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{339} } -func (x *RequireStorageItemHandlerInfoByIdContext) GetKey() *LookupStorageByIdRequestKey { +func (x *RequireStorageDeepItemInfoByIdContext) GetKey() *LookupStorageByIdRequestKey { if x != nil { return x.Key } return nil } -func (x *RequireStorageItemHandlerInfoByIdContext) GetFields() *RequireStorageItemHandlerInfoByIdFields { +func (x *RequireStorageDeepItemInfoByIdContext) GetFields() *RequireStorageDeepItemInfoByIdFields { if x != nil { return x.Fields } return nil } -type RequireStorageItemHandlerInfoByIdResponse struct { +type RequireStorageDeepItemInfoByIdResponse struct { state protoimpl.MessageState `protogen:"open.v1"` - // RequireStorageItemHandlerInfoByIdResult provides the result for the required fields method RequireStorageItemHandlerInfoById. - Result []*RequireStorageItemHandlerInfoByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` + // RequireStorageDeepItemInfoByIdResult provides the result for the required fields method RequireStorageDeepItemInfoById. + Result []*RequireStorageDeepItemInfoByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageItemHandlerInfoByIdResponse) Reset() { - *x = RequireStorageItemHandlerInfoByIdResponse{} - mi := &file_product_proto_msgTypes[315] +func (x *RequireStorageDeepItemInfoByIdResponse) Reset() { + *x = RequireStorageDeepItemInfoByIdResponse{} + mi := &file_product_proto_msgTypes[340] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageItemHandlerInfoByIdResponse) String() string { +func (x *RequireStorageDeepItemInfoByIdResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageItemHandlerInfoByIdResponse) ProtoMessage() {} +func (*RequireStorageDeepItemInfoByIdResponse) ProtoMessage() {} -func (x *RequireStorageItemHandlerInfoByIdResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[315] +func (x *RequireStorageDeepItemInfoByIdResponse) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[340] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14659,40 +15807,40 @@ func (x *RequireStorageItemHandlerInfoByIdResponse) ProtoReflect() protoreflect. return mi.MessageOf(x) } -// Deprecated: Use RequireStorageItemHandlerInfoByIdResponse.ProtoReflect.Descriptor instead. -func (*RequireStorageItemHandlerInfoByIdResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{315} +// Deprecated: Use RequireStorageDeepItemInfoByIdResponse.ProtoReflect.Descriptor instead. +func (*RequireStorageDeepItemInfoByIdResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{340} } -func (x *RequireStorageItemHandlerInfoByIdResponse) GetResult() []*RequireStorageItemHandlerInfoByIdResult { +func (x *RequireStorageDeepItemInfoByIdResponse) GetResult() []*RequireStorageDeepItemInfoByIdResult { if x != nil { return x.Result } return nil } -type RequireStorageItemHandlerInfoByIdResult struct { - state protoimpl.MessageState `protogen:"open.v1"` - ItemHandlerInfo string `protobuf:"bytes,1,opt,name=item_handler_info,json=itemHandlerInfo,proto3" json:"item_handler_info,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type RequireStorageDeepItemInfoByIdResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + DeepItemInfo string `protobuf:"bytes,1,opt,name=deep_item_info,json=deepItemInfo,proto3" json:"deep_item_info,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *RequireStorageItemHandlerInfoByIdResult) Reset() { - *x = RequireStorageItemHandlerInfoByIdResult{} - mi := &file_product_proto_msgTypes[316] +func (x *RequireStorageDeepItemInfoByIdResult) Reset() { + *x = RequireStorageDeepItemInfoByIdResult{} + mi := &file_product_proto_msgTypes[341] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageItemHandlerInfoByIdResult) String() string { +func (x *RequireStorageDeepItemInfoByIdResult) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageItemHandlerInfoByIdResult) ProtoMessage() {} +func (*RequireStorageDeepItemInfoByIdResult) ProtoMessage() {} -func (x *RequireStorageItemHandlerInfoByIdResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[316] +func (x *RequireStorageDeepItemInfoByIdResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[341] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14703,40 +15851,40 @@ func (x *RequireStorageItemHandlerInfoByIdResult) ProtoReflect() protoreflect.Me return mi.MessageOf(x) } -// Deprecated: Use RequireStorageItemHandlerInfoByIdResult.ProtoReflect.Descriptor instead. -func (*RequireStorageItemHandlerInfoByIdResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{316} +// Deprecated: Use RequireStorageDeepItemInfoByIdResult.ProtoReflect.Descriptor instead. +func (*RequireStorageDeepItemInfoByIdResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{341} } -func (x *RequireStorageItemHandlerInfoByIdResult) GetItemHandlerInfo() string { +func (x *RequireStorageDeepItemInfoByIdResult) GetDeepItemInfo() string { if x != nil { - return x.ItemHandlerInfo + return x.DeepItemInfo } return "" } -type RequireStorageItemHandlerInfoByIdFields struct { - state protoimpl.MessageState `protogen:"open.v1"` - PrimaryItem *RequireStorageItemHandlerInfoByIdFields_StorageItem `protobuf:"bytes,1,opt,name=primary_item,json=primaryItem,proto3" json:"primary_item,omitempty"` +type RequireStorageDeepItemInfoByIdFields struct { + state protoimpl.MessageState `protogen:"open.v1"` + PrimaryItem *RequireStorageDeepItemInfoByIdFields_StorageItem `protobuf:"bytes,1,opt,name=primary_item,json=primaryItem,proto3" json:"primary_item,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageItemHandlerInfoByIdFields) Reset() { - *x = RequireStorageItemHandlerInfoByIdFields{} - mi := &file_product_proto_msgTypes[317] +func (x *RequireStorageDeepItemInfoByIdFields) Reset() { + *x = RequireStorageDeepItemInfoByIdFields{} + mi := &file_product_proto_msgTypes[342] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageItemHandlerInfoByIdFields) String() string { +func (x *RequireStorageDeepItemInfoByIdFields) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageItemHandlerInfoByIdFields) ProtoMessage() {} +func (*RequireStorageDeepItemInfoByIdFields) ProtoMessage() {} -func (x *RequireStorageItemHandlerInfoByIdFields) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[317] +func (x *RequireStorageDeepItemInfoByIdFields) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[342] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14747,41 +15895,41 @@ func (x *RequireStorageItemHandlerInfoByIdFields) ProtoReflect() protoreflect.Me return mi.MessageOf(x) } -// Deprecated: Use RequireStorageItemHandlerInfoByIdFields.ProtoReflect.Descriptor instead. -func (*RequireStorageItemHandlerInfoByIdFields) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{317} +// Deprecated: Use RequireStorageDeepItemInfoByIdFields.ProtoReflect.Descriptor instead. +func (*RequireStorageDeepItemInfoByIdFields) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{342} } -func (x *RequireStorageItemHandlerInfoByIdFields) GetPrimaryItem() *RequireStorageItemHandlerInfoByIdFields_StorageItem { +func (x *RequireStorageDeepItemInfoByIdFields) GetPrimaryItem() *RequireStorageDeepItemInfoByIdFields_StorageItem { if x != nil { return x.PrimaryItem } return nil } -type RequireStorageItemSpecsInfoByIdRequest struct { +type RequireStorageRecommendedItemByIdRequest struct { state protoimpl.MessageState `protogen:"open.v1"` - // RequireStorageItemSpecsInfoByIdContext provides the context for the required fields method RequireStorageItemSpecsInfoById. - Context []*RequireStorageItemSpecsInfoByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` + // RequireStorageRecommendedItemByIdContext provides the context for the required fields method RequireStorageRecommendedItemById. + Context []*RequireStorageRecommendedItemByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageItemSpecsInfoByIdRequest) Reset() { - *x = RequireStorageItemSpecsInfoByIdRequest{} - mi := &file_product_proto_msgTypes[318] +func (x *RequireStorageRecommendedItemByIdRequest) Reset() { + *x = RequireStorageRecommendedItemByIdRequest{} + mi := &file_product_proto_msgTypes[343] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageItemSpecsInfoByIdRequest) String() string { +func (x *RequireStorageRecommendedItemByIdRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageItemSpecsInfoByIdRequest) ProtoMessage() {} +func (*RequireStorageRecommendedItemByIdRequest) ProtoMessage() {} -func (x *RequireStorageItemSpecsInfoByIdRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[318] +func (x *RequireStorageRecommendedItemByIdRequest) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[343] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14792,41 +15940,41 @@ func (x *RequireStorageItemSpecsInfoByIdRequest) ProtoReflect() protoreflect.Mes return mi.MessageOf(x) } -// Deprecated: Use RequireStorageItemSpecsInfoByIdRequest.ProtoReflect.Descriptor instead. -func (*RequireStorageItemSpecsInfoByIdRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{318} +// Deprecated: Use RequireStorageRecommendedItemByIdRequest.ProtoReflect.Descriptor instead. +func (*RequireStorageRecommendedItemByIdRequest) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{343} } -func (x *RequireStorageItemSpecsInfoByIdRequest) GetContext() []*RequireStorageItemSpecsInfoByIdContext { +func (x *RequireStorageRecommendedItemByIdRequest) GetContext() []*RequireStorageRecommendedItemByIdContext { if x != nil { return x.Context } return nil } -type RequireStorageItemSpecsInfoByIdContext struct { - state protoimpl.MessageState `protogen:"open.v1"` - Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` - Fields *RequireStorageItemSpecsInfoByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` +type RequireStorageRecommendedItemByIdContext struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Fields *RequireStorageRecommendedItemByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageItemSpecsInfoByIdContext) Reset() { - *x = RequireStorageItemSpecsInfoByIdContext{} - mi := &file_product_proto_msgTypes[319] +func (x *RequireStorageRecommendedItemByIdContext) Reset() { + *x = RequireStorageRecommendedItemByIdContext{} + mi := &file_product_proto_msgTypes[344] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageItemSpecsInfoByIdContext) String() string { +func (x *RequireStorageRecommendedItemByIdContext) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageItemSpecsInfoByIdContext) ProtoMessage() {} +func (*RequireStorageRecommendedItemByIdContext) ProtoMessage() {} -func (x *RequireStorageItemSpecsInfoByIdContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[319] +func (x *RequireStorageRecommendedItemByIdContext) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[344] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14837,48 +15985,48 @@ func (x *RequireStorageItemSpecsInfoByIdContext) ProtoReflect() protoreflect.Mes return mi.MessageOf(x) } -// Deprecated: Use RequireStorageItemSpecsInfoByIdContext.ProtoReflect.Descriptor instead. -func (*RequireStorageItemSpecsInfoByIdContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{319} +// Deprecated: Use RequireStorageRecommendedItemByIdContext.ProtoReflect.Descriptor instead. +func (*RequireStorageRecommendedItemByIdContext) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{344} } -func (x *RequireStorageItemSpecsInfoByIdContext) GetKey() *LookupStorageByIdRequestKey { +func (x *RequireStorageRecommendedItemByIdContext) GetKey() *LookupStorageByIdRequestKey { if x != nil { return x.Key } return nil } -func (x *RequireStorageItemSpecsInfoByIdContext) GetFields() *RequireStorageItemSpecsInfoByIdFields { +func (x *RequireStorageRecommendedItemByIdContext) GetFields() *RequireStorageRecommendedItemByIdFields { if x != nil { return x.Fields } return nil } -type RequireStorageItemSpecsInfoByIdResponse struct { +type RequireStorageRecommendedItemByIdResponse struct { state protoimpl.MessageState `protogen:"open.v1"` - // RequireStorageItemSpecsInfoByIdResult provides the result for the required fields method RequireStorageItemSpecsInfoById. - Result []*RequireStorageItemSpecsInfoByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` + // RequireStorageRecommendedItemByIdResult provides the result for the required fields method RequireStorageRecommendedItemById. + Result []*RequireStorageRecommendedItemByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageItemSpecsInfoByIdResponse) Reset() { - *x = RequireStorageItemSpecsInfoByIdResponse{} - mi := &file_product_proto_msgTypes[320] +func (x *RequireStorageRecommendedItemByIdResponse) Reset() { + *x = RequireStorageRecommendedItemByIdResponse{} + mi := &file_product_proto_msgTypes[345] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageItemSpecsInfoByIdResponse) String() string { +func (x *RequireStorageRecommendedItemByIdResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageItemSpecsInfoByIdResponse) ProtoMessage() {} +func (*RequireStorageRecommendedItemByIdResponse) ProtoMessage() {} -func (x *RequireStorageItemSpecsInfoByIdResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[320] +func (x *RequireStorageRecommendedItemByIdResponse) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[345] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14889,40 +16037,40 @@ func (x *RequireStorageItemSpecsInfoByIdResponse) ProtoReflect() protoreflect.Me return mi.MessageOf(x) } -// Deprecated: Use RequireStorageItemSpecsInfoByIdResponse.ProtoReflect.Descriptor instead. -func (*RequireStorageItemSpecsInfoByIdResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{320} +// Deprecated: Use RequireStorageRecommendedItemByIdResponse.ProtoReflect.Descriptor instead. +func (*RequireStorageRecommendedItemByIdResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{345} } -func (x *RequireStorageItemSpecsInfoByIdResponse) GetResult() []*RequireStorageItemSpecsInfoByIdResult { +func (x *RequireStorageRecommendedItemByIdResponse) GetResult() []*RequireStorageRecommendedItemByIdResult { if x != nil { return x.Result } return nil } -type RequireStorageItemSpecsInfoByIdResult struct { - state protoimpl.MessageState `protogen:"open.v1"` - ItemSpecsInfo string `protobuf:"bytes,1,opt,name=item_specs_info,json=itemSpecsInfo,proto3" json:"item_specs_info,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type RequireStorageRecommendedItemByIdResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + RecommendedItem *StorageItem `protobuf:"bytes,1,opt,name=recommended_item,json=recommendedItem,proto3" json:"recommended_item,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *RequireStorageItemSpecsInfoByIdResult) Reset() { - *x = RequireStorageItemSpecsInfoByIdResult{} - mi := &file_product_proto_msgTypes[321] +func (x *RequireStorageRecommendedItemByIdResult) Reset() { + *x = RequireStorageRecommendedItemByIdResult{} + mi := &file_product_proto_msgTypes[346] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageItemSpecsInfoByIdResult) String() string { +func (x *RequireStorageRecommendedItemByIdResult) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageItemSpecsInfoByIdResult) ProtoMessage() {} +func (*RequireStorageRecommendedItemByIdResult) ProtoMessage() {} -func (x *RequireStorageItemSpecsInfoByIdResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[321] +func (x *RequireStorageRecommendedItemByIdResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[346] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14933,40 +16081,40 @@ func (x *RequireStorageItemSpecsInfoByIdResult) ProtoReflect() protoreflect.Mess return mi.MessageOf(x) } -// Deprecated: Use RequireStorageItemSpecsInfoByIdResult.ProtoReflect.Descriptor instead. -func (*RequireStorageItemSpecsInfoByIdResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{321} +// Deprecated: Use RequireStorageRecommendedItemByIdResult.ProtoReflect.Descriptor instead. +func (*RequireStorageRecommendedItemByIdResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{346} } -func (x *RequireStorageItemSpecsInfoByIdResult) GetItemSpecsInfo() string { +func (x *RequireStorageRecommendedItemByIdResult) GetRecommendedItem() *StorageItem { if x != nil { - return x.ItemSpecsInfo + return x.RecommendedItem } - return "" + return nil } -type RequireStorageItemSpecsInfoByIdFields struct { - state protoimpl.MessageState `protogen:"open.v1"` - PrimaryItem *RequireStorageItemSpecsInfoByIdFields_StorageItem `protobuf:"bytes,1,opt,name=primary_item,json=primaryItem,proto3" json:"primary_item,omitempty"` +type RequireStorageRecommendedItemByIdFields struct { + state protoimpl.MessageState `protogen:"open.v1"` + Metadata *RequireStorageRecommendedItemByIdFields_StorageMetadata `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageItemSpecsInfoByIdFields) Reset() { - *x = RequireStorageItemSpecsInfoByIdFields{} - mi := &file_product_proto_msgTypes[322] +func (x *RequireStorageRecommendedItemByIdFields) Reset() { + *x = RequireStorageRecommendedItemByIdFields{} + mi := &file_product_proto_msgTypes[347] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageItemSpecsInfoByIdFields) String() string { +func (x *RequireStorageRecommendedItemByIdFields) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageItemSpecsInfoByIdFields) ProtoMessage() {} +func (*RequireStorageRecommendedItemByIdFields) ProtoMessage() {} -func (x *RequireStorageItemSpecsInfoByIdFields) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[322] +func (x *RequireStorageRecommendedItemByIdFields) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[347] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14977,41 +16125,41 @@ func (x *RequireStorageItemSpecsInfoByIdFields) ProtoReflect() protoreflect.Mess return mi.MessageOf(x) } -// Deprecated: Use RequireStorageItemSpecsInfoByIdFields.ProtoReflect.Descriptor instead. -func (*RequireStorageItemSpecsInfoByIdFields) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{322} +// Deprecated: Use RequireStorageRecommendedItemByIdFields.ProtoReflect.Descriptor instead. +func (*RequireStorageRecommendedItemByIdFields) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{347} } -func (x *RequireStorageItemSpecsInfoByIdFields) GetPrimaryItem() *RequireStorageItemSpecsInfoByIdFields_StorageItem { +func (x *RequireStorageRecommendedItemByIdFields) GetMetadata() *RequireStorageRecommendedItemByIdFields_StorageMetadata { if x != nil { - return x.PrimaryItem + return x.Metadata } return nil } -type RequireStorageDeepItemInfoByIdRequest struct { +type RequireStorageRecommendedItemsByIdRequest struct { state protoimpl.MessageState `protogen:"open.v1"` - // RequireStorageDeepItemInfoByIdContext provides the context for the required fields method RequireStorageDeepItemInfoById. - Context []*RequireStorageDeepItemInfoByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` + // RequireStorageRecommendedItemsByIdContext provides the context for the required fields method RequireStorageRecommendedItemsById. + Context []*RequireStorageRecommendedItemsByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageDeepItemInfoByIdRequest) Reset() { - *x = RequireStorageDeepItemInfoByIdRequest{} - mi := &file_product_proto_msgTypes[323] +func (x *RequireStorageRecommendedItemsByIdRequest) Reset() { + *x = RequireStorageRecommendedItemsByIdRequest{} + mi := &file_product_proto_msgTypes[348] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageDeepItemInfoByIdRequest) String() string { +func (x *RequireStorageRecommendedItemsByIdRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageDeepItemInfoByIdRequest) ProtoMessage() {} +func (*RequireStorageRecommendedItemsByIdRequest) ProtoMessage() {} -func (x *RequireStorageDeepItemInfoByIdRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[323] +func (x *RequireStorageRecommendedItemsByIdRequest) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[348] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15022,41 +16170,41 @@ func (x *RequireStorageDeepItemInfoByIdRequest) ProtoReflect() protoreflect.Mess return mi.MessageOf(x) } -// Deprecated: Use RequireStorageDeepItemInfoByIdRequest.ProtoReflect.Descriptor instead. -func (*RequireStorageDeepItemInfoByIdRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{323} +// Deprecated: Use RequireStorageRecommendedItemsByIdRequest.ProtoReflect.Descriptor instead. +func (*RequireStorageRecommendedItemsByIdRequest) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{348} } -func (x *RequireStorageDeepItemInfoByIdRequest) GetContext() []*RequireStorageDeepItemInfoByIdContext { +func (x *RequireStorageRecommendedItemsByIdRequest) GetContext() []*RequireStorageRecommendedItemsByIdContext { if x != nil { return x.Context } return nil } -type RequireStorageDeepItemInfoByIdContext struct { - state protoimpl.MessageState `protogen:"open.v1"` - Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` - Fields *RequireStorageDeepItemInfoByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` +type RequireStorageRecommendedItemsByIdContext struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Fields *RequireStorageRecommendedItemsByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageDeepItemInfoByIdContext) Reset() { - *x = RequireStorageDeepItemInfoByIdContext{} - mi := &file_product_proto_msgTypes[324] +func (x *RequireStorageRecommendedItemsByIdContext) Reset() { + *x = RequireStorageRecommendedItemsByIdContext{} + mi := &file_product_proto_msgTypes[349] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageDeepItemInfoByIdContext) String() string { +func (x *RequireStorageRecommendedItemsByIdContext) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageDeepItemInfoByIdContext) ProtoMessage() {} +func (*RequireStorageRecommendedItemsByIdContext) ProtoMessage() {} -func (x *RequireStorageDeepItemInfoByIdContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[324] +func (x *RequireStorageRecommendedItemsByIdContext) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[349] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15067,48 +16215,48 @@ func (x *RequireStorageDeepItemInfoByIdContext) ProtoReflect() protoreflect.Mess return mi.MessageOf(x) } -// Deprecated: Use RequireStorageDeepItemInfoByIdContext.ProtoReflect.Descriptor instead. -func (*RequireStorageDeepItemInfoByIdContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{324} +// Deprecated: Use RequireStorageRecommendedItemsByIdContext.ProtoReflect.Descriptor instead. +func (*RequireStorageRecommendedItemsByIdContext) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{349} } -func (x *RequireStorageDeepItemInfoByIdContext) GetKey() *LookupStorageByIdRequestKey { +func (x *RequireStorageRecommendedItemsByIdContext) GetKey() *LookupStorageByIdRequestKey { if x != nil { return x.Key } return nil } -func (x *RequireStorageDeepItemInfoByIdContext) GetFields() *RequireStorageDeepItemInfoByIdFields { +func (x *RequireStorageRecommendedItemsByIdContext) GetFields() *RequireStorageRecommendedItemsByIdFields { if x != nil { return x.Fields } return nil } -type RequireStorageDeepItemInfoByIdResponse struct { +type RequireStorageRecommendedItemsByIdResponse struct { state protoimpl.MessageState `protogen:"open.v1"` - // RequireStorageDeepItemInfoByIdResult provides the result for the required fields method RequireStorageDeepItemInfoById. - Result []*RequireStorageDeepItemInfoByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` + // RequireStorageRecommendedItemsByIdResult provides the result for the required fields method RequireStorageRecommendedItemsById. + Result []*RequireStorageRecommendedItemsByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageDeepItemInfoByIdResponse) Reset() { - *x = RequireStorageDeepItemInfoByIdResponse{} - mi := &file_product_proto_msgTypes[325] +func (x *RequireStorageRecommendedItemsByIdResponse) Reset() { + *x = RequireStorageRecommendedItemsByIdResponse{} + mi := &file_product_proto_msgTypes[350] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageDeepItemInfoByIdResponse) String() string { +func (x *RequireStorageRecommendedItemsByIdResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageDeepItemInfoByIdResponse) ProtoMessage() {} +func (*RequireStorageRecommendedItemsByIdResponse) ProtoMessage() {} -func (x *RequireStorageDeepItemInfoByIdResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[325] +func (x *RequireStorageRecommendedItemsByIdResponse) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[350] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15119,40 +16267,40 @@ func (x *RequireStorageDeepItemInfoByIdResponse) ProtoReflect() protoreflect.Mes return mi.MessageOf(x) } -// Deprecated: Use RequireStorageDeepItemInfoByIdResponse.ProtoReflect.Descriptor instead. -func (*RequireStorageDeepItemInfoByIdResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{325} +// Deprecated: Use RequireStorageRecommendedItemsByIdResponse.ProtoReflect.Descriptor instead. +func (*RequireStorageRecommendedItemsByIdResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{350} } -func (x *RequireStorageDeepItemInfoByIdResponse) GetResult() []*RequireStorageDeepItemInfoByIdResult { +func (x *RequireStorageRecommendedItemsByIdResponse) GetResult() []*RequireStorageRecommendedItemsByIdResult { if x != nil { return x.Result } return nil } -type RequireStorageDeepItemInfoByIdResult struct { - state protoimpl.MessageState `protogen:"open.v1"` - DeepItemInfo string `protobuf:"bytes,1,opt,name=deep_item_info,json=deepItemInfo,proto3" json:"deep_item_info,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type RequireStorageRecommendedItemsByIdResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + RecommendedItems []*StorageItem `protobuf:"bytes,1,rep,name=recommended_items,json=recommendedItems,proto3" json:"recommended_items,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *RequireStorageDeepItemInfoByIdResult) Reset() { - *x = RequireStorageDeepItemInfoByIdResult{} - mi := &file_product_proto_msgTypes[326] +func (x *RequireStorageRecommendedItemsByIdResult) Reset() { + *x = RequireStorageRecommendedItemsByIdResult{} + mi := &file_product_proto_msgTypes[351] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageDeepItemInfoByIdResult) String() string { +func (x *RequireStorageRecommendedItemsByIdResult) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageDeepItemInfoByIdResult) ProtoMessage() {} +func (*RequireStorageRecommendedItemsByIdResult) ProtoMessage() {} -func (x *RequireStorageDeepItemInfoByIdResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[326] +func (x *RequireStorageRecommendedItemsByIdResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[351] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15163,40 +16311,40 @@ func (x *RequireStorageDeepItemInfoByIdResult) ProtoReflect() protoreflect.Messa return mi.MessageOf(x) } -// Deprecated: Use RequireStorageDeepItemInfoByIdResult.ProtoReflect.Descriptor instead. -func (*RequireStorageDeepItemInfoByIdResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{326} +// Deprecated: Use RequireStorageRecommendedItemsByIdResult.ProtoReflect.Descriptor instead. +func (*RequireStorageRecommendedItemsByIdResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{351} } -func (x *RequireStorageDeepItemInfoByIdResult) GetDeepItemInfo() string { +func (x *RequireStorageRecommendedItemsByIdResult) GetRecommendedItems() []*StorageItem { if x != nil { - return x.DeepItemInfo + return x.RecommendedItems } - return "" + return nil } -type RequireStorageDeepItemInfoByIdFields struct { - state protoimpl.MessageState `protogen:"open.v1"` - PrimaryItem *RequireStorageDeepItemInfoByIdFields_StorageItem `protobuf:"bytes,1,opt,name=primary_item,json=primaryItem,proto3" json:"primary_item,omitempty"` +type RequireStorageRecommendedItemsByIdFields 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 *RequireStorageDeepItemInfoByIdFields) Reset() { - *x = RequireStorageDeepItemInfoByIdFields{} - mi := &file_product_proto_msgTypes[327] +func (x *RequireStorageRecommendedItemsByIdFields) Reset() { + *x = RequireStorageRecommendedItemsByIdFields{} + mi := &file_product_proto_msgTypes[352] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageDeepItemInfoByIdFields) String() string { +func (x *RequireStorageRecommendedItemsByIdFields) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageDeepItemInfoByIdFields) ProtoMessage() {} +func (*RequireStorageRecommendedItemsByIdFields) ProtoMessage() {} -func (x *RequireStorageDeepItemInfoByIdFields) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[327] +func (x *RequireStorageRecommendedItemsByIdFields) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[352] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15207,41 +16355,41 @@ func (x *RequireStorageDeepItemInfoByIdFields) ProtoReflect() protoreflect.Messa return mi.MessageOf(x) } -// Deprecated: Use RequireStorageDeepItemInfoByIdFields.ProtoReflect.Descriptor instead. -func (*RequireStorageDeepItemInfoByIdFields) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{327} +// Deprecated: Use RequireStorageRecommendedItemsByIdFields.ProtoReflect.Descriptor instead. +func (*RequireStorageRecommendedItemsByIdFields) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{352} } -func (x *RequireStorageDeepItemInfoByIdFields) GetPrimaryItem() *RequireStorageDeepItemInfoByIdFields_StorageItem { +func (x *RequireStorageRecommendedItemsByIdFields) GetTags() []string { if x != nil { - return x.PrimaryItem + return x.Tags } return nil } -type RequireStorageRecommendedItemByIdRequest struct { +type RequireStorageLatestOperationByIdRequest struct { state protoimpl.MessageState `protogen:"open.v1"` - // RequireStorageRecommendedItemByIdContext provides the context for the required fields method RequireStorageRecommendedItemById. - Context []*RequireStorageRecommendedItemByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` + // RequireStorageLatestOperationByIdContext provides the context for the required fields method RequireStorageLatestOperationById. + Context []*RequireStorageLatestOperationByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageRecommendedItemByIdRequest) Reset() { - *x = RequireStorageRecommendedItemByIdRequest{} - mi := &file_product_proto_msgTypes[328] +func (x *RequireStorageLatestOperationByIdRequest) Reset() { + *x = RequireStorageLatestOperationByIdRequest{} + mi := &file_product_proto_msgTypes[353] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageRecommendedItemByIdRequest) String() string { +func (x *RequireStorageLatestOperationByIdRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageRecommendedItemByIdRequest) ProtoMessage() {} +func (*RequireStorageLatestOperationByIdRequest) ProtoMessage() {} -func (x *RequireStorageRecommendedItemByIdRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[328] +func (x *RequireStorageLatestOperationByIdRequest) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[353] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15252,41 +16400,41 @@ func (x *RequireStorageRecommendedItemByIdRequest) ProtoReflect() protoreflect.M return mi.MessageOf(x) } -// Deprecated: Use RequireStorageRecommendedItemByIdRequest.ProtoReflect.Descriptor instead. -func (*RequireStorageRecommendedItemByIdRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{328} +// Deprecated: Use RequireStorageLatestOperationByIdRequest.ProtoReflect.Descriptor instead. +func (*RequireStorageLatestOperationByIdRequest) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{353} } -func (x *RequireStorageRecommendedItemByIdRequest) GetContext() []*RequireStorageRecommendedItemByIdContext { +func (x *RequireStorageLatestOperationByIdRequest) GetContext() []*RequireStorageLatestOperationByIdContext { if x != nil { return x.Context } return nil } -type RequireStorageRecommendedItemByIdContext struct { +type RequireStorageLatestOperationByIdContext struct { state protoimpl.MessageState `protogen:"open.v1"` Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` - Fields *RequireStorageRecommendedItemByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` + Fields *RequireStorageLatestOperationByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageRecommendedItemByIdContext) Reset() { - *x = RequireStorageRecommendedItemByIdContext{} - mi := &file_product_proto_msgTypes[329] +func (x *RequireStorageLatestOperationByIdContext) Reset() { + *x = RequireStorageLatestOperationByIdContext{} + mi := &file_product_proto_msgTypes[354] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageRecommendedItemByIdContext) String() string { +func (x *RequireStorageLatestOperationByIdContext) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageRecommendedItemByIdContext) ProtoMessage() {} +func (*RequireStorageLatestOperationByIdContext) ProtoMessage() {} -func (x *RequireStorageRecommendedItemByIdContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[329] +func (x *RequireStorageLatestOperationByIdContext) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[354] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15297,48 +16445,48 @@ func (x *RequireStorageRecommendedItemByIdContext) ProtoReflect() protoreflect.M return mi.MessageOf(x) } -// Deprecated: Use RequireStorageRecommendedItemByIdContext.ProtoReflect.Descriptor instead. -func (*RequireStorageRecommendedItemByIdContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{329} +// Deprecated: Use RequireStorageLatestOperationByIdContext.ProtoReflect.Descriptor instead. +func (*RequireStorageLatestOperationByIdContext) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{354} } -func (x *RequireStorageRecommendedItemByIdContext) GetKey() *LookupStorageByIdRequestKey { +func (x *RequireStorageLatestOperationByIdContext) GetKey() *LookupStorageByIdRequestKey { if x != nil { return x.Key } return nil } -func (x *RequireStorageRecommendedItemByIdContext) GetFields() *RequireStorageRecommendedItemByIdFields { +func (x *RequireStorageLatestOperationByIdContext) GetFields() *RequireStorageLatestOperationByIdFields { if x != nil { return x.Fields } return nil } -type RequireStorageRecommendedItemByIdResponse struct { +type RequireStorageLatestOperationByIdResponse struct { state protoimpl.MessageState `protogen:"open.v1"` - // RequireStorageRecommendedItemByIdResult provides the result for the required fields method RequireStorageRecommendedItemById. - Result []*RequireStorageRecommendedItemByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` + // RequireStorageLatestOperationByIdResult provides the result for the required fields method RequireStorageLatestOperationById. + Result []*RequireStorageLatestOperationByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageRecommendedItemByIdResponse) Reset() { - *x = RequireStorageRecommendedItemByIdResponse{} - mi := &file_product_proto_msgTypes[330] +func (x *RequireStorageLatestOperationByIdResponse) Reset() { + *x = RequireStorageLatestOperationByIdResponse{} + mi := &file_product_proto_msgTypes[355] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageRecommendedItemByIdResponse) String() string { +func (x *RequireStorageLatestOperationByIdResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageRecommendedItemByIdResponse) ProtoMessage() {} +func (*RequireStorageLatestOperationByIdResponse) ProtoMessage() {} -func (x *RequireStorageRecommendedItemByIdResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[330] +func (x *RequireStorageLatestOperationByIdResponse) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[355] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15349,40 +16497,40 @@ func (x *RequireStorageRecommendedItemByIdResponse) ProtoReflect() protoreflect. return mi.MessageOf(x) } -// Deprecated: Use RequireStorageRecommendedItemByIdResponse.ProtoReflect.Descriptor instead. -func (*RequireStorageRecommendedItemByIdResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{330} +// Deprecated: Use RequireStorageLatestOperationByIdResponse.ProtoReflect.Descriptor instead. +func (*RequireStorageLatestOperationByIdResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{355} } -func (x *RequireStorageRecommendedItemByIdResponse) GetResult() []*RequireStorageRecommendedItemByIdResult { +func (x *RequireStorageLatestOperationByIdResponse) GetResult() []*RequireStorageLatestOperationByIdResult { if x != nil { return x.Result } return nil } -type RequireStorageRecommendedItemByIdResult struct { - state protoimpl.MessageState `protogen:"open.v1"` - RecommendedItem *StorageItem `protobuf:"bytes,1,opt,name=recommended_item,json=recommendedItem,proto3" json:"recommended_item,omitempty"` +type RequireStorageLatestOperationByIdResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + LatestOperation *StorageOperationResult `protobuf:"bytes,1,opt,name=latest_operation,json=latestOperation,proto3" json:"latest_operation,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageRecommendedItemByIdResult) Reset() { - *x = RequireStorageRecommendedItemByIdResult{} - mi := &file_product_proto_msgTypes[331] +func (x *RequireStorageLatestOperationByIdResult) Reset() { + *x = RequireStorageLatestOperationByIdResult{} + mi := &file_product_proto_msgTypes[356] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageRecommendedItemByIdResult) String() string { +func (x *RequireStorageLatestOperationByIdResult) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageRecommendedItemByIdResult) ProtoMessage() {} +func (*RequireStorageLatestOperationByIdResult) ProtoMessage() {} -func (x *RequireStorageRecommendedItemByIdResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[331] +func (x *RequireStorageLatestOperationByIdResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[356] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15393,40 +16541,40 @@ func (x *RequireStorageRecommendedItemByIdResult) ProtoReflect() protoreflect.Me return mi.MessageOf(x) } -// Deprecated: Use RequireStorageRecommendedItemByIdResult.ProtoReflect.Descriptor instead. -func (*RequireStorageRecommendedItemByIdResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{331} +// Deprecated: Use RequireStorageLatestOperationByIdResult.ProtoReflect.Descriptor instead. +func (*RequireStorageLatestOperationByIdResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{356} } -func (x *RequireStorageRecommendedItemByIdResult) GetRecommendedItem() *StorageItem { +func (x *RequireStorageLatestOperationByIdResult) GetLatestOperation() *StorageOperationResult { if x != nil { - return x.RecommendedItem + return x.LatestOperation } return nil } -type RequireStorageRecommendedItemByIdFields struct { - state protoimpl.MessageState `protogen:"open.v1"` - Metadata *RequireStorageRecommendedItemByIdFields_StorageMetadata `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"` +type RequireStorageLatestOperationByIdFields 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"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageRecommendedItemByIdFields) Reset() { - *x = RequireStorageRecommendedItemByIdFields{} - mi := &file_product_proto_msgTypes[332] +func (x *RequireStorageLatestOperationByIdFields) Reset() { + *x = RequireStorageLatestOperationByIdFields{} + mi := &file_product_proto_msgTypes[357] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageRecommendedItemByIdFields) String() string { +func (x *RequireStorageLatestOperationByIdFields) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageRecommendedItemByIdFields) ProtoMessage() {} +func (*RequireStorageLatestOperationByIdFields) ProtoMessage() {} -func (x *RequireStorageRecommendedItemByIdFields) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[332] +func (x *RequireStorageLatestOperationByIdFields) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[357] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15437,41 +16585,41 @@ func (x *RequireStorageRecommendedItemByIdFields) ProtoReflect() protoreflect.Me return mi.MessageOf(x) } -// Deprecated: Use RequireStorageRecommendedItemByIdFields.ProtoReflect.Descriptor instead. -func (*RequireStorageRecommendedItemByIdFields) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{332} +// Deprecated: Use RequireStorageLatestOperationByIdFields.ProtoReflect.Descriptor instead. +func (*RequireStorageLatestOperationByIdFields) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{357} } -func (x *RequireStorageRecommendedItemByIdFields) GetMetadata() *RequireStorageRecommendedItemByIdFields_StorageMetadata { +func (x *RequireStorageLatestOperationByIdFields) GetStorageKind() CategoryKind { if x != nil { - return x.Metadata + return x.StorageKind } - return nil + return CategoryKind_CATEGORY_KIND_UNSPECIFIED } -type RequireStorageRecommendedItemsByIdRequest struct { +type RequireStorageOptionalLatestOperationByIdRequest struct { state protoimpl.MessageState `protogen:"open.v1"` - // RequireStorageRecommendedItemsByIdContext provides the context for the required fields method RequireStorageRecommendedItemsById. - Context []*RequireStorageRecommendedItemsByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` + // RequireStorageOptionalLatestOperationByIdContext provides the context for the required fields method RequireStorageOptionalLatestOperationById. + Context []*RequireStorageOptionalLatestOperationByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageRecommendedItemsByIdRequest) Reset() { - *x = RequireStorageRecommendedItemsByIdRequest{} - mi := &file_product_proto_msgTypes[333] +func (x *RequireStorageOptionalLatestOperationByIdRequest) Reset() { + *x = RequireStorageOptionalLatestOperationByIdRequest{} + mi := &file_product_proto_msgTypes[358] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageRecommendedItemsByIdRequest) String() string { +func (x *RequireStorageOptionalLatestOperationByIdRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageRecommendedItemsByIdRequest) ProtoMessage() {} +func (*RequireStorageOptionalLatestOperationByIdRequest) ProtoMessage() {} -func (x *RequireStorageRecommendedItemsByIdRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[333] +func (x *RequireStorageOptionalLatestOperationByIdRequest) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[358] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15482,41 +16630,41 @@ func (x *RequireStorageRecommendedItemsByIdRequest) ProtoReflect() protoreflect. return mi.MessageOf(x) } -// Deprecated: Use RequireStorageRecommendedItemsByIdRequest.ProtoReflect.Descriptor instead. -func (*RequireStorageRecommendedItemsByIdRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{333} +// Deprecated: Use RequireStorageOptionalLatestOperationByIdRequest.ProtoReflect.Descriptor instead. +func (*RequireStorageOptionalLatestOperationByIdRequest) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{358} } -func (x *RequireStorageRecommendedItemsByIdRequest) GetContext() []*RequireStorageRecommendedItemsByIdContext { +func (x *RequireStorageOptionalLatestOperationByIdRequest) GetContext() []*RequireStorageOptionalLatestOperationByIdContext { if x != nil { return x.Context } return nil } -type RequireStorageRecommendedItemsByIdContext struct { - state protoimpl.MessageState `protogen:"open.v1"` - Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` - Fields *RequireStorageRecommendedItemsByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` +type RequireStorageOptionalLatestOperationByIdContext struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Fields *RequireStorageOptionalLatestOperationByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageRecommendedItemsByIdContext) Reset() { - *x = RequireStorageRecommendedItemsByIdContext{} - mi := &file_product_proto_msgTypes[334] +func (x *RequireStorageOptionalLatestOperationByIdContext) Reset() { + *x = RequireStorageOptionalLatestOperationByIdContext{} + mi := &file_product_proto_msgTypes[359] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageRecommendedItemsByIdContext) String() string { +func (x *RequireStorageOptionalLatestOperationByIdContext) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageRecommendedItemsByIdContext) ProtoMessage() {} +func (*RequireStorageOptionalLatestOperationByIdContext) ProtoMessage() {} -func (x *RequireStorageRecommendedItemsByIdContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[334] +func (x *RequireStorageOptionalLatestOperationByIdContext) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[359] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15527,48 +16675,48 @@ func (x *RequireStorageRecommendedItemsByIdContext) ProtoReflect() protoreflect. return mi.MessageOf(x) } -// Deprecated: Use RequireStorageRecommendedItemsByIdContext.ProtoReflect.Descriptor instead. -func (*RequireStorageRecommendedItemsByIdContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{334} +// Deprecated: Use RequireStorageOptionalLatestOperationByIdContext.ProtoReflect.Descriptor instead. +func (*RequireStorageOptionalLatestOperationByIdContext) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{359} } -func (x *RequireStorageRecommendedItemsByIdContext) GetKey() *LookupStorageByIdRequestKey { +func (x *RequireStorageOptionalLatestOperationByIdContext) GetKey() *LookupStorageByIdRequestKey { if x != nil { return x.Key } return nil } -func (x *RequireStorageRecommendedItemsByIdContext) GetFields() *RequireStorageRecommendedItemsByIdFields { +func (x *RequireStorageOptionalLatestOperationByIdContext) GetFields() *RequireStorageOptionalLatestOperationByIdFields { if x != nil { return x.Fields } return nil } -type RequireStorageRecommendedItemsByIdResponse struct { +type RequireStorageOptionalLatestOperationByIdResponse struct { state protoimpl.MessageState `protogen:"open.v1"` - // RequireStorageRecommendedItemsByIdResult provides the result for the required fields method RequireStorageRecommendedItemsById. - Result []*RequireStorageRecommendedItemsByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` + // RequireStorageOptionalLatestOperationByIdResult provides the result for the required fields method RequireStorageOptionalLatestOperationById. + Result []*RequireStorageOptionalLatestOperationByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageRecommendedItemsByIdResponse) Reset() { - *x = RequireStorageRecommendedItemsByIdResponse{} - mi := &file_product_proto_msgTypes[335] +func (x *RequireStorageOptionalLatestOperationByIdResponse) Reset() { + *x = RequireStorageOptionalLatestOperationByIdResponse{} + mi := &file_product_proto_msgTypes[360] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageRecommendedItemsByIdResponse) String() string { +func (x *RequireStorageOptionalLatestOperationByIdResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageRecommendedItemsByIdResponse) ProtoMessage() {} +func (*RequireStorageOptionalLatestOperationByIdResponse) ProtoMessage() {} -func (x *RequireStorageRecommendedItemsByIdResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[335] +func (x *RequireStorageOptionalLatestOperationByIdResponse) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[360] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15579,40 +16727,40 @@ func (x *RequireStorageRecommendedItemsByIdResponse) ProtoReflect() protoreflect return mi.MessageOf(x) } -// Deprecated: Use RequireStorageRecommendedItemsByIdResponse.ProtoReflect.Descriptor instead. -func (*RequireStorageRecommendedItemsByIdResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{335} +// Deprecated: Use RequireStorageOptionalLatestOperationByIdResponse.ProtoReflect.Descriptor instead. +func (*RequireStorageOptionalLatestOperationByIdResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{360} } -func (x *RequireStorageRecommendedItemsByIdResponse) GetResult() []*RequireStorageRecommendedItemsByIdResult { +func (x *RequireStorageOptionalLatestOperationByIdResponse) GetResult() []*RequireStorageOptionalLatestOperationByIdResult { if x != nil { return x.Result } return nil } -type RequireStorageRecommendedItemsByIdResult struct { - state protoimpl.MessageState `protogen:"open.v1"` - RecommendedItems []*StorageItem `protobuf:"bytes,1,rep,name=recommended_items,json=recommendedItems,proto3" json:"recommended_items,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type RequireStorageOptionalLatestOperationByIdResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + OptionalLatestOperation *StorageOperationResult `protobuf:"bytes,1,opt,name=optional_latest_operation,json=optionalLatestOperation,proto3" json:"optional_latest_operation,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *RequireStorageRecommendedItemsByIdResult) Reset() { - *x = RequireStorageRecommendedItemsByIdResult{} - mi := &file_product_proto_msgTypes[336] +func (x *RequireStorageOptionalLatestOperationByIdResult) Reset() { + *x = RequireStorageOptionalLatestOperationByIdResult{} + mi := &file_product_proto_msgTypes[361] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageRecommendedItemsByIdResult) String() string { +func (x *RequireStorageOptionalLatestOperationByIdResult) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageRecommendedItemsByIdResult) ProtoMessage() {} +func (*RequireStorageOptionalLatestOperationByIdResult) ProtoMessage() {} -func (x *RequireStorageRecommendedItemsByIdResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[336] +func (x *RequireStorageOptionalLatestOperationByIdResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[361] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15623,40 +16771,40 @@ func (x *RequireStorageRecommendedItemsByIdResult) ProtoReflect() protoreflect.M return mi.MessageOf(x) } -// Deprecated: Use RequireStorageRecommendedItemsByIdResult.ProtoReflect.Descriptor instead. -func (*RequireStorageRecommendedItemsByIdResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{336} +// Deprecated: Use RequireStorageOptionalLatestOperationByIdResult.ProtoReflect.Descriptor instead. +func (*RequireStorageOptionalLatestOperationByIdResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{361} } -func (x *RequireStorageRecommendedItemsByIdResult) GetRecommendedItems() []*StorageItem { +func (x *RequireStorageOptionalLatestOperationByIdResult) GetOptionalLatestOperation() *StorageOperationResult { if x != nil { - return x.RecommendedItems + return x.OptionalLatestOperation } return nil } -type RequireStorageRecommendedItemsByIdFields struct { +type RequireStorageOptionalLatestOperationByIdFields 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 *RequireStorageRecommendedItemsByIdFields) Reset() { - *x = RequireStorageRecommendedItemsByIdFields{} - mi := &file_product_proto_msgTypes[337] +func (x *RequireStorageOptionalLatestOperationByIdFields) Reset() { + *x = RequireStorageOptionalLatestOperationByIdFields{} + mi := &file_product_proto_msgTypes[362] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageRecommendedItemsByIdFields) String() string { +func (x *RequireStorageOptionalLatestOperationByIdFields) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageRecommendedItemsByIdFields) ProtoMessage() {} +func (*RequireStorageOptionalLatestOperationByIdFields) ProtoMessage() {} -func (x *RequireStorageRecommendedItemsByIdFields) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[337] +func (x *RequireStorageOptionalLatestOperationByIdFields) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[362] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15667,41 +16815,41 @@ func (x *RequireStorageRecommendedItemsByIdFields) ProtoReflect() protoreflect.M return mi.MessageOf(x) } -// Deprecated: Use RequireStorageRecommendedItemsByIdFields.ProtoReflect.Descriptor instead. -func (*RequireStorageRecommendedItemsByIdFields) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{337} +// Deprecated: Use RequireStorageOptionalLatestOperationByIdFields.ProtoReflect.Descriptor instead. +func (*RequireStorageOptionalLatestOperationByIdFields) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{362} } -func (x *RequireStorageRecommendedItemsByIdFields) GetTags() []string { +func (x *RequireStorageOptionalLatestOperationByIdFields) GetOptionalTags() *ListOfString { if x != nil { - return x.Tags + return x.OptionalTags } return nil } -type RequireStorageLatestOperationByIdRequest struct { +type RequireStorageOptionalRecommendedItemsByIdRequest struct { state protoimpl.MessageState `protogen:"open.v1"` - // RequireStorageLatestOperationByIdContext provides the context for the required fields method RequireStorageLatestOperationById. - Context []*RequireStorageLatestOperationByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` + // RequireStorageOptionalRecommendedItemsByIdContext provides the context for the required fields method RequireStorageOptionalRecommendedItemsById. + Context []*RequireStorageOptionalRecommendedItemsByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageLatestOperationByIdRequest) Reset() { - *x = RequireStorageLatestOperationByIdRequest{} - mi := &file_product_proto_msgTypes[338] +func (x *RequireStorageOptionalRecommendedItemsByIdRequest) Reset() { + *x = RequireStorageOptionalRecommendedItemsByIdRequest{} + mi := &file_product_proto_msgTypes[363] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageLatestOperationByIdRequest) String() string { +func (x *RequireStorageOptionalRecommendedItemsByIdRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageLatestOperationByIdRequest) ProtoMessage() {} +func (*RequireStorageOptionalRecommendedItemsByIdRequest) ProtoMessage() {} -func (x *RequireStorageLatestOperationByIdRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[338] +func (x *RequireStorageOptionalRecommendedItemsByIdRequest) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[363] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15712,41 +16860,41 @@ func (x *RequireStorageLatestOperationByIdRequest) ProtoReflect() protoreflect.M return mi.MessageOf(x) } -// Deprecated: Use RequireStorageLatestOperationByIdRequest.ProtoReflect.Descriptor instead. -func (*RequireStorageLatestOperationByIdRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{338} +// Deprecated: Use RequireStorageOptionalRecommendedItemsByIdRequest.ProtoReflect.Descriptor instead. +func (*RequireStorageOptionalRecommendedItemsByIdRequest) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{363} } -func (x *RequireStorageLatestOperationByIdRequest) GetContext() []*RequireStorageLatestOperationByIdContext { +func (x *RequireStorageOptionalRecommendedItemsByIdRequest) GetContext() []*RequireStorageOptionalRecommendedItemsByIdContext { if x != nil { return x.Context } return nil } -type RequireStorageLatestOperationByIdContext struct { - state protoimpl.MessageState `protogen:"open.v1"` - Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` - Fields *RequireStorageLatestOperationByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` +type RequireStorageOptionalRecommendedItemsByIdContext struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Fields *RequireStorageOptionalRecommendedItemsByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageLatestOperationByIdContext) Reset() { - *x = RequireStorageLatestOperationByIdContext{} - mi := &file_product_proto_msgTypes[339] +func (x *RequireStorageOptionalRecommendedItemsByIdContext) Reset() { + *x = RequireStorageOptionalRecommendedItemsByIdContext{} + mi := &file_product_proto_msgTypes[364] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageLatestOperationByIdContext) String() string { +func (x *RequireStorageOptionalRecommendedItemsByIdContext) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageLatestOperationByIdContext) ProtoMessage() {} +func (*RequireStorageOptionalRecommendedItemsByIdContext) ProtoMessage() {} -func (x *RequireStorageLatestOperationByIdContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[339] +func (x *RequireStorageOptionalRecommendedItemsByIdContext) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[364] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15757,48 +16905,48 @@ func (x *RequireStorageLatestOperationByIdContext) ProtoReflect() protoreflect.M return mi.MessageOf(x) } -// Deprecated: Use RequireStorageLatestOperationByIdContext.ProtoReflect.Descriptor instead. -func (*RequireStorageLatestOperationByIdContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{339} +// Deprecated: Use RequireStorageOptionalRecommendedItemsByIdContext.ProtoReflect.Descriptor instead. +func (*RequireStorageOptionalRecommendedItemsByIdContext) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{364} } -func (x *RequireStorageLatestOperationByIdContext) GetKey() *LookupStorageByIdRequestKey { +func (x *RequireStorageOptionalRecommendedItemsByIdContext) GetKey() *LookupStorageByIdRequestKey { if x != nil { return x.Key } return nil } -func (x *RequireStorageLatestOperationByIdContext) GetFields() *RequireStorageLatestOperationByIdFields { +func (x *RequireStorageOptionalRecommendedItemsByIdContext) GetFields() *RequireStorageOptionalRecommendedItemsByIdFields { if x != nil { return x.Fields } return nil } -type RequireStorageLatestOperationByIdResponse struct { +type RequireStorageOptionalRecommendedItemsByIdResponse struct { state protoimpl.MessageState `protogen:"open.v1"` - // RequireStorageLatestOperationByIdResult provides the result for the required fields method RequireStorageLatestOperationById. - Result []*RequireStorageLatestOperationByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` + // RequireStorageOptionalRecommendedItemsByIdResult provides the result for the required fields method RequireStorageOptionalRecommendedItemsById. + Result []*RequireStorageOptionalRecommendedItemsByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageLatestOperationByIdResponse) Reset() { - *x = RequireStorageLatestOperationByIdResponse{} - mi := &file_product_proto_msgTypes[340] +func (x *RequireStorageOptionalRecommendedItemsByIdResponse) Reset() { + *x = RequireStorageOptionalRecommendedItemsByIdResponse{} + mi := &file_product_proto_msgTypes[365] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageLatestOperationByIdResponse) String() string { +func (x *RequireStorageOptionalRecommendedItemsByIdResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageLatestOperationByIdResponse) ProtoMessage() {} +func (*RequireStorageOptionalRecommendedItemsByIdResponse) ProtoMessage() {} -func (x *RequireStorageLatestOperationByIdResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[340] +func (x *RequireStorageOptionalRecommendedItemsByIdResponse) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[365] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15809,40 +16957,40 @@ func (x *RequireStorageLatestOperationByIdResponse) ProtoReflect() protoreflect. return mi.MessageOf(x) } -// Deprecated: Use RequireStorageLatestOperationByIdResponse.ProtoReflect.Descriptor instead. -func (*RequireStorageLatestOperationByIdResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{340} +// Deprecated: Use RequireStorageOptionalRecommendedItemsByIdResponse.ProtoReflect.Descriptor instead. +func (*RequireStorageOptionalRecommendedItemsByIdResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{365} } -func (x *RequireStorageLatestOperationByIdResponse) GetResult() []*RequireStorageLatestOperationByIdResult { +func (x *RequireStorageOptionalRecommendedItemsByIdResponse) GetResult() []*RequireStorageOptionalRecommendedItemsByIdResult { if x != nil { return x.Result } return nil } -type RequireStorageLatestOperationByIdResult struct { - state protoimpl.MessageState `protogen:"open.v1"` - LatestOperation *StorageOperationResult `protobuf:"bytes,1,opt,name=latest_operation,json=latestOperation,proto3" json:"latest_operation,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type RequireStorageOptionalRecommendedItemsByIdResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + OptionalRecommendedItems *ListOfStorageItem `protobuf:"bytes,1,opt,name=optional_recommended_items,json=optionalRecommendedItems,proto3" json:"optional_recommended_items,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *RequireStorageLatestOperationByIdResult) Reset() { - *x = RequireStorageLatestOperationByIdResult{} - mi := &file_product_proto_msgTypes[341] +func (x *RequireStorageOptionalRecommendedItemsByIdResult) Reset() { + *x = RequireStorageOptionalRecommendedItemsByIdResult{} + mi := &file_product_proto_msgTypes[366] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageLatestOperationByIdResult) String() string { +func (x *RequireStorageOptionalRecommendedItemsByIdResult) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageLatestOperationByIdResult) ProtoMessage() {} +func (*RequireStorageOptionalRecommendedItemsByIdResult) ProtoMessage() {} -func (x *RequireStorageLatestOperationByIdResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[341] +func (x *RequireStorageOptionalRecommendedItemsByIdResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[366] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15853,40 +17001,40 @@ func (x *RequireStorageLatestOperationByIdResult) ProtoReflect() protoreflect.Me return mi.MessageOf(x) } -// Deprecated: Use RequireStorageLatestOperationByIdResult.ProtoReflect.Descriptor instead. -func (*RequireStorageLatestOperationByIdResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{341} +// Deprecated: Use RequireStorageOptionalRecommendedItemsByIdResult.ProtoReflect.Descriptor instead. +func (*RequireStorageOptionalRecommendedItemsByIdResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{366} } -func (x *RequireStorageLatestOperationByIdResult) GetLatestOperation() *StorageOperationResult { +func (x *RequireStorageOptionalRecommendedItemsByIdResult) GetOptionalRecommendedItems() *ListOfStorageItem { if x != nil { - return x.LatestOperation + return x.OptionalRecommendedItems } return nil } -type RequireStorageLatestOperationByIdFields struct { +type RequireStorageOptionalRecommendedItemsByIdFields 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"` + Tags []string `protobuf:"bytes,1,rep,name=tags,proto3" json:"tags,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageLatestOperationByIdFields) Reset() { - *x = RequireStorageLatestOperationByIdFields{} - mi := &file_product_proto_msgTypes[342] +func (x *RequireStorageOptionalRecommendedItemsByIdFields) Reset() { + *x = RequireStorageOptionalRecommendedItemsByIdFields{} + mi := &file_product_proto_msgTypes[367] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageLatestOperationByIdFields) String() string { +func (x *RequireStorageOptionalRecommendedItemsByIdFields) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageLatestOperationByIdFields) ProtoMessage() {} +func (*RequireStorageOptionalRecommendedItemsByIdFields) ProtoMessage() {} -func (x *RequireStorageLatestOperationByIdFields) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[342] +func (x *RequireStorageOptionalRecommendedItemsByIdFields) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[367] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15897,41 +17045,41 @@ func (x *RequireStorageLatestOperationByIdFields) ProtoReflect() protoreflect.Me return mi.MessageOf(x) } -// Deprecated: Use RequireStorageLatestOperationByIdFields.ProtoReflect.Descriptor instead. -func (*RequireStorageLatestOperationByIdFields) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{342} +// Deprecated: Use RequireStorageOptionalRecommendedItemsByIdFields.ProtoReflect.Descriptor instead. +func (*RequireStorageOptionalRecommendedItemsByIdFields) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{367} } -func (x *RequireStorageLatestOperationByIdFields) GetStorageKind() CategoryKind { +func (x *RequireStorageOptionalRecommendedItemsByIdFields) GetTags() []string { if x != nil { - return x.StorageKind + return x.Tags } - return CategoryKind_CATEGORY_KIND_UNSPECIFIED + return nil } -type RequireStorageOptionalLatestOperationByIdRequest struct { +type RequireStorageOptionalOperationHistoryByIdRequest struct { state protoimpl.MessageState `protogen:"open.v1"` - // RequireStorageOptionalLatestOperationByIdContext provides the context for the required fields method RequireStorageOptionalLatestOperationById. - Context []*RequireStorageOptionalLatestOperationByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` + // RequireStorageOptionalOperationHistoryByIdContext provides the context for the required fields method RequireStorageOptionalOperationHistoryById. + Context []*RequireStorageOptionalOperationHistoryByIdContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageOptionalLatestOperationByIdRequest) Reset() { - *x = RequireStorageOptionalLatestOperationByIdRequest{} - mi := &file_product_proto_msgTypes[343] +func (x *RequireStorageOptionalOperationHistoryByIdRequest) Reset() { + *x = RequireStorageOptionalOperationHistoryByIdRequest{} + mi := &file_product_proto_msgTypes[368] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageOptionalLatestOperationByIdRequest) String() string { +func (x *RequireStorageOptionalOperationHistoryByIdRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageOptionalLatestOperationByIdRequest) ProtoMessage() {} +func (*RequireStorageOptionalOperationHistoryByIdRequest) ProtoMessage() {} -func (x *RequireStorageOptionalLatestOperationByIdRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[343] +func (x *RequireStorageOptionalOperationHistoryByIdRequest) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[368] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15942,41 +17090,41 @@ func (x *RequireStorageOptionalLatestOperationByIdRequest) ProtoReflect() protor return mi.MessageOf(x) } -// Deprecated: Use RequireStorageOptionalLatestOperationByIdRequest.ProtoReflect.Descriptor instead. -func (*RequireStorageOptionalLatestOperationByIdRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{343} +// Deprecated: Use RequireStorageOptionalOperationHistoryByIdRequest.ProtoReflect.Descriptor instead. +func (*RequireStorageOptionalOperationHistoryByIdRequest) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{368} } -func (x *RequireStorageOptionalLatestOperationByIdRequest) GetContext() []*RequireStorageOptionalLatestOperationByIdContext { +func (x *RequireStorageOptionalOperationHistoryByIdRequest) GetContext() []*RequireStorageOptionalOperationHistoryByIdContext { if x != nil { return x.Context } return nil } -type RequireStorageOptionalLatestOperationByIdContext struct { - state protoimpl.MessageState `protogen:"open.v1"` - Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` - Fields *RequireStorageOptionalLatestOperationByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` +type RequireStorageOptionalOperationHistoryByIdContext struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key *LookupStorageByIdRequestKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Fields *RequireStorageOptionalOperationHistoryByIdFields `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageOptionalLatestOperationByIdContext) Reset() { - *x = RequireStorageOptionalLatestOperationByIdContext{} - mi := &file_product_proto_msgTypes[344] +func (x *RequireStorageOptionalOperationHistoryByIdContext) Reset() { + *x = RequireStorageOptionalOperationHistoryByIdContext{} + mi := &file_product_proto_msgTypes[369] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageOptionalLatestOperationByIdContext) String() string { +func (x *RequireStorageOptionalOperationHistoryByIdContext) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageOptionalLatestOperationByIdContext) ProtoMessage() {} +func (*RequireStorageOptionalOperationHistoryByIdContext) ProtoMessage() {} -func (x *RequireStorageOptionalLatestOperationByIdContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[344] +func (x *RequireStorageOptionalOperationHistoryByIdContext) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[369] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15987,48 +17135,48 @@ func (x *RequireStorageOptionalLatestOperationByIdContext) ProtoReflect() protor return mi.MessageOf(x) } -// Deprecated: Use RequireStorageOptionalLatestOperationByIdContext.ProtoReflect.Descriptor instead. -func (*RequireStorageOptionalLatestOperationByIdContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{344} +// Deprecated: Use RequireStorageOptionalOperationHistoryByIdContext.ProtoReflect.Descriptor instead. +func (*RequireStorageOptionalOperationHistoryByIdContext) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{369} } -func (x *RequireStorageOptionalLatestOperationByIdContext) GetKey() *LookupStorageByIdRequestKey { +func (x *RequireStorageOptionalOperationHistoryByIdContext) GetKey() *LookupStorageByIdRequestKey { if x != nil { return x.Key } return nil } -func (x *RequireStorageOptionalLatestOperationByIdContext) GetFields() *RequireStorageOptionalLatestOperationByIdFields { +func (x *RequireStorageOptionalOperationHistoryByIdContext) GetFields() *RequireStorageOptionalOperationHistoryByIdFields { if x != nil { return x.Fields } return nil } -type RequireStorageOptionalLatestOperationByIdResponse struct { +type RequireStorageOptionalOperationHistoryByIdResponse struct { state protoimpl.MessageState `protogen:"open.v1"` - // RequireStorageOptionalLatestOperationByIdResult provides the result for the required fields method RequireStorageOptionalLatestOperationById. - Result []*RequireStorageOptionalLatestOperationByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` + // RequireStorageOptionalOperationHistoryByIdResult provides the result for the required fields method RequireStorageOptionalOperationHistoryById. + Result []*RequireStorageOptionalOperationHistoryByIdResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RequireStorageOptionalLatestOperationByIdResponse) Reset() { - *x = RequireStorageOptionalLatestOperationByIdResponse{} - mi := &file_product_proto_msgTypes[345] +func (x *RequireStorageOptionalOperationHistoryByIdResponse) Reset() { + *x = RequireStorageOptionalOperationHistoryByIdResponse{} + mi := &file_product_proto_msgTypes[370] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageOptionalLatestOperationByIdResponse) String() string { +func (x *RequireStorageOptionalOperationHistoryByIdResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageOptionalLatestOperationByIdResponse) ProtoMessage() {} +func (*RequireStorageOptionalOperationHistoryByIdResponse) ProtoMessage() {} -func (x *RequireStorageOptionalLatestOperationByIdResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[345] +func (x *RequireStorageOptionalOperationHistoryByIdResponse) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[370] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16039,40 +17187,40 @@ func (x *RequireStorageOptionalLatestOperationByIdResponse) ProtoReflect() proto return mi.MessageOf(x) } -// Deprecated: Use RequireStorageOptionalLatestOperationByIdResponse.ProtoReflect.Descriptor instead. -func (*RequireStorageOptionalLatestOperationByIdResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{345} +// Deprecated: Use RequireStorageOptionalOperationHistoryByIdResponse.ProtoReflect.Descriptor instead. +func (*RequireStorageOptionalOperationHistoryByIdResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{370} } -func (x *RequireStorageOptionalLatestOperationByIdResponse) GetResult() []*RequireStorageOptionalLatestOperationByIdResult { +func (x *RequireStorageOptionalOperationHistoryByIdResponse) GetResult() []*RequireStorageOptionalOperationHistoryByIdResult { if x != nil { return x.Result } return nil } -type RequireStorageOptionalLatestOperationByIdResult struct { - state protoimpl.MessageState `protogen:"open.v1"` - OptionalLatestOperation *StorageOperationResult `protobuf:"bytes,1,opt,name=optional_latest_operation,json=optionalLatestOperation,proto3" json:"optional_latest_operation,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type RequireStorageOptionalOperationHistoryByIdResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + OptionalOperationHistory *ListOfStorageOperationResult `protobuf:"bytes,1,opt,name=optional_operation_history,json=optionalOperationHistory,proto3" json:"optional_operation_history,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *RequireStorageOptionalLatestOperationByIdResult) Reset() { - *x = RequireStorageOptionalLatestOperationByIdResult{} - mi := &file_product_proto_msgTypes[346] +func (x *RequireStorageOptionalOperationHistoryByIdResult) Reset() { + *x = RequireStorageOptionalOperationHistoryByIdResult{} + mi := &file_product_proto_msgTypes[371] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageOptionalLatestOperationByIdResult) String() string { +func (x *RequireStorageOptionalOperationHistoryByIdResult) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageOptionalLatestOperationByIdResult) ProtoMessage() {} +func (*RequireStorageOptionalOperationHistoryByIdResult) ProtoMessage() {} -func (x *RequireStorageOptionalLatestOperationByIdResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[346] +func (x *RequireStorageOptionalOperationHistoryByIdResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[371] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16083,40 +17231,40 @@ func (x *RequireStorageOptionalLatestOperationByIdResult) ProtoReflect() protore return mi.MessageOf(x) } -// Deprecated: Use RequireStorageOptionalLatestOperationByIdResult.ProtoReflect.Descriptor instead. -func (*RequireStorageOptionalLatestOperationByIdResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{346} +// Deprecated: Use RequireStorageOptionalOperationHistoryByIdResult.ProtoReflect.Descriptor instead. +func (*RequireStorageOptionalOperationHistoryByIdResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{371} } -func (x *RequireStorageOptionalLatestOperationByIdResult) GetOptionalLatestOperation() *StorageOperationResult { +func (x *RequireStorageOptionalOperationHistoryByIdResult) GetOptionalOperationHistory() *ListOfStorageOperationResult { if x != nil { - return x.OptionalLatestOperation + return x.OptionalOperationHistory } return nil } -type RequireStorageOptionalLatestOperationByIdFields struct { +type RequireStorageOptionalOperationHistoryByIdFields struct { state protoimpl.MessageState `protogen:"open.v1"` - OptionalTags *ListOfString `protobuf:"bytes,1,opt,name=optional_tags,json=optionalTags,proto3" json:"optional_tags,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 *RequireStorageOptionalLatestOperationByIdFields) Reset() { - *x = RequireStorageOptionalLatestOperationByIdFields{} - mi := &file_product_proto_msgTypes[347] +func (x *RequireStorageOptionalOperationHistoryByIdFields) Reset() { + *x = RequireStorageOptionalOperationHistoryByIdFields{} + mi := &file_product_proto_msgTypes[372] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RequireStorageOptionalLatestOperationByIdFields) String() string { +func (x *RequireStorageOptionalOperationHistoryByIdFields) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RequireStorageOptionalLatestOperationByIdFields) ProtoMessage() {} +func (*RequireStorageOptionalOperationHistoryByIdFields) ProtoMessage() {} -func (x *RequireStorageOptionalLatestOperationByIdFields) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[347] +func (x *RequireStorageOptionalOperationHistoryByIdFields) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[372] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16127,16 +17275,16 @@ func (x *RequireStorageOptionalLatestOperationByIdFields) ProtoReflect() protore return mi.MessageOf(x) } -// Deprecated: Use RequireStorageOptionalLatestOperationByIdFields.ProtoReflect.Descriptor instead. -func (*RequireStorageOptionalLatestOperationByIdFields) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{347} +// Deprecated: Use RequireStorageOptionalOperationHistoryByIdFields.ProtoReflect.Descriptor instead. +func (*RequireStorageOptionalOperationHistoryByIdFields) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{372} } -func (x *RequireStorageOptionalLatestOperationByIdFields) GetOptionalTags() *ListOfString { +func (x *RequireStorageOptionalOperationHistoryByIdFields) GetStorageKind() CategoryKind { if x != nil { - return x.OptionalTags + return x.StorageKind } - return nil + return CategoryKind_CATEGORY_KIND_UNSPECIFIED } type RequireStorageFilteredTagSummaryByIdRequest struct { @@ -16151,7 +17299,7 @@ type RequireStorageFilteredTagSummaryByIdRequest struct { func (x *RequireStorageFilteredTagSummaryByIdRequest) Reset() { *x = RequireStorageFilteredTagSummaryByIdRequest{} - mi := &file_product_proto_msgTypes[348] + mi := &file_product_proto_msgTypes[373] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16163,7 +17311,7 @@ func (x *RequireStorageFilteredTagSummaryByIdRequest) String() string { func (*RequireStorageFilteredTagSummaryByIdRequest) ProtoMessage() {} func (x *RequireStorageFilteredTagSummaryByIdRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[348] + mi := &file_product_proto_msgTypes[373] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16176,7 +17324,7 @@ func (x *RequireStorageFilteredTagSummaryByIdRequest) ProtoReflect() protoreflec // Deprecated: Use RequireStorageFilteredTagSummaryByIdRequest.ProtoReflect.Descriptor instead. func (*RequireStorageFilteredTagSummaryByIdRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{348} + return file_product_proto_rawDescGZIP(), []int{373} } func (x *RequireStorageFilteredTagSummaryByIdRequest) GetContext() []*RequireStorageFilteredTagSummaryByIdContext { @@ -16203,7 +17351,7 @@ type RequireStorageFilteredTagSummaryByIdContext struct { func (x *RequireStorageFilteredTagSummaryByIdContext) Reset() { *x = RequireStorageFilteredTagSummaryByIdContext{} - mi := &file_product_proto_msgTypes[349] + mi := &file_product_proto_msgTypes[374] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16215,7 +17363,7 @@ func (x *RequireStorageFilteredTagSummaryByIdContext) String() string { func (*RequireStorageFilteredTagSummaryByIdContext) ProtoMessage() {} func (x *RequireStorageFilteredTagSummaryByIdContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[349] + mi := &file_product_proto_msgTypes[374] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16228,7 +17376,7 @@ func (x *RequireStorageFilteredTagSummaryByIdContext) ProtoReflect() protoreflec // Deprecated: Use RequireStorageFilteredTagSummaryByIdContext.ProtoReflect.Descriptor instead. func (*RequireStorageFilteredTagSummaryByIdContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{349} + return file_product_proto_rawDescGZIP(), []int{374} } func (x *RequireStorageFilteredTagSummaryByIdContext) GetKey() *LookupStorageByIdRequestKey { @@ -16254,7 +17402,7 @@ type RequireStorageFilteredTagSummaryByIdArgs struct { func (x *RequireStorageFilteredTagSummaryByIdArgs) Reset() { *x = RequireStorageFilteredTagSummaryByIdArgs{} - mi := &file_product_proto_msgTypes[350] + mi := &file_product_proto_msgTypes[375] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16266,7 +17414,7 @@ func (x *RequireStorageFilteredTagSummaryByIdArgs) String() string { func (*RequireStorageFilteredTagSummaryByIdArgs) ProtoMessage() {} func (x *RequireStorageFilteredTagSummaryByIdArgs) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[350] + mi := &file_product_proto_msgTypes[375] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16279,7 +17427,7 @@ func (x *RequireStorageFilteredTagSummaryByIdArgs) ProtoReflect() protoreflect.M // Deprecated: Use RequireStorageFilteredTagSummaryByIdArgs.ProtoReflect.Descriptor instead. func (*RequireStorageFilteredTagSummaryByIdArgs) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{350} + return file_product_proto_rawDescGZIP(), []int{375} } func (x *RequireStorageFilteredTagSummaryByIdArgs) GetPrefix() string { @@ -16299,7 +17447,7 @@ type RequireStorageFilteredTagSummaryByIdResponse struct { func (x *RequireStorageFilteredTagSummaryByIdResponse) Reset() { *x = RequireStorageFilteredTagSummaryByIdResponse{} - mi := &file_product_proto_msgTypes[351] + mi := &file_product_proto_msgTypes[376] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16311,7 +17459,7 @@ func (x *RequireStorageFilteredTagSummaryByIdResponse) String() string { func (*RequireStorageFilteredTagSummaryByIdResponse) ProtoMessage() {} func (x *RequireStorageFilteredTagSummaryByIdResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[351] + mi := &file_product_proto_msgTypes[376] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16324,7 +17472,7 @@ func (x *RequireStorageFilteredTagSummaryByIdResponse) ProtoReflect() protorefle // Deprecated: Use RequireStorageFilteredTagSummaryByIdResponse.ProtoReflect.Descriptor instead. func (*RequireStorageFilteredTagSummaryByIdResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{351} + return file_product_proto_rawDescGZIP(), []int{376} } func (x *RequireStorageFilteredTagSummaryByIdResponse) GetResult() []*RequireStorageFilteredTagSummaryByIdResult { @@ -16343,7 +17491,7 @@ type RequireStorageFilteredTagSummaryByIdResult struct { func (x *RequireStorageFilteredTagSummaryByIdResult) Reset() { *x = RequireStorageFilteredTagSummaryByIdResult{} - mi := &file_product_proto_msgTypes[352] + mi := &file_product_proto_msgTypes[377] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16355,7 +17503,7 @@ func (x *RequireStorageFilteredTagSummaryByIdResult) String() string { func (*RequireStorageFilteredTagSummaryByIdResult) ProtoMessage() {} func (x *RequireStorageFilteredTagSummaryByIdResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[352] + mi := &file_product_proto_msgTypes[377] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16368,7 +17516,7 @@ func (x *RequireStorageFilteredTagSummaryByIdResult) ProtoReflect() protoreflect // Deprecated: Use RequireStorageFilteredTagSummaryByIdResult.ProtoReflect.Descriptor instead. func (*RequireStorageFilteredTagSummaryByIdResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{352} + return file_product_proto_rawDescGZIP(), []int{377} } func (x *RequireStorageFilteredTagSummaryByIdResult) GetFilteredTagSummary() *wrapperspb.StringValue { @@ -16387,7 +17535,7 @@ type RequireStorageFilteredTagSummaryByIdFields struct { func (x *RequireStorageFilteredTagSummaryByIdFields) Reset() { *x = RequireStorageFilteredTagSummaryByIdFields{} - mi := &file_product_proto_msgTypes[353] + mi := &file_product_proto_msgTypes[378] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16399,7 +17547,7 @@ func (x *RequireStorageFilteredTagSummaryByIdFields) String() string { func (*RequireStorageFilteredTagSummaryByIdFields) ProtoMessage() {} func (x *RequireStorageFilteredTagSummaryByIdFields) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[353] + mi := &file_product_proto_msgTypes[378] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16412,7 +17560,7 @@ func (x *RequireStorageFilteredTagSummaryByIdFields) ProtoReflect() protoreflect // Deprecated: Use RequireStorageFilteredTagSummaryByIdFields.ProtoReflect.Descriptor instead. func (*RequireStorageFilteredTagSummaryByIdFields) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{353} + return file_product_proto_rawDescGZIP(), []int{378} } func (x *RequireStorageFilteredTagSummaryByIdFields) GetTags() []string { @@ -16434,7 +17582,7 @@ type RequireStorageMultiFilteredTagSummaryByIdRequest struct { func (x *RequireStorageMultiFilteredTagSummaryByIdRequest) Reset() { *x = RequireStorageMultiFilteredTagSummaryByIdRequest{} - mi := &file_product_proto_msgTypes[354] + mi := &file_product_proto_msgTypes[379] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16446,7 +17594,7 @@ func (x *RequireStorageMultiFilteredTagSummaryByIdRequest) String() string { func (*RequireStorageMultiFilteredTagSummaryByIdRequest) ProtoMessage() {} func (x *RequireStorageMultiFilteredTagSummaryByIdRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[354] + mi := &file_product_proto_msgTypes[379] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16459,7 +17607,7 @@ func (x *RequireStorageMultiFilteredTagSummaryByIdRequest) ProtoReflect() protor // Deprecated: Use RequireStorageMultiFilteredTagSummaryByIdRequest.ProtoReflect.Descriptor instead. func (*RequireStorageMultiFilteredTagSummaryByIdRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{354} + return file_product_proto_rawDescGZIP(), []int{379} } func (x *RequireStorageMultiFilteredTagSummaryByIdRequest) GetContext() []*RequireStorageMultiFilteredTagSummaryByIdContext { @@ -16486,7 +17634,7 @@ type RequireStorageMultiFilteredTagSummaryByIdContext struct { func (x *RequireStorageMultiFilteredTagSummaryByIdContext) Reset() { *x = RequireStorageMultiFilteredTagSummaryByIdContext{} - mi := &file_product_proto_msgTypes[355] + mi := &file_product_proto_msgTypes[380] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16498,7 +17646,7 @@ func (x *RequireStorageMultiFilteredTagSummaryByIdContext) String() string { func (*RequireStorageMultiFilteredTagSummaryByIdContext) ProtoMessage() {} func (x *RequireStorageMultiFilteredTagSummaryByIdContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[355] + mi := &file_product_proto_msgTypes[380] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16511,7 +17659,7 @@ func (x *RequireStorageMultiFilteredTagSummaryByIdContext) ProtoReflect() protor // Deprecated: Use RequireStorageMultiFilteredTagSummaryByIdContext.ProtoReflect.Descriptor instead. func (*RequireStorageMultiFilteredTagSummaryByIdContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{355} + return file_product_proto_rawDescGZIP(), []int{380} } func (x *RequireStorageMultiFilteredTagSummaryByIdContext) GetKey() *LookupStorageByIdRequestKey { @@ -16538,7 +17686,7 @@ type RequireStorageMultiFilteredTagSummaryByIdArgs struct { func (x *RequireStorageMultiFilteredTagSummaryByIdArgs) Reset() { *x = RequireStorageMultiFilteredTagSummaryByIdArgs{} - mi := &file_product_proto_msgTypes[356] + mi := &file_product_proto_msgTypes[381] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16550,7 +17698,7 @@ func (x *RequireStorageMultiFilteredTagSummaryByIdArgs) String() string { func (*RequireStorageMultiFilteredTagSummaryByIdArgs) ProtoMessage() {} func (x *RequireStorageMultiFilteredTagSummaryByIdArgs) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[356] + mi := &file_product_proto_msgTypes[381] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16563,7 +17711,7 @@ func (x *RequireStorageMultiFilteredTagSummaryByIdArgs) ProtoReflect() protorefl // Deprecated: Use RequireStorageMultiFilteredTagSummaryByIdArgs.ProtoReflect.Descriptor instead. func (*RequireStorageMultiFilteredTagSummaryByIdArgs) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{356} + return file_product_proto_rawDescGZIP(), []int{381} } func (x *RequireStorageMultiFilteredTagSummaryByIdArgs) GetPrefixes() []string { @@ -16590,7 +17738,7 @@ type RequireStorageMultiFilteredTagSummaryByIdResponse struct { func (x *RequireStorageMultiFilteredTagSummaryByIdResponse) Reset() { *x = RequireStorageMultiFilteredTagSummaryByIdResponse{} - mi := &file_product_proto_msgTypes[357] + mi := &file_product_proto_msgTypes[382] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16602,7 +17750,7 @@ func (x *RequireStorageMultiFilteredTagSummaryByIdResponse) String() string { func (*RequireStorageMultiFilteredTagSummaryByIdResponse) ProtoMessage() {} func (x *RequireStorageMultiFilteredTagSummaryByIdResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[357] + mi := &file_product_proto_msgTypes[382] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16615,7 +17763,7 @@ func (x *RequireStorageMultiFilteredTagSummaryByIdResponse) ProtoReflect() proto // Deprecated: Use RequireStorageMultiFilteredTagSummaryByIdResponse.ProtoReflect.Descriptor instead. func (*RequireStorageMultiFilteredTagSummaryByIdResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{357} + return file_product_proto_rawDescGZIP(), []int{382} } func (x *RequireStorageMultiFilteredTagSummaryByIdResponse) GetResult() []*RequireStorageMultiFilteredTagSummaryByIdResult { @@ -16634,7 +17782,7 @@ type RequireStorageMultiFilteredTagSummaryByIdResult struct { func (x *RequireStorageMultiFilteredTagSummaryByIdResult) Reset() { *x = RequireStorageMultiFilteredTagSummaryByIdResult{} - mi := &file_product_proto_msgTypes[358] + mi := &file_product_proto_msgTypes[383] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16646,7 +17794,7 @@ func (x *RequireStorageMultiFilteredTagSummaryByIdResult) String() string { func (*RequireStorageMultiFilteredTagSummaryByIdResult) ProtoMessage() {} func (x *RequireStorageMultiFilteredTagSummaryByIdResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[358] + mi := &file_product_proto_msgTypes[383] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16659,7 +17807,7 @@ func (x *RequireStorageMultiFilteredTagSummaryByIdResult) ProtoReflect() protore // Deprecated: Use RequireStorageMultiFilteredTagSummaryByIdResult.ProtoReflect.Descriptor instead. func (*RequireStorageMultiFilteredTagSummaryByIdResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{358} + return file_product_proto_rawDescGZIP(), []int{383} } func (x *RequireStorageMultiFilteredTagSummaryByIdResult) GetMultiFilteredTagSummary() *wrapperspb.StringValue { @@ -16678,7 +17826,7 @@ type RequireStorageMultiFilteredTagSummaryByIdFields struct { func (x *RequireStorageMultiFilteredTagSummaryByIdFields) Reset() { *x = RequireStorageMultiFilteredTagSummaryByIdFields{} - mi := &file_product_proto_msgTypes[359] + mi := &file_product_proto_msgTypes[384] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16690,7 +17838,7 @@ func (x *RequireStorageMultiFilteredTagSummaryByIdFields) String() string { func (*RequireStorageMultiFilteredTagSummaryByIdFields) ProtoMessage() {} func (x *RequireStorageMultiFilteredTagSummaryByIdFields) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[359] + mi := &file_product_proto_msgTypes[384] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16703,7 +17851,7 @@ func (x *RequireStorageMultiFilteredTagSummaryByIdFields) ProtoReflect() protore // Deprecated: Use RequireStorageMultiFilteredTagSummaryByIdFields.ProtoReflect.Descriptor instead. func (*RequireStorageMultiFilteredTagSummaryByIdFields) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{359} + return file_product_proto_rawDescGZIP(), []int{384} } func (x *RequireStorageMultiFilteredTagSummaryByIdFields) GetTags() []string { @@ -16725,7 +17873,7 @@ type RequireStorageNullableFilteredTagSummaryByIdRequest struct { func (x *RequireStorageNullableFilteredTagSummaryByIdRequest) Reset() { *x = RequireStorageNullableFilteredTagSummaryByIdRequest{} - mi := &file_product_proto_msgTypes[360] + mi := &file_product_proto_msgTypes[385] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16737,7 +17885,7 @@ func (x *RequireStorageNullableFilteredTagSummaryByIdRequest) String() string { func (*RequireStorageNullableFilteredTagSummaryByIdRequest) ProtoMessage() {} func (x *RequireStorageNullableFilteredTagSummaryByIdRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[360] + mi := &file_product_proto_msgTypes[385] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16750,7 +17898,7 @@ func (x *RequireStorageNullableFilteredTagSummaryByIdRequest) ProtoReflect() pro // Deprecated: Use RequireStorageNullableFilteredTagSummaryByIdRequest.ProtoReflect.Descriptor instead. func (*RequireStorageNullableFilteredTagSummaryByIdRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{360} + return file_product_proto_rawDescGZIP(), []int{385} } func (x *RequireStorageNullableFilteredTagSummaryByIdRequest) GetContext() []*RequireStorageNullableFilteredTagSummaryByIdContext { @@ -16777,7 +17925,7 @@ type RequireStorageNullableFilteredTagSummaryByIdContext struct { func (x *RequireStorageNullableFilteredTagSummaryByIdContext) Reset() { *x = RequireStorageNullableFilteredTagSummaryByIdContext{} - mi := &file_product_proto_msgTypes[361] + mi := &file_product_proto_msgTypes[386] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16789,7 +17937,7 @@ func (x *RequireStorageNullableFilteredTagSummaryByIdContext) String() string { func (*RequireStorageNullableFilteredTagSummaryByIdContext) ProtoMessage() {} func (x *RequireStorageNullableFilteredTagSummaryByIdContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[361] + mi := &file_product_proto_msgTypes[386] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16802,7 +17950,7 @@ func (x *RequireStorageNullableFilteredTagSummaryByIdContext) ProtoReflect() pro // Deprecated: Use RequireStorageNullableFilteredTagSummaryByIdContext.ProtoReflect.Descriptor instead. func (*RequireStorageNullableFilteredTagSummaryByIdContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{361} + return file_product_proto_rawDescGZIP(), []int{386} } func (x *RequireStorageNullableFilteredTagSummaryByIdContext) GetKey() *LookupStorageByIdRequestKey { @@ -16828,7 +17976,7 @@ type RequireStorageNullableFilteredTagSummaryByIdArgs struct { func (x *RequireStorageNullableFilteredTagSummaryByIdArgs) Reset() { *x = RequireStorageNullableFilteredTagSummaryByIdArgs{} - mi := &file_product_proto_msgTypes[362] + mi := &file_product_proto_msgTypes[387] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16840,7 +17988,7 @@ func (x *RequireStorageNullableFilteredTagSummaryByIdArgs) String() string { func (*RequireStorageNullableFilteredTagSummaryByIdArgs) ProtoMessage() {} func (x *RequireStorageNullableFilteredTagSummaryByIdArgs) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[362] + mi := &file_product_proto_msgTypes[387] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16853,7 +18001,7 @@ func (x *RequireStorageNullableFilteredTagSummaryByIdArgs) ProtoReflect() protor // Deprecated: Use RequireStorageNullableFilteredTagSummaryByIdArgs.ProtoReflect.Descriptor instead. func (*RequireStorageNullableFilteredTagSummaryByIdArgs) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{362} + return file_product_proto_rawDescGZIP(), []int{387} } func (x *RequireStorageNullableFilteredTagSummaryByIdArgs) GetPrefix() *wrapperspb.StringValue { @@ -16873,7 +18021,7 @@ type RequireStorageNullableFilteredTagSummaryByIdResponse struct { func (x *RequireStorageNullableFilteredTagSummaryByIdResponse) Reset() { *x = RequireStorageNullableFilteredTagSummaryByIdResponse{} - mi := &file_product_proto_msgTypes[363] + mi := &file_product_proto_msgTypes[388] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16885,7 +18033,7 @@ func (x *RequireStorageNullableFilteredTagSummaryByIdResponse) String() string { func (*RequireStorageNullableFilteredTagSummaryByIdResponse) ProtoMessage() {} func (x *RequireStorageNullableFilteredTagSummaryByIdResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[363] + mi := &file_product_proto_msgTypes[388] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16898,7 +18046,7 @@ func (x *RequireStorageNullableFilteredTagSummaryByIdResponse) ProtoReflect() pr // Deprecated: Use RequireStorageNullableFilteredTagSummaryByIdResponse.ProtoReflect.Descriptor instead. func (*RequireStorageNullableFilteredTagSummaryByIdResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{363} + return file_product_proto_rawDescGZIP(), []int{388} } func (x *RequireStorageNullableFilteredTagSummaryByIdResponse) GetResult() []*RequireStorageNullableFilteredTagSummaryByIdResult { @@ -16917,7 +18065,7 @@ type RequireStorageNullableFilteredTagSummaryByIdResult struct { func (x *RequireStorageNullableFilteredTagSummaryByIdResult) Reset() { *x = RequireStorageNullableFilteredTagSummaryByIdResult{} - mi := &file_product_proto_msgTypes[364] + mi := &file_product_proto_msgTypes[389] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16929,7 +18077,7 @@ func (x *RequireStorageNullableFilteredTagSummaryByIdResult) String() string { func (*RequireStorageNullableFilteredTagSummaryByIdResult) ProtoMessage() {} func (x *RequireStorageNullableFilteredTagSummaryByIdResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[364] + mi := &file_product_proto_msgTypes[389] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16942,7 +18090,7 @@ func (x *RequireStorageNullableFilteredTagSummaryByIdResult) ProtoReflect() prot // Deprecated: Use RequireStorageNullableFilteredTagSummaryByIdResult.ProtoReflect.Descriptor instead. func (*RequireStorageNullableFilteredTagSummaryByIdResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{364} + return file_product_proto_rawDescGZIP(), []int{389} } func (x *RequireStorageNullableFilteredTagSummaryByIdResult) GetNullableFilteredTagSummary() *wrapperspb.StringValue { @@ -16961,7 +18109,7 @@ type RequireStorageNullableFilteredTagSummaryByIdFields struct { func (x *RequireStorageNullableFilteredTagSummaryByIdFields) Reset() { *x = RequireStorageNullableFilteredTagSummaryByIdFields{} - mi := &file_product_proto_msgTypes[365] + mi := &file_product_proto_msgTypes[390] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16973,7 +18121,7 @@ func (x *RequireStorageNullableFilteredTagSummaryByIdFields) String() string { func (*RequireStorageNullableFilteredTagSummaryByIdFields) ProtoMessage() {} func (x *RequireStorageNullableFilteredTagSummaryByIdFields) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[365] + mi := &file_product_proto_msgTypes[390] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16986,7 +18134,7 @@ func (x *RequireStorageNullableFilteredTagSummaryByIdFields) ProtoReflect() prot // Deprecated: Use RequireStorageNullableFilteredTagSummaryByIdFields.ProtoReflect.Descriptor instead. func (*RequireStorageNullableFilteredTagSummaryByIdFields) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{365} + return file_product_proto_rawDescGZIP(), []int{390} } func (x *RequireStorageNullableFilteredTagSummaryByIdFields) GetTags() []string { @@ -17006,7 +18154,7 @@ type RequireWarehouseStockHealthScoreByIdRequest struct { func (x *RequireWarehouseStockHealthScoreByIdRequest) Reset() { *x = RequireWarehouseStockHealthScoreByIdRequest{} - mi := &file_product_proto_msgTypes[366] + mi := &file_product_proto_msgTypes[391] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17018,7 +18166,7 @@ func (x *RequireWarehouseStockHealthScoreByIdRequest) String() string { func (*RequireWarehouseStockHealthScoreByIdRequest) ProtoMessage() {} func (x *RequireWarehouseStockHealthScoreByIdRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[366] + mi := &file_product_proto_msgTypes[391] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17031,7 +18179,7 @@ func (x *RequireWarehouseStockHealthScoreByIdRequest) ProtoReflect() protoreflec // Deprecated: Use RequireWarehouseStockHealthScoreByIdRequest.ProtoReflect.Descriptor instead. func (*RequireWarehouseStockHealthScoreByIdRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{366} + return file_product_proto_rawDescGZIP(), []int{391} } func (x *RequireWarehouseStockHealthScoreByIdRequest) GetContext() []*RequireWarehouseStockHealthScoreByIdContext { @@ -17051,7 +18199,7 @@ type RequireWarehouseStockHealthScoreByIdContext struct { func (x *RequireWarehouseStockHealthScoreByIdContext) Reset() { *x = RequireWarehouseStockHealthScoreByIdContext{} - mi := &file_product_proto_msgTypes[367] + mi := &file_product_proto_msgTypes[392] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17063,7 +18211,7 @@ func (x *RequireWarehouseStockHealthScoreByIdContext) String() string { func (*RequireWarehouseStockHealthScoreByIdContext) ProtoMessage() {} func (x *RequireWarehouseStockHealthScoreByIdContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[367] + mi := &file_product_proto_msgTypes[392] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17076,7 +18224,7 @@ func (x *RequireWarehouseStockHealthScoreByIdContext) ProtoReflect() protoreflec // Deprecated: Use RequireWarehouseStockHealthScoreByIdContext.ProtoReflect.Descriptor instead. func (*RequireWarehouseStockHealthScoreByIdContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{367} + return file_product_proto_rawDescGZIP(), []int{392} } func (x *RequireWarehouseStockHealthScoreByIdContext) GetKey() *LookupWarehouseByIdRequestKey { @@ -17103,7 +18251,7 @@ type RequireWarehouseStockHealthScoreByIdResponse struct { func (x *RequireWarehouseStockHealthScoreByIdResponse) Reset() { *x = RequireWarehouseStockHealthScoreByIdResponse{} - mi := &file_product_proto_msgTypes[368] + mi := &file_product_proto_msgTypes[393] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17115,7 +18263,7 @@ func (x *RequireWarehouseStockHealthScoreByIdResponse) String() string { func (*RequireWarehouseStockHealthScoreByIdResponse) ProtoMessage() {} func (x *RequireWarehouseStockHealthScoreByIdResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[368] + mi := &file_product_proto_msgTypes[393] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17128,7 +18276,7 @@ func (x *RequireWarehouseStockHealthScoreByIdResponse) ProtoReflect() protorefle // Deprecated: Use RequireWarehouseStockHealthScoreByIdResponse.ProtoReflect.Descriptor instead. func (*RequireWarehouseStockHealthScoreByIdResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{368} + return file_product_proto_rawDescGZIP(), []int{393} } func (x *RequireWarehouseStockHealthScoreByIdResponse) GetResult() []*RequireWarehouseStockHealthScoreByIdResult { @@ -17147,7 +18295,7 @@ type RequireWarehouseStockHealthScoreByIdResult struct { func (x *RequireWarehouseStockHealthScoreByIdResult) Reset() { *x = RequireWarehouseStockHealthScoreByIdResult{} - mi := &file_product_proto_msgTypes[369] + mi := &file_product_proto_msgTypes[394] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17159,7 +18307,7 @@ func (x *RequireWarehouseStockHealthScoreByIdResult) String() string { func (*RequireWarehouseStockHealthScoreByIdResult) ProtoMessage() {} func (x *RequireWarehouseStockHealthScoreByIdResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[369] + mi := &file_product_proto_msgTypes[394] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17172,7 +18320,7 @@ func (x *RequireWarehouseStockHealthScoreByIdResult) ProtoReflect() protoreflect // Deprecated: Use RequireWarehouseStockHealthScoreByIdResult.ProtoReflect.Descriptor instead. func (*RequireWarehouseStockHealthScoreByIdResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{369} + return file_product_proto_rawDescGZIP(), []int{394} } func (x *RequireWarehouseStockHealthScoreByIdResult) GetStockHealthScore() float64 { @@ -17192,7 +18340,7 @@ type RequireWarehouseStockHealthScoreByIdFields struct { func (x *RequireWarehouseStockHealthScoreByIdFields) Reset() { *x = RequireWarehouseStockHealthScoreByIdFields{} - mi := &file_product_proto_msgTypes[370] + mi := &file_product_proto_msgTypes[395] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17204,7 +18352,7 @@ func (x *RequireWarehouseStockHealthScoreByIdFields) String() string { func (*RequireWarehouseStockHealthScoreByIdFields) ProtoMessage() {} func (x *RequireWarehouseStockHealthScoreByIdFields) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[370] + mi := &file_product_proto_msgTypes[395] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17217,7 +18365,7 @@ func (x *RequireWarehouseStockHealthScoreByIdFields) ProtoReflect() protoreflect // Deprecated: Use RequireWarehouseStockHealthScoreByIdFields.ProtoReflect.Descriptor instead. func (*RequireWarehouseStockHealthScoreByIdFields) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{370} + return file_product_proto_rawDescGZIP(), []int{395} } func (x *RequireWarehouseStockHealthScoreByIdFields) GetInventoryCount() int32 { @@ -17245,7 +18393,7 @@ type Product struct { func (x *Product) Reset() { *x = Product{} - mi := &file_product_proto_msgTypes[371] + mi := &file_product_proto_msgTypes[396] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17257,7 +18405,7 @@ func (x *Product) String() string { func (*Product) ProtoMessage() {} func (x *Product) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[371] + mi := &file_product_proto_msgTypes[396] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17270,7 +18418,7 @@ func (x *Product) ProtoReflect() protoreflect.Message { // Deprecated: Use Product.ProtoReflect.Descriptor instead. func (*Product) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{371} + return file_product_proto_rawDescGZIP(), []int{396} } func (x *Product) GetId() string { @@ -17305,7 +18453,7 @@ type Storage struct { func (x *Storage) Reset() { *x = Storage{} - mi := &file_product_proto_msgTypes[372] + mi := &file_product_proto_msgTypes[397] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17317,7 +18465,7 @@ func (x *Storage) String() string { func (*Storage) ProtoMessage() {} func (x *Storage) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[372] + mi := &file_product_proto_msgTypes[397] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17330,7 +18478,7 @@ func (x *Storage) ProtoReflect() protoreflect.Message { // Deprecated: Use Storage.ProtoReflect.Descriptor instead. func (*Storage) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{372} + return file_product_proto_rawDescGZIP(), []int{397} } func (x *Storage) GetId() string { @@ -17365,7 +18513,7 @@ type Warehouse struct { func (x *Warehouse) Reset() { *x = Warehouse{} - mi := &file_product_proto_msgTypes[373] + mi := &file_product_proto_msgTypes[398] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17377,7 +18525,7 @@ func (x *Warehouse) String() string { func (*Warehouse) ProtoMessage() {} func (x *Warehouse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[373] + mi := &file_product_proto_msgTypes[398] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17390,7 +18538,7 @@ func (x *Warehouse) ProtoReflect() protoreflect.Message { // Deprecated: Use Warehouse.ProtoReflect.Descriptor instead. func (*Warehouse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{373} + return file_product_proto_rawDescGZIP(), []int{398} } func (x *Warehouse) GetId() string { @@ -17424,7 +18572,7 @@ type User struct { func (x *User) Reset() { *x = User{} - mi := &file_product_proto_msgTypes[374] + mi := &file_product_proto_msgTypes[399] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17436,7 +18584,7 @@ func (x *User) String() string { func (*User) ProtoMessage() {} func (x *User) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[374] + mi := &file_product_proto_msgTypes[399] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17449,7 +18597,7 @@ func (x *User) ProtoReflect() protoreflect.Message { // Deprecated: Use User.ProtoReflect.Descriptor instead. func (*User) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{374} + return file_product_proto_rawDescGZIP(), []int{399} } func (x *User) GetId() string { @@ -17477,7 +18625,7 @@ type NestedTypeA struct { func (x *NestedTypeA) Reset() { *x = NestedTypeA{} - mi := &file_product_proto_msgTypes[375] + mi := &file_product_proto_msgTypes[400] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17489,7 +18637,7 @@ func (x *NestedTypeA) String() string { func (*NestedTypeA) ProtoMessage() {} func (x *NestedTypeA) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[375] + mi := &file_product_proto_msgTypes[400] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17502,7 +18650,7 @@ func (x *NestedTypeA) ProtoReflect() protoreflect.Message { // Deprecated: Use NestedTypeA.ProtoReflect.Descriptor instead. func (*NestedTypeA) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{375} + return file_product_proto_rawDescGZIP(), []int{400} } func (x *NestedTypeA) GetId() string { @@ -17537,7 +18685,7 @@ type RecursiveType struct { func (x *RecursiveType) Reset() { *x = RecursiveType{} - mi := &file_product_proto_msgTypes[376] + mi := &file_product_proto_msgTypes[401] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17549,7 +18697,7 @@ func (x *RecursiveType) String() string { func (*RecursiveType) ProtoMessage() {} func (x *RecursiveType) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[376] + mi := &file_product_proto_msgTypes[401] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17562,7 +18710,7 @@ func (x *RecursiveType) ProtoReflect() protoreflect.Message { // Deprecated: Use RecursiveType.ProtoReflect.Descriptor instead. func (*RecursiveType) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{376} + return file_product_proto_rawDescGZIP(), []int{401} } func (x *RecursiveType) GetId() string { @@ -17598,7 +18746,7 @@ type TypeWithMultipleFilterFields struct { func (x *TypeWithMultipleFilterFields) Reset() { *x = TypeWithMultipleFilterFields{} - mi := &file_product_proto_msgTypes[377] + mi := &file_product_proto_msgTypes[402] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17610,7 +18758,7 @@ func (x *TypeWithMultipleFilterFields) String() string { func (*TypeWithMultipleFilterFields) ProtoMessage() {} func (x *TypeWithMultipleFilterFields) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[377] + mi := &file_product_proto_msgTypes[402] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17623,7 +18771,7 @@ func (x *TypeWithMultipleFilterFields) ProtoReflect() protoreflect.Message { // Deprecated: Use TypeWithMultipleFilterFields.ProtoReflect.Descriptor instead. func (*TypeWithMultipleFilterFields) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{377} + return file_product_proto_rawDescGZIP(), []int{402} } func (x *TypeWithMultipleFilterFields) GetId() string { @@ -17664,7 +18812,7 @@ type FilterTypeInput struct { func (x *FilterTypeInput) Reset() { *x = FilterTypeInput{} - mi := &file_product_proto_msgTypes[378] + mi := &file_product_proto_msgTypes[403] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17676,7 +18824,7 @@ func (x *FilterTypeInput) String() string { func (*FilterTypeInput) ProtoMessage() {} func (x *FilterTypeInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[378] + mi := &file_product_proto_msgTypes[403] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17689,7 +18837,7 @@ func (x *FilterTypeInput) ProtoReflect() protoreflect.Message { // Deprecated: Use FilterTypeInput.ProtoReflect.Descriptor instead. func (*FilterTypeInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{378} + return file_product_proto_rawDescGZIP(), []int{403} } func (x *FilterTypeInput) GetFilterField_1() string { @@ -17715,7 +18863,7 @@ type ComplexFilterTypeInput struct { func (x *ComplexFilterTypeInput) Reset() { *x = ComplexFilterTypeInput{} - mi := &file_product_proto_msgTypes[379] + mi := &file_product_proto_msgTypes[404] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17727,7 +18875,7 @@ func (x *ComplexFilterTypeInput) String() string { func (*ComplexFilterTypeInput) ProtoMessage() {} func (x *ComplexFilterTypeInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[379] + mi := &file_product_proto_msgTypes[404] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17740,7 +18888,7 @@ func (x *ComplexFilterTypeInput) ProtoReflect() protoreflect.Message { // Deprecated: Use ComplexFilterTypeInput.ProtoReflect.Descriptor instead. func (*ComplexFilterTypeInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{379} + return file_product_proto_rawDescGZIP(), []int{404} } func (x *ComplexFilterTypeInput) GetFilter() *FilterType { @@ -17760,7 +18908,7 @@ type TypeWithComplexFilterInput struct { func (x *TypeWithComplexFilterInput) Reset() { *x = TypeWithComplexFilterInput{} - mi := &file_product_proto_msgTypes[380] + mi := &file_product_proto_msgTypes[405] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17772,7 +18920,7 @@ func (x *TypeWithComplexFilterInput) String() string { func (*TypeWithComplexFilterInput) ProtoMessage() {} func (x *TypeWithComplexFilterInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[380] + mi := &file_product_proto_msgTypes[405] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17785,7 +18933,7 @@ func (x *TypeWithComplexFilterInput) ProtoReflect() protoreflect.Message { // Deprecated: Use TypeWithComplexFilterInput.ProtoReflect.Descriptor instead. func (*TypeWithComplexFilterInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{380} + return file_product_proto_rawDescGZIP(), []int{405} } func (x *TypeWithComplexFilterInput) GetId() string { @@ -17813,7 +18961,7 @@ type OrderInput struct { func (x *OrderInput) Reset() { *x = OrderInput{} - mi := &file_product_proto_msgTypes[381] + mi := &file_product_proto_msgTypes[406] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17825,7 +18973,7 @@ func (x *OrderInput) String() string { func (*OrderInput) ProtoMessage() {} func (x *OrderInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[381] + mi := &file_product_proto_msgTypes[406] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17838,7 +18986,7 @@ func (x *OrderInput) ProtoReflect() protoreflect.Message { // Deprecated: Use OrderInput.ProtoReflect.Descriptor instead. func (*OrderInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{381} + return file_product_proto_rawDescGZIP(), []int{406} } func (x *OrderInput) GetOrderId() string { @@ -17874,7 +19022,7 @@ type Order struct { func (x *Order) Reset() { *x = Order{} - mi := &file_product_proto_msgTypes[382] + mi := &file_product_proto_msgTypes[407] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17886,7 +19034,7 @@ func (x *Order) String() string { func (*Order) ProtoMessage() {} func (x *Order) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[382] + mi := &file_product_proto_msgTypes[407] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17899,7 +19047,7 @@ func (x *Order) ProtoReflect() protoreflect.Message { // Deprecated: Use Order.ProtoReflect.Descriptor instead. func (*Order) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{382} + return file_product_proto_rawDescGZIP(), []int{407} } func (x *Order) GetOrderId() string { @@ -17943,7 +19091,7 @@ type Category struct { func (x *Category) Reset() { *x = Category{} - mi := &file_product_proto_msgTypes[383] + mi := &file_product_proto_msgTypes[408] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17955,7 +19103,7 @@ func (x *Category) String() string { func (*Category) ProtoMessage() {} func (x *Category) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[383] + mi := &file_product_proto_msgTypes[408] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17968,7 +19116,7 @@ func (x *Category) ProtoReflect() protoreflect.Message { // Deprecated: Use Category.ProtoReflect.Descriptor instead. func (*Category) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{383} + return file_product_proto_rawDescGZIP(), []int{408} } func (x *Category) GetId() string { @@ -18016,7 +19164,7 @@ type CategoryFilter struct { func (x *CategoryFilter) Reset() { *x = CategoryFilter{} - mi := &file_product_proto_msgTypes[384] + mi := &file_product_proto_msgTypes[409] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -18028,7 +19176,7 @@ func (x *CategoryFilter) String() string { func (*CategoryFilter) ProtoMessage() {} func (x *CategoryFilter) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[384] + mi := &file_product_proto_msgTypes[409] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18041,7 +19189,7 @@ func (x *CategoryFilter) ProtoReflect() protoreflect.Message { // Deprecated: Use CategoryFilter.ProtoReflect.Descriptor instead. func (*CategoryFilter) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{384} + return file_product_proto_rawDescGZIP(), []int{409} } func (x *CategoryFilter) GetCategory() CategoryKind { @@ -18071,7 +19219,7 @@ type Animal struct { func (x *Animal) Reset() { *x = Animal{} - mi := &file_product_proto_msgTypes[385] + mi := &file_product_proto_msgTypes[410] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -18083,7 +19231,7 @@ func (x *Animal) String() string { func (*Animal) ProtoMessage() {} func (x *Animal) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[385] + mi := &file_product_proto_msgTypes[410] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18096,7 +19244,7 @@ func (x *Animal) ProtoReflect() protoreflect.Message { // Deprecated: Use Animal.ProtoReflect.Descriptor instead. func (*Animal) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{385} + return file_product_proto_rawDescGZIP(), []int{410} } func (x *Animal) GetInstance() isAnimal_Instance { @@ -18150,7 +19298,7 @@ type SearchInput struct { func (x *SearchInput) Reset() { *x = SearchInput{} - mi := &file_product_proto_msgTypes[386] + mi := &file_product_proto_msgTypes[411] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -18162,7 +19310,7 @@ func (x *SearchInput) String() string { func (*SearchInput) ProtoMessage() {} func (x *SearchInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[386] + mi := &file_product_proto_msgTypes[411] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18175,7 +19323,7 @@ func (x *SearchInput) ProtoReflect() protoreflect.Message { // Deprecated: Use SearchInput.ProtoReflect.Descriptor instead. func (*SearchInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{386} + return file_product_proto_rawDescGZIP(), []int{411} } func (x *SearchInput) GetQuery() string { @@ -18206,7 +19354,7 @@ type SearchResult struct { func (x *SearchResult) Reset() { *x = SearchResult{} - mi := &file_product_proto_msgTypes[387] + mi := &file_product_proto_msgTypes[412] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -18218,7 +19366,7 @@ func (x *SearchResult) String() string { func (*SearchResult) ProtoMessage() {} func (x *SearchResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[387] + mi := &file_product_proto_msgTypes[412] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18231,7 +19379,7 @@ func (x *SearchResult) ProtoReflect() protoreflect.Message { // Deprecated: Use SearchResult.ProtoReflect.Descriptor instead. func (*SearchResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{387} + return file_product_proto_rawDescGZIP(), []int{412} } func (x *SearchResult) GetValue() isSearchResult_Value { @@ -18306,7 +19454,7 @@ type NullableFieldsType struct { func (x *NullableFieldsType) Reset() { *x = NullableFieldsType{} - mi := &file_product_proto_msgTypes[388] + mi := &file_product_proto_msgTypes[413] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -18318,7 +19466,7 @@ func (x *NullableFieldsType) String() string { func (*NullableFieldsType) ProtoMessage() {} func (x *NullableFieldsType) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[388] + mi := &file_product_proto_msgTypes[413] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18331,7 +19479,7 @@ func (x *NullableFieldsType) ProtoReflect() protoreflect.Message { // Deprecated: Use NullableFieldsType.ProtoReflect.Descriptor instead. func (*NullableFieldsType) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{388} + return file_product_proto_rawDescGZIP(), []int{413} } func (x *NullableFieldsType) GetId() string { @@ -18401,7 +19549,7 @@ type NullableFieldsFilter struct { func (x *NullableFieldsFilter) Reset() { *x = NullableFieldsFilter{} - mi := &file_product_proto_msgTypes[389] + mi := &file_product_proto_msgTypes[414] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -18413,7 +19561,7 @@ func (x *NullableFieldsFilter) String() string { func (*NullableFieldsFilter) ProtoMessage() {} func (x *NullableFieldsFilter) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[389] + mi := &file_product_proto_msgTypes[414] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18426,7 +19574,7 @@ func (x *NullableFieldsFilter) ProtoReflect() protoreflect.Message { // Deprecated: Use NullableFieldsFilter.ProtoReflect.Descriptor instead. func (*NullableFieldsFilter) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{389} + return file_product_proto_rawDescGZIP(), []int{414} } func (x *NullableFieldsFilter) GetName() *wrapperspb.StringValue { @@ -18478,7 +19626,7 @@ type BlogPost struct { func (x *BlogPost) Reset() { *x = BlogPost{} - mi := &file_product_proto_msgTypes[390] + mi := &file_product_proto_msgTypes[415] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -18490,7 +19638,7 @@ func (x *BlogPost) String() string { func (*BlogPost) ProtoMessage() {} func (x *BlogPost) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[390] + mi := &file_product_proto_msgTypes[415] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18503,7 +19651,7 @@ func (x *BlogPost) ProtoReflect() protoreflect.Message { // Deprecated: Use BlogPost.ProtoReflect.Descriptor instead. func (*BlogPost) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{390} + return file_product_proto_rawDescGZIP(), []int{415} } func (x *BlogPost) GetId() string { @@ -18657,7 +19805,7 @@ type BlogPostFilter struct { func (x *BlogPostFilter) Reset() { *x = BlogPostFilter{} - mi := &file_product_proto_msgTypes[391] + mi := &file_product_proto_msgTypes[416] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -18669,7 +19817,7 @@ func (x *BlogPostFilter) String() string { func (*BlogPostFilter) ProtoMessage() {} func (x *BlogPostFilter) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[391] + mi := &file_product_proto_msgTypes[416] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18682,7 +19830,7 @@ func (x *BlogPostFilter) ProtoReflect() protoreflect.Message { // Deprecated: Use BlogPostFilter.ProtoReflect.Descriptor instead. func (*BlogPostFilter) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{391} + return file_product_proto_rawDescGZIP(), []int{416} } func (x *BlogPostFilter) GetTitle() *wrapperspb.StringValue { @@ -18729,7 +19877,7 @@ type Author struct { func (x *Author) Reset() { *x = Author{} - mi := &file_product_proto_msgTypes[392] + mi := &file_product_proto_msgTypes[417] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -18741,7 +19889,7 @@ func (x *Author) String() string { func (*Author) ProtoMessage() {} func (x *Author) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[392] + mi := &file_product_proto_msgTypes[417] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18754,7 +19902,7 @@ func (x *Author) ProtoReflect() protoreflect.Message { // Deprecated: Use Author.ProtoReflect.Descriptor instead. func (*Author) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{392} + return file_product_proto_rawDescGZIP(), []int{417} } func (x *Author) GetId() string { @@ -18873,7 +20021,7 @@ type AuthorFilter struct { func (x *AuthorFilter) Reset() { *x = AuthorFilter{} - mi := &file_product_proto_msgTypes[393] + mi := &file_product_proto_msgTypes[418] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -18885,7 +20033,7 @@ func (x *AuthorFilter) String() string { func (*AuthorFilter) ProtoMessage() {} func (x *AuthorFilter) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[393] + mi := &file_product_proto_msgTypes[418] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18898,7 +20046,7 @@ func (x *AuthorFilter) ProtoReflect() protoreflect.Message { // Deprecated: Use AuthorFilter.ProtoReflect.Descriptor instead. func (*AuthorFilter) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{393} + return file_product_proto_rawDescGZIP(), []int{418} } func (x *AuthorFilter) GetName() *wrapperspb.StringValue { @@ -18933,7 +20081,7 @@ type TestContainer struct { func (x *TestContainer) Reset() { *x = TestContainer{} - mi := &file_product_proto_msgTypes[394] + mi := &file_product_proto_msgTypes[419] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -18945,7 +20093,7 @@ func (x *TestContainer) String() string { func (*TestContainer) ProtoMessage() {} func (x *TestContainer) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[394] + mi := &file_product_proto_msgTypes[419] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18958,7 +20106,7 @@ func (x *TestContainer) ProtoReflect() protoreflect.Message { // Deprecated: Use TestContainer.ProtoReflect.Descriptor instead. func (*TestContainer) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{394} + return file_product_proto_rawDescGZIP(), []int{419} } func (x *TestContainer) GetId() string { @@ -18994,7 +20142,7 @@ type ConditionsInput struct { func (x *ConditionsInput) Reset() { *x = ConditionsInput{} - mi := &file_product_proto_msgTypes[395] + mi := &file_product_proto_msgTypes[420] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -19006,7 +20154,7 @@ func (x *ConditionsInput) String() string { func (*ConditionsInput) ProtoMessage() {} func (x *ConditionsInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[395] + mi := &file_product_proto_msgTypes[420] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -19019,7 +20167,7 @@ func (x *ConditionsInput) ProtoReflect() protoreflect.Message { // Deprecated: Use ConditionsInput.ProtoReflect.Descriptor instead. func (*ConditionsInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{395} + return file_product_proto_rawDescGZIP(), []int{420} } func (x *ConditionsInput) GetAnd() *ListOfConditionsInput { @@ -19061,7 +20209,7 @@ type ConditionalSearchResult struct { func (x *ConditionalSearchResult) Reset() { *x = ConditionalSearchResult{} - mi := &file_product_proto_msgTypes[396] + mi := &file_product_proto_msgTypes[421] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -19073,7 +20221,7 @@ func (x *ConditionalSearchResult) String() string { func (*ConditionalSearchResult) ProtoMessage() {} func (x *ConditionalSearchResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[396] + mi := &file_product_proto_msgTypes[421] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -19086,7 +20234,7 @@ func (x *ConditionalSearchResult) ProtoReflect() protoreflect.Message { // Deprecated: Use ConditionalSearchResult.ProtoReflect.Descriptor instead. func (*ConditionalSearchResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{396} + return file_product_proto_rawDescGZIP(), []int{421} } func (x *ConditionalSearchResult) GetId() string { @@ -19119,7 +20267,7 @@ type UserInput struct { func (x *UserInput) Reset() { *x = UserInput{} - mi := &file_product_proto_msgTypes[397] + mi := &file_product_proto_msgTypes[422] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -19131,7 +20279,7 @@ func (x *UserInput) String() string { func (*UserInput) ProtoMessage() {} func (x *UserInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[397] + mi := &file_product_proto_msgTypes[422] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -19144,7 +20292,7 @@ func (x *UserInput) ProtoReflect() protoreflect.Message { // Deprecated: Use UserInput.ProtoReflect.Descriptor instead. func (*UserInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{397} + return file_product_proto_rawDescGZIP(), []int{422} } func (x *UserInput) GetName() string { @@ -19164,7 +20312,7 @@ type ActionInput struct { func (x *ActionInput) Reset() { *x = ActionInput{} - mi := &file_product_proto_msgTypes[398] + mi := &file_product_proto_msgTypes[423] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -19176,7 +20324,7 @@ func (x *ActionInput) String() string { func (*ActionInput) ProtoMessage() {} func (x *ActionInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[398] + mi := &file_product_proto_msgTypes[423] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -19189,7 +20337,7 @@ func (x *ActionInput) ProtoReflect() protoreflect.Message { // Deprecated: Use ActionInput.ProtoReflect.Descriptor instead. func (*ActionInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{398} + return file_product_proto_rawDescGZIP(), []int{423} } func (x *ActionInput) GetType() string { @@ -19219,7 +20367,7 @@ type ActionResult struct { func (x *ActionResult) Reset() { *x = ActionResult{} - mi := &file_product_proto_msgTypes[399] + mi := &file_product_proto_msgTypes[424] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -19231,7 +20379,7 @@ func (x *ActionResult) String() string { func (*ActionResult) ProtoMessage() {} func (x *ActionResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[399] + mi := &file_product_proto_msgTypes[424] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -19244,7 +20392,7 @@ func (x *ActionResult) ProtoReflect() protoreflect.Message { // Deprecated: Use ActionResult.ProtoReflect.Descriptor instead. func (*ActionResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{399} + return file_product_proto_rawDescGZIP(), []int{424} } func (x *ActionResult) GetValue() isActionResult_Value { @@ -19303,7 +20451,7 @@ type NullableFieldsInput struct { func (x *NullableFieldsInput) Reset() { *x = NullableFieldsInput{} - mi := &file_product_proto_msgTypes[400] + mi := &file_product_proto_msgTypes[425] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -19315,7 +20463,7 @@ func (x *NullableFieldsInput) String() string { func (*NullableFieldsInput) ProtoMessage() {} func (x *NullableFieldsInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[400] + mi := &file_product_proto_msgTypes[425] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -19328,7 +20476,7 @@ func (x *NullableFieldsInput) ProtoReflect() protoreflect.Message { // Deprecated: Use NullableFieldsInput.ProtoReflect.Descriptor instead. func (*NullableFieldsInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{400} + return file_product_proto_rawDescGZIP(), []int{425} } func (x *NullableFieldsInput) GetName() string { @@ -19404,7 +20552,7 @@ type BlogPostInput struct { func (x *BlogPostInput) Reset() { *x = BlogPostInput{} - mi := &file_product_proto_msgTypes[401] + mi := &file_product_proto_msgTypes[426] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -19416,7 +20564,7 @@ func (x *BlogPostInput) String() string { func (*BlogPostInput) ProtoMessage() {} func (x *BlogPostInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[401] + mi := &file_product_proto_msgTypes[426] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -19429,7 +20577,7 @@ func (x *BlogPostInput) ProtoReflect() protoreflect.Message { // Deprecated: Use BlogPostInput.ProtoReflect.Descriptor instead. func (*BlogPostInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{401} + return file_product_proto_rawDescGZIP(), []int{426} } func (x *BlogPostInput) GetTitle() string { @@ -19562,7 +20710,7 @@ type AuthorInput struct { func (x *AuthorInput) Reset() { *x = AuthorInput{} - mi := &file_product_proto_msgTypes[402] + mi := &file_product_proto_msgTypes[427] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -19574,7 +20722,7 @@ func (x *AuthorInput) String() string { func (*AuthorInput) ProtoMessage() {} func (x *AuthorInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[402] + mi := &file_product_proto_msgTypes[427] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -19587,7 +20735,7 @@ func (x *AuthorInput) ProtoReflect() protoreflect.Message { // Deprecated: Use AuthorInput.ProtoReflect.Descriptor instead. func (*AuthorInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{402} + return file_product_proto_rawDescGZIP(), []int{427} } func (x *AuthorInput) GetName() string { @@ -19672,7 +20820,7 @@ type ProductDetails struct { func (x *ProductDetails) Reset() { *x = ProductDetails{} - mi := &file_product_proto_msgTypes[403] + mi := &file_product_proto_msgTypes[428] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -19684,7 +20832,7 @@ func (x *ProductDetails) String() string { func (*ProductDetails) ProtoMessage() {} func (x *ProductDetails) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[403] + mi := &file_product_proto_msgTypes[428] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -19697,7 +20845,7 @@ func (x *ProductDetails) ProtoReflect() protoreflect.Message { // Deprecated: Use ProductDetails.ProtoReflect.Descriptor instead. func (*ProductDetails) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{403} + return file_product_proto_rawDescGZIP(), []int{428} } func (x *ProductDetails) GetId() string { @@ -19737,7 +20885,7 @@ type RestockData struct { func (x *RestockData) Reset() { *x = RestockData{} - mi := &file_product_proto_msgTypes[404] + mi := &file_product_proto_msgTypes[429] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -19749,7 +20897,7 @@ func (x *RestockData) String() string { func (*RestockData) ProtoMessage() {} func (x *RestockData) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[404] + mi := &file_product_proto_msgTypes[429] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -19762,7 +20910,7 @@ func (x *RestockData) ProtoReflect() protoreflect.Message { // Deprecated: Use RestockData.ProtoReflect.Descriptor instead. func (*RestockData) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{404} + return file_product_proto_rawDescGZIP(), []int{429} } func (x *RestockData) GetLastRestockDate() string { @@ -19783,7 +20931,7 @@ type StorageMetadata struct { func (x *StorageMetadata) Reset() { *x = StorageMetadata{} - mi := &file_product_proto_msgTypes[405] + mi := &file_product_proto_msgTypes[430] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -19795,7 +20943,7 @@ func (x *StorageMetadata) String() string { func (*StorageMetadata) ProtoMessage() {} func (x *StorageMetadata) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[405] + mi := &file_product_proto_msgTypes[430] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -19808,7 +20956,7 @@ func (x *StorageMetadata) ProtoReflect() protoreflect.Message { // Deprecated: Use StorageMetadata.ProtoReflect.Descriptor instead. func (*StorageMetadata) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{405} + return file_product_proto_rawDescGZIP(), []int{430} } func (x *StorageMetadata) GetCapacity() int32 { @@ -19842,7 +20990,7 @@ type StorageCategoryInfo struct { func (x *StorageCategoryInfo) Reset() { *x = StorageCategoryInfo{} - mi := &file_product_proto_msgTypes[406] + mi := &file_product_proto_msgTypes[431] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -19854,7 +21002,7 @@ func (x *StorageCategoryInfo) String() string { func (*StorageCategoryInfo) ProtoMessage() {} func (x *StorageCategoryInfo) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[406] + mi := &file_product_proto_msgTypes[431] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -19867,7 +21015,7 @@ func (x *StorageCategoryInfo) ProtoReflect() protoreflect.Message { // Deprecated: Use StorageCategoryInfo.ProtoReflect.Descriptor instead. func (*StorageCategoryInfo) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{406} + return file_product_proto_rawDescGZIP(), []int{431} } func (x *StorageCategoryInfo) GetKind() CategoryKind { @@ -19895,7 +21043,7 @@ type NestedTypeB struct { func (x *NestedTypeB) Reset() { *x = NestedTypeB{} - mi := &file_product_proto_msgTypes[407] + mi := &file_product_proto_msgTypes[432] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -19907,7 +21055,7 @@ func (x *NestedTypeB) String() string { func (*NestedTypeB) ProtoMessage() {} func (x *NestedTypeB) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[407] + mi := &file_product_proto_msgTypes[432] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -19920,7 +21068,7 @@ func (x *NestedTypeB) ProtoReflect() protoreflect.Message { // Deprecated: Use NestedTypeB.ProtoReflect.Descriptor instead. func (*NestedTypeB) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{407} + return file_product_proto_rawDescGZIP(), []int{432} } func (x *NestedTypeB) GetId() string { @@ -19954,7 +21102,7 @@ type NestedTypeC struct { func (x *NestedTypeC) Reset() { *x = NestedTypeC{} - mi := &file_product_proto_msgTypes[408] + mi := &file_product_proto_msgTypes[433] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -19966,7 +21114,7 @@ func (x *NestedTypeC) String() string { func (*NestedTypeC) ProtoMessage() {} func (x *NestedTypeC) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[408] + mi := &file_product_proto_msgTypes[433] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -19979,7 +21127,7 @@ func (x *NestedTypeC) ProtoReflect() protoreflect.Message { // Deprecated: Use NestedTypeC.ProtoReflect.Descriptor instead. func (*NestedTypeC) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{408} + return file_product_proto_rawDescGZIP(), []int{433} } func (x *NestedTypeC) GetId() string { @@ -20008,7 +21156,7 @@ type FilterType struct { func (x *FilterType) Reset() { *x = FilterType{} - mi := &file_product_proto_msgTypes[409] + mi := &file_product_proto_msgTypes[434] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -20020,7 +21168,7 @@ func (x *FilterType) String() string { func (*FilterType) ProtoMessage() {} func (x *FilterType) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[409] + mi := &file_product_proto_msgTypes[434] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -20033,7 +21181,7 @@ func (x *FilterType) ProtoReflect() protoreflect.Message { // Deprecated: Use FilterType.ProtoReflect.Descriptor instead. func (*FilterType) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{409} + return file_product_proto_rawDescGZIP(), []int{434} } func (x *FilterType) GetName() string { @@ -20074,7 +21222,7 @@ type Pagination struct { func (x *Pagination) Reset() { *x = Pagination{} - mi := &file_product_proto_msgTypes[410] + mi := &file_product_proto_msgTypes[435] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -20086,7 +21234,7 @@ func (x *Pagination) String() string { func (*Pagination) ProtoMessage() {} func (x *Pagination) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[410] + mi := &file_product_proto_msgTypes[435] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -20099,7 +21247,7 @@ func (x *Pagination) ProtoReflect() protoreflect.Message { // Deprecated: Use Pagination.ProtoReflect.Descriptor instead. func (*Pagination) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{410} + return file_product_proto_rawDescGZIP(), []int{435} } func (x *Pagination) GetPage() int32 { @@ -20127,7 +21275,7 @@ type OrderLineInput struct { func (x *OrderLineInput) Reset() { *x = OrderLineInput{} - mi := &file_product_proto_msgTypes[411] + mi := &file_product_proto_msgTypes[436] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -20139,7 +21287,7 @@ func (x *OrderLineInput) String() string { func (*OrderLineInput) ProtoMessage() {} func (x *OrderLineInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[411] + mi := &file_product_proto_msgTypes[436] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -20152,7 +21300,7 @@ func (x *OrderLineInput) ProtoReflect() protoreflect.Message { // Deprecated: Use OrderLineInput.ProtoReflect.Descriptor instead. func (*OrderLineInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{411} + return file_product_proto_rawDescGZIP(), []int{436} } func (x *OrderLineInput) GetProductId() string { @@ -20187,7 +21335,7 @@ type OrderLine struct { func (x *OrderLine) Reset() { *x = OrderLine{} - mi := &file_product_proto_msgTypes[412] + mi := &file_product_proto_msgTypes[437] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -20199,7 +21347,7 @@ func (x *OrderLine) String() string { func (*OrderLine) ProtoMessage() {} func (x *OrderLine) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[412] + mi := &file_product_proto_msgTypes[437] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -20212,7 +21360,7 @@ func (x *OrderLine) ProtoReflect() protoreflect.Message { // Deprecated: Use OrderLine.ProtoReflect.Descriptor instead. func (*OrderLine) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{412} + return file_product_proto_rawDescGZIP(), []int{437} } func (x *OrderLine) GetProductId() string { @@ -20248,7 +21396,7 @@ type Subcategory struct { func (x *Subcategory) Reset() { *x = Subcategory{} - mi := &file_product_proto_msgTypes[413] + mi := &file_product_proto_msgTypes[438] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -20260,7 +21408,7 @@ func (x *Subcategory) String() string { func (*Subcategory) ProtoMessage() {} func (x *Subcategory) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[413] + mi := &file_product_proto_msgTypes[438] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -20273,7 +21421,7 @@ func (x *Subcategory) ProtoReflect() protoreflect.Message { // Deprecated: Use Subcategory.ProtoReflect.Descriptor instead. func (*Subcategory) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{413} + return file_product_proto_rawDescGZIP(), []int{438} } func (x *Subcategory) GetId() string { @@ -20317,7 +21465,7 @@ type CategoryMetrics struct { func (x *CategoryMetrics) Reset() { *x = CategoryMetrics{} - mi := &file_product_proto_msgTypes[414] + mi := &file_product_proto_msgTypes[439] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -20329,7 +21477,7 @@ func (x *CategoryMetrics) String() string { func (*CategoryMetrics) ProtoMessage() {} func (x *CategoryMetrics) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[414] + mi := &file_product_proto_msgTypes[439] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -20342,7 +21490,7 @@ func (x *CategoryMetrics) ProtoReflect() protoreflect.Message { // Deprecated: Use CategoryMetrics.ProtoReflect.Descriptor instead. func (*CategoryMetrics) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{414} + return file_product_proto_rawDescGZIP(), []int{439} } func (x *CategoryMetrics) GetId() string { @@ -20394,7 +21542,7 @@ type Cat struct { func (x *Cat) Reset() { *x = Cat{} - mi := &file_product_proto_msgTypes[415] + mi := &file_product_proto_msgTypes[440] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -20406,7 +21554,7 @@ func (x *Cat) String() string { func (*Cat) ProtoMessage() {} func (x *Cat) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[415] + mi := &file_product_proto_msgTypes[440] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -20419,7 +21567,7 @@ func (x *Cat) ProtoReflect() protoreflect.Message { // Deprecated: Use Cat.ProtoReflect.Descriptor instead. func (*Cat) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{415} + return file_product_proto_rawDescGZIP(), []int{440} } func (x *Cat) GetId() string { @@ -20478,7 +21626,7 @@ type Dog struct { func (x *Dog) Reset() { *x = Dog{} - mi := &file_product_proto_msgTypes[416] + mi := &file_product_proto_msgTypes[441] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -20490,7 +21638,7 @@ func (x *Dog) String() string { func (*Dog) ProtoMessage() {} func (x *Dog) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[416] + mi := &file_product_proto_msgTypes[441] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -20503,7 +21651,7 @@ func (x *Dog) ProtoReflect() protoreflect.Message { // Deprecated: Use Dog.ProtoReflect.Descriptor instead. func (*Dog) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{416} + return file_product_proto_rawDescGZIP(), []int{441} } func (x *Dog) GetId() string { @@ -20560,7 +21708,7 @@ type Owner struct { func (x *Owner) Reset() { *x = Owner{} - mi := &file_product_proto_msgTypes[417] + mi := &file_product_proto_msgTypes[442] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -20572,7 +21720,7 @@ func (x *Owner) String() string { func (*Owner) ProtoMessage() {} func (x *Owner) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[417] + mi := &file_product_proto_msgTypes[442] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -20585,7 +21733,7 @@ func (x *Owner) ProtoReflect() protoreflect.Message { // Deprecated: Use Owner.ProtoReflect.Descriptor instead. func (*Owner) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{417} + return file_product_proto_rawDescGZIP(), []int{442} } func (x *Owner) GetId() string { @@ -20627,7 +21775,7 @@ type ContactInfo struct { func (x *ContactInfo) Reset() { *x = ContactInfo{} - mi := &file_product_proto_msgTypes[418] + mi := &file_product_proto_msgTypes[443] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -20639,7 +21787,7 @@ func (x *ContactInfo) String() string { func (*ContactInfo) ProtoMessage() {} func (x *ContactInfo) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[418] + mi := &file_product_proto_msgTypes[443] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -20652,7 +21800,7 @@ func (x *ContactInfo) ProtoReflect() protoreflect.Message { // Deprecated: Use ContactInfo.ProtoReflect.Descriptor instead. func (*ContactInfo) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{418} + return file_product_proto_rawDescGZIP(), []int{443} } func (x *ContactInfo) GetEmail() string { @@ -20688,7 +21836,7 @@ type Address struct { func (x *Address) Reset() { *x = Address{} - mi := &file_product_proto_msgTypes[419] + mi := &file_product_proto_msgTypes[444] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -20700,7 +21848,7 @@ func (x *Address) String() string { func (*Address) ProtoMessage() {} func (x *Address) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[419] + mi := &file_product_proto_msgTypes[444] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -20713,7 +21861,7 @@ func (x *Address) ProtoReflect() protoreflect.Message { // Deprecated: Use Address.ProtoReflect.Descriptor instead. func (*Address) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{419} + return file_product_proto_rawDescGZIP(), []int{444} } func (x *Address) GetStreet() string { @@ -20756,7 +21904,7 @@ type CatBreed struct { func (x *CatBreed) Reset() { *x = CatBreed{} - mi := &file_product_proto_msgTypes[420] + mi := &file_product_proto_msgTypes[445] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -20768,7 +21916,7 @@ func (x *CatBreed) String() string { func (*CatBreed) ProtoMessage() {} func (x *CatBreed) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[420] + mi := &file_product_proto_msgTypes[445] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -20781,7 +21929,7 @@ func (x *CatBreed) ProtoReflect() protoreflect.Message { // Deprecated: Use CatBreed.ProtoReflect.Descriptor instead. func (*CatBreed) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{420} + return file_product_proto_rawDescGZIP(), []int{445} } func (x *CatBreed) GetId() string { @@ -20824,7 +21972,7 @@ type DogBreed struct { func (x *DogBreed) Reset() { *x = DogBreed{} - mi := &file_product_proto_msgTypes[421] + mi := &file_product_proto_msgTypes[446] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -20836,7 +21984,7 @@ func (x *DogBreed) String() string { func (*DogBreed) ProtoMessage() {} func (x *DogBreed) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[421] + mi := &file_product_proto_msgTypes[446] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -20849,7 +21997,7 @@ func (x *DogBreed) ProtoReflect() protoreflect.Message { // Deprecated: Use DogBreed.ProtoReflect.Descriptor instead. func (*DogBreed) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{421} + return file_product_proto_rawDescGZIP(), []int{446} } func (x *DogBreed) GetId() string { @@ -20891,7 +22039,7 @@ type BreedCharacteristics struct { func (x *BreedCharacteristics) Reset() { *x = BreedCharacteristics{} - mi := &file_product_proto_msgTypes[422] + mi := &file_product_proto_msgTypes[447] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -20903,7 +22051,7 @@ func (x *BreedCharacteristics) String() string { func (*BreedCharacteristics) ProtoMessage() {} func (x *BreedCharacteristics) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[422] + mi := &file_product_proto_msgTypes[447] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -20916,7 +22064,7 @@ func (x *BreedCharacteristics) ProtoReflect() protoreflect.Message { // Deprecated: Use BreedCharacteristics.ProtoReflect.Descriptor instead. func (*BreedCharacteristics) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{422} + return file_product_proto_rawDescGZIP(), []int{447} } func (x *BreedCharacteristics) GetSize() string { @@ -20953,7 +22101,7 @@ type StorageItem struct { func (x *StorageItem) Reset() { *x = StorageItem{} - mi := &file_product_proto_msgTypes[423] + mi := &file_product_proto_msgTypes[448] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -20965,7 +22113,7 @@ func (x *StorageItem) String() string { func (*StorageItem) ProtoMessage() {} func (x *StorageItem) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[423] + mi := &file_product_proto_msgTypes[448] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -20978,7 +22126,7 @@ func (x *StorageItem) ProtoReflect() protoreflect.Message { // Deprecated: Use StorageItem.ProtoReflect.Descriptor instead. func (*StorageItem) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{423} + return file_product_proto_rawDescGZIP(), []int{448} } func (x *StorageItem) GetInstance() isStorageItem_Instance { @@ -21036,7 +22184,7 @@ type PalletItem struct { func (x *PalletItem) Reset() { *x = PalletItem{} - mi := &file_product_proto_msgTypes[424] + mi := &file_product_proto_msgTypes[449] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -21048,7 +22196,7 @@ func (x *PalletItem) String() string { func (*PalletItem) ProtoMessage() {} func (x *PalletItem) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[424] + mi := &file_product_proto_msgTypes[449] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -21061,7 +22209,7 @@ func (x *PalletItem) ProtoReflect() protoreflect.Message { // Deprecated: Use PalletItem.ProtoReflect.Descriptor instead. func (*PalletItem) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{424} + return file_product_proto_rawDescGZIP(), []int{449} } func (x *PalletItem) GetId() string { @@ -21120,7 +22268,7 @@ type ContainerItem struct { func (x *ContainerItem) Reset() { *x = ContainerItem{} - mi := &file_product_proto_msgTypes[425] + mi := &file_product_proto_msgTypes[450] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -21132,7 +22280,7 @@ func (x *ContainerItem) String() string { func (*ContainerItem) ProtoMessage() {} func (x *ContainerItem) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[425] + mi := &file_product_proto_msgTypes[450] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -21145,7 +22293,7 @@ func (x *ContainerItem) ProtoReflect() protoreflect.Message { // Deprecated: Use ContainerItem.ProtoReflect.Descriptor instead. func (*ContainerItem) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{425} + return file_product_proto_rawDescGZIP(), []int{450} } func (x *ContainerItem) GetId() string { @@ -21201,7 +22349,7 @@ type ItemHandler struct { func (x *ItemHandler) Reset() { *x = ItemHandler{} - mi := &file_product_proto_msgTypes[426] + mi := &file_product_proto_msgTypes[451] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -21213,7 +22361,7 @@ func (x *ItemHandler) String() string { func (*ItemHandler) ProtoMessage() {} func (x *ItemHandler) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[426] + mi := &file_product_proto_msgTypes[451] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -21226,7 +22374,7 @@ func (x *ItemHandler) ProtoReflect() protoreflect.Message { // Deprecated: Use ItemHandler.ProtoReflect.Descriptor instead. func (*ItemHandler) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{426} + return file_product_proto_rawDescGZIP(), []int{451} } func (x *ItemHandler) GetId() string { @@ -21261,7 +22409,7 @@ type PalletSpecs struct { func (x *PalletSpecs) Reset() { *x = PalletSpecs{} - mi := &file_product_proto_msgTypes[427] + mi := &file_product_proto_msgTypes[452] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -21273,7 +22421,7 @@ func (x *PalletSpecs) String() string { func (*PalletSpecs) ProtoMessage() {} func (x *PalletSpecs) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[427] + mi := &file_product_proto_msgTypes[452] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -21286,7 +22434,7 @@ func (x *PalletSpecs) ProtoReflect() protoreflect.Message { // Deprecated: Use PalletSpecs.ProtoReflect.Descriptor instead. func (*PalletSpecs) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{427} + return file_product_proto_rawDescGZIP(), []int{452} } func (x *PalletSpecs) GetName() string { @@ -21321,7 +22469,7 @@ type ContainerSpecs struct { func (x *ContainerSpecs) Reset() { *x = ContainerSpecs{} - mi := &file_product_proto_msgTypes[428] + mi := &file_product_proto_msgTypes[453] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -21333,7 +22481,7 @@ func (x *ContainerSpecs) String() string { func (*ContainerSpecs) ProtoMessage() {} func (x *ContainerSpecs) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[428] + mi := &file_product_proto_msgTypes[453] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -21346,7 +22494,7 @@ func (x *ContainerSpecs) ProtoReflect() protoreflect.Message { // Deprecated: Use ContainerSpecs.ProtoReflect.Descriptor instead. func (*ContainerSpecs) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{428} + return file_product_proto_rawDescGZIP(), []int{453} } func (x *ContainerSpecs) GetName() string { @@ -21381,7 +22529,7 @@ type Dimensions struct { func (x *Dimensions) Reset() { *x = Dimensions{} - mi := &file_product_proto_msgTypes[429] + mi := &file_product_proto_msgTypes[454] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -21393,7 +22541,7 @@ func (x *Dimensions) String() string { func (*Dimensions) ProtoMessage() {} func (x *Dimensions) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[429] + mi := &file_product_proto_msgTypes[454] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -21406,7 +22554,7 @@ func (x *Dimensions) ProtoReflect() protoreflect.Message { // Deprecated: Use Dimensions.ProtoReflect.Descriptor instead. func (*Dimensions) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{429} + return file_product_proto_rawDescGZIP(), []int{454} } func (x *Dimensions) GetLength() float64 { @@ -21443,7 +22591,7 @@ type StorageOperationResult struct { func (x *StorageOperationResult) Reset() { *x = StorageOperationResult{} - mi := &file_product_proto_msgTypes[430] + mi := &file_product_proto_msgTypes[455] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -21455,7 +22603,7 @@ func (x *StorageOperationResult) String() string { func (*StorageOperationResult) ProtoMessage() {} func (x *StorageOperationResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[430] + mi := &file_product_proto_msgTypes[455] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -21468,7 +22616,7 @@ func (x *StorageOperationResult) ProtoReflect() protoreflect.Message { // Deprecated: Use StorageOperationResult.ProtoReflect.Descriptor instead. func (*StorageOperationResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{430} + return file_product_proto_rawDescGZIP(), []int{455} } func (x *StorageOperationResult) GetValue() isStorageOperationResult_Value { @@ -21522,7 +22670,7 @@ type StorageSuccess struct { func (x *StorageSuccess) Reset() { *x = StorageSuccess{} - mi := &file_product_proto_msgTypes[431] + mi := &file_product_proto_msgTypes[456] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -21534,7 +22682,7 @@ func (x *StorageSuccess) String() string { func (*StorageSuccess) ProtoMessage() {} func (x *StorageSuccess) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[431] + mi := &file_product_proto_msgTypes[456] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -21547,7 +22695,7 @@ func (x *StorageSuccess) ProtoReflect() protoreflect.Message { // Deprecated: Use StorageSuccess.ProtoReflect.Descriptor instead. func (*StorageSuccess) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{431} + return file_product_proto_rawDescGZIP(), []int{456} } func (x *StorageSuccess) GetMessage() string { @@ -21574,7 +22722,7 @@ type StorageFailure struct { func (x *StorageFailure) Reset() { *x = StorageFailure{} - mi := &file_product_proto_msgTypes[432] + mi := &file_product_proto_msgTypes[457] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -21586,7 +22734,7 @@ func (x *StorageFailure) String() string { func (*StorageFailure) ProtoMessage() {} func (x *StorageFailure) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[432] + mi := &file_product_proto_msgTypes[457] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -21599,7 +22747,7 @@ func (x *StorageFailure) ProtoReflect() protoreflect.Message { // Deprecated: Use StorageFailure.ProtoReflect.Descriptor instead. func (*StorageFailure) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{432} + return file_product_proto_rawDescGZIP(), []int{457} } func (x *StorageFailure) GetMessage() string { @@ -21626,7 +22774,7 @@ type SecuritySetup struct { func (x *SecuritySetup) Reset() { *x = SecuritySetup{} - mi := &file_product_proto_msgTypes[433] + mi := &file_product_proto_msgTypes[458] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -21638,7 +22786,7 @@ func (x *SecuritySetup) String() string { func (*SecuritySetup) ProtoMessage() {} func (x *SecuritySetup) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[433] + mi := &file_product_proto_msgTypes[458] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -21651,7 +22799,7 @@ func (x *SecuritySetup) ProtoReflect() protoreflect.Message { // Deprecated: Use SecuritySetup.ProtoReflect.Descriptor instead. func (*SecuritySetup) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{433} + return file_product_proto_rawDescGZIP(), []int{458} } func (x *SecuritySetup) GetSecurityLevel() string { @@ -21678,7 +22826,7 @@ type ActionSuccess struct { func (x *ActionSuccess) Reset() { *x = ActionSuccess{} - mi := &file_product_proto_msgTypes[434] + mi := &file_product_proto_msgTypes[459] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -21690,7 +22838,7 @@ func (x *ActionSuccess) String() string { func (*ActionSuccess) ProtoMessage() {} func (x *ActionSuccess) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[434] + mi := &file_product_proto_msgTypes[459] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -21703,7 +22851,7 @@ func (x *ActionSuccess) ProtoReflect() protoreflect.Message { // Deprecated: Use ActionSuccess.ProtoReflect.Descriptor instead. func (*ActionSuccess) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{434} + return file_product_proto_rawDescGZIP(), []int{459} } func (x *ActionSuccess) GetMessage() string { @@ -21730,7 +22878,7 @@ type ActionError struct { func (x *ActionError) Reset() { *x = ActionError{} - mi := &file_product_proto_msgTypes[435] + mi := &file_product_proto_msgTypes[460] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -21742,7 +22890,7 @@ func (x *ActionError) String() string { func (*ActionError) ProtoMessage() {} func (x *ActionError) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[435] + mi := &file_product_proto_msgTypes[460] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -21755,7 +22903,7 @@ func (x *ActionError) ProtoReflect() protoreflect.Message { // Deprecated: Use ActionError.ProtoReflect.Descriptor instead. func (*ActionError) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{435} + return file_product_proto_rawDescGZIP(), []int{460} } func (x *ActionError) GetMessage() string { @@ -21784,7 +22932,7 @@ type TestDetails struct { func (x *TestDetails) Reset() { *x = TestDetails{} - mi := &file_product_proto_msgTypes[436] + mi := &file_product_proto_msgTypes[461] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -21796,7 +22944,7 @@ func (x *TestDetails) String() string { func (*TestDetails) ProtoMessage() {} func (x *TestDetails) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[436] + mi := &file_product_proto_msgTypes[461] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -21809,7 +22957,7 @@ func (x *TestDetails) ProtoReflect() protoreflect.Message { // Deprecated: Use TestDetails.ProtoReflect.Descriptor instead. func (*TestDetails) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{436} + return file_product_proto_rawDescGZIP(), []int{461} } func (x *TestDetails) GetId() string { @@ -21850,7 +22998,7 @@ type CategoryInput struct { func (x *CategoryInput) Reset() { *x = CategoryInput{} - mi := &file_product_proto_msgTypes[437] + mi := &file_product_proto_msgTypes[462] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -21862,7 +23010,7 @@ func (x *CategoryInput) String() string { func (*CategoryInput) ProtoMessage() {} func (x *CategoryInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[437] + mi := &file_product_proto_msgTypes[462] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -21875,7 +23023,7 @@ func (x *CategoryInput) ProtoReflect() protoreflect.Message { // Deprecated: Use CategoryInput.ProtoReflect.Descriptor instead. func (*CategoryInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{437} + return file_product_proto_rawDescGZIP(), []int{462} } func (x *CategoryInput) GetName() string { @@ -21904,7 +23052,7 @@ type ProductCountFilter struct { func (x *ProductCountFilter) Reset() { *x = ProductCountFilter{} - mi := &file_product_proto_msgTypes[438] + mi := &file_product_proto_msgTypes[463] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -21916,7 +23064,7 @@ func (x *ProductCountFilter) String() string { func (*ProductCountFilter) ProtoMessage() {} func (x *ProductCountFilter) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[438] + mi := &file_product_proto_msgTypes[463] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -21929,7 +23077,7 @@ func (x *ProductCountFilter) ProtoReflect() protoreflect.Message { // Deprecated: Use ProductCountFilter.ProtoReflect.Descriptor instead. func (*ProductCountFilter) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{438} + return file_product_proto_rawDescGZIP(), []int{463} } func (x *ProductCountFilter) GetMinPrice() *wrapperspb.DoubleValue { @@ -21973,7 +23121,7 @@ type SubcategoryItemFilter struct { func (x *SubcategoryItemFilter) Reset() { *x = SubcategoryItemFilter{} - mi := &file_product_proto_msgTypes[439] + mi := &file_product_proto_msgTypes[464] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -21985,7 +23133,7 @@ func (x *SubcategoryItemFilter) String() string { func (*SubcategoryItemFilter) ProtoMessage() {} func (x *SubcategoryItemFilter) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[439] + mi := &file_product_proto_msgTypes[464] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -21998,7 +23146,7 @@ func (x *SubcategoryItemFilter) ProtoReflect() protoreflect.Message { // Deprecated: Use SubcategoryItemFilter.ProtoReflect.Descriptor instead. func (*SubcategoryItemFilter) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{439} + return file_product_proto_rawDescGZIP(), []int{464} } func (x *SubcategoryItemFilter) GetMinPrice() *wrapperspb.DoubleValue { @@ -22047,7 +23195,7 @@ type ShippingEstimateInput struct { func (x *ShippingEstimateInput) Reset() { *x = ShippingEstimateInput{} - mi := &file_product_proto_msgTypes[440] + mi := &file_product_proto_msgTypes[465] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -22059,7 +23207,7 @@ func (x *ShippingEstimateInput) String() string { func (*ShippingEstimateInput) ProtoMessage() {} func (x *ShippingEstimateInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[440] + mi := &file_product_proto_msgTypes[465] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -22072,7 +23220,7 @@ func (x *ShippingEstimateInput) ProtoReflect() protoreflect.Message { // Deprecated: Use ShippingEstimateInput.ProtoReflect.Descriptor instead. func (*ShippingEstimateInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{440} + return file_product_proto_rawDescGZIP(), []int{465} } func (x *ShippingEstimateInput) GetDestination() ShippingDestination { @@ -22105,7 +23253,7 @@ type ListOfAuthorFilter_List struct { func (x *ListOfAuthorFilter_List) Reset() { *x = ListOfAuthorFilter_List{} - mi := &file_product_proto_msgTypes[441] + mi := &file_product_proto_msgTypes[466] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -22117,7 +23265,7 @@ func (x *ListOfAuthorFilter_List) String() string { func (*ListOfAuthorFilter_List) ProtoMessage() {} func (x *ListOfAuthorFilter_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[441] + mi := &file_product_proto_msgTypes[466] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -22149,7 +23297,7 @@ type ListOfAuthorInput_List struct { func (x *ListOfAuthorInput_List) Reset() { *x = ListOfAuthorInput_List{} - mi := &file_product_proto_msgTypes[442] + mi := &file_product_proto_msgTypes[467] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -22161,7 +23309,7 @@ func (x *ListOfAuthorInput_List) String() string { func (*ListOfAuthorInput_List) ProtoMessage() {} func (x *ListOfAuthorInput_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[442] + mi := &file_product_proto_msgTypes[467] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -22193,7 +23341,7 @@ type ListOfBlogPost_List struct { func (x *ListOfBlogPost_List) Reset() { *x = ListOfBlogPost_List{} - mi := &file_product_proto_msgTypes[443] + mi := &file_product_proto_msgTypes[468] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -22205,7 +23353,7 @@ func (x *ListOfBlogPost_List) String() string { func (*ListOfBlogPost_List) ProtoMessage() {} func (x *ListOfBlogPost_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[443] + mi := &file_product_proto_msgTypes[468] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -22237,7 +23385,7 @@ type ListOfBlogPostFilter_List struct { func (x *ListOfBlogPostFilter_List) Reset() { *x = ListOfBlogPostFilter_List{} - mi := &file_product_proto_msgTypes[444] + mi := &file_product_proto_msgTypes[469] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -22249,7 +23397,7 @@ func (x *ListOfBlogPostFilter_List) String() string { func (*ListOfBlogPostFilter_List) ProtoMessage() {} func (x *ListOfBlogPostFilter_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[444] + mi := &file_product_proto_msgTypes[469] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -22281,7 +23429,7 @@ type ListOfBlogPostInput_List struct { func (x *ListOfBlogPostInput_List) Reset() { *x = ListOfBlogPostInput_List{} - mi := &file_product_proto_msgTypes[445] + mi := &file_product_proto_msgTypes[470] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -22293,7 +23441,7 @@ func (x *ListOfBlogPostInput_List) String() string { func (*ListOfBlogPostInput_List) ProtoMessage() {} func (x *ListOfBlogPostInput_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[445] + mi := &file_product_proto_msgTypes[470] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -22325,7 +23473,7 @@ type ListOfBoolean_List struct { func (x *ListOfBoolean_List) Reset() { *x = ListOfBoolean_List{} - mi := &file_product_proto_msgTypes[446] + mi := &file_product_proto_msgTypes[471] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -22337,7 +23485,7 @@ func (x *ListOfBoolean_List) String() string { func (*ListOfBoolean_List) ProtoMessage() {} func (x *ListOfBoolean_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[446] + mi := &file_product_proto_msgTypes[471] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -22369,7 +23517,7 @@ type ListOfCategory_List struct { func (x *ListOfCategory_List) Reset() { *x = ListOfCategory_List{} - mi := &file_product_proto_msgTypes[447] + mi := &file_product_proto_msgTypes[472] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -22381,7 +23529,7 @@ func (x *ListOfCategory_List) String() string { func (*ListOfCategory_List) ProtoMessage() {} func (x *ListOfCategory_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[447] + mi := &file_product_proto_msgTypes[472] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -22413,7 +23561,7 @@ type ListOfCategoryInput_List struct { func (x *ListOfCategoryInput_List) Reset() { *x = ListOfCategoryInput_List{} - mi := &file_product_proto_msgTypes[448] + mi := &file_product_proto_msgTypes[473] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -22425,7 +23573,7 @@ func (x *ListOfCategoryInput_List) String() string { func (*ListOfCategoryInput_List) ProtoMessage() {} func (x *ListOfCategoryInput_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[448] + mi := &file_product_proto_msgTypes[473] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -22457,7 +23605,7 @@ type ListOfConditionsInput_List struct { func (x *ListOfConditionsInput_List) Reset() { *x = ListOfConditionsInput_List{} - mi := &file_product_proto_msgTypes[449] + mi := &file_product_proto_msgTypes[474] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -22469,7 +23617,7 @@ func (x *ListOfConditionsInput_List) String() string { func (*ListOfConditionsInput_List) ProtoMessage() {} func (x *ListOfConditionsInput_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[449] + mi := &file_product_proto_msgTypes[474] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -22501,7 +23649,7 @@ type ListOfFloat_List struct { func (x *ListOfFloat_List) Reset() { *x = ListOfFloat_List{} - mi := &file_product_proto_msgTypes[450] + mi := &file_product_proto_msgTypes[475] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -22513,7 +23661,7 @@ func (x *ListOfFloat_List) String() string { func (*ListOfFloat_List) ProtoMessage() {} func (x *ListOfFloat_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[450] + mi := &file_product_proto_msgTypes[475] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -22536,6 +23684,50 @@ func (x *ListOfFloat_List) GetItems() []float64 { return nil } +type ListOfInt_List struct { + state protoimpl.MessageState `protogen:"open.v1"` + Items []int32 `protobuf:"varint,1,rep,packed,name=items,proto3" json:"items,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListOfInt_List) Reset() { + *x = ListOfInt_List{} + mi := &file_product_proto_msgTypes[476] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListOfInt_List) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListOfInt_List) ProtoMessage() {} + +func (x *ListOfInt_List) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[476] + 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 ListOfInt_List.ProtoReflect.Descriptor instead. +func (*ListOfInt_List) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{10, 0} +} + +func (x *ListOfInt_List) GetItems() []int32 { + 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"` @@ -22545,7 +23737,7 @@ type ListOfListOfCategory_List struct { func (x *ListOfListOfCategory_List) Reset() { *x = ListOfListOfCategory_List{} - mi := &file_product_proto_msgTypes[451] + mi := &file_product_proto_msgTypes[477] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -22557,7 +23749,7 @@ func (x *ListOfListOfCategory_List) String() string { func (*ListOfListOfCategory_List) ProtoMessage() {} func (x *ListOfListOfCategory_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[451] + mi := &file_product_proto_msgTypes[477] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -22570,7 +23762,7 @@ func (x *ListOfListOfCategory_List) ProtoReflect() protoreflect.Message { // Deprecated: Use ListOfListOfCategory_List.ProtoReflect.Descriptor instead. func (*ListOfListOfCategory_List) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{10, 0} + return file_product_proto_rawDescGZIP(), []int{11, 0} } func (x *ListOfListOfCategory_List) GetItems() []*ListOfCategory { @@ -22589,7 +23781,7 @@ type ListOfListOfCategoryInput_List struct { func (x *ListOfListOfCategoryInput_List) Reset() { *x = ListOfListOfCategoryInput_List{} - mi := &file_product_proto_msgTypes[452] + mi := &file_product_proto_msgTypes[478] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -22601,7 +23793,7 @@ func (x *ListOfListOfCategoryInput_List) String() string { func (*ListOfListOfCategoryInput_List) ProtoMessage() {} func (x *ListOfListOfCategoryInput_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[452] + mi := &file_product_proto_msgTypes[478] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -22614,7 +23806,7 @@ func (x *ListOfListOfCategoryInput_List) ProtoReflect() protoreflect.Message { // Deprecated: Use ListOfListOfCategoryInput_List.ProtoReflect.Descriptor instead. func (*ListOfListOfCategoryInput_List) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{11, 0} + return file_product_proto_rawDescGZIP(), []int{12, 0} } func (x *ListOfListOfCategoryInput_List) GetItems() []*ListOfCategoryInput { @@ -22633,7 +23825,7 @@ type ListOfListOfString_List struct { func (x *ListOfListOfString_List) Reset() { *x = ListOfListOfString_List{} - mi := &file_product_proto_msgTypes[453] + mi := &file_product_proto_msgTypes[479] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -22645,7 +23837,7 @@ func (x *ListOfListOfString_List) String() string { func (*ListOfListOfString_List) ProtoMessage() {} func (x *ListOfListOfString_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[453] + mi := &file_product_proto_msgTypes[479] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -22658,7 +23850,7 @@ func (x *ListOfListOfString_List) ProtoReflect() protoreflect.Message { // Deprecated: Use ListOfListOfString_List.ProtoReflect.Descriptor instead. func (*ListOfListOfString_List) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{12, 0} + return file_product_proto_rawDescGZIP(), []int{13, 0} } func (x *ListOfListOfString_List) GetItems() []*ListOfString { @@ -22677,7 +23869,7 @@ type ListOfListOfUser_List struct { func (x *ListOfListOfUser_List) Reset() { *x = ListOfListOfUser_List{} - mi := &file_product_proto_msgTypes[454] + mi := &file_product_proto_msgTypes[480] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -22689,7 +23881,7 @@ func (x *ListOfListOfUser_List) String() string { func (*ListOfListOfUser_List) ProtoMessage() {} func (x *ListOfListOfUser_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[454] + mi := &file_product_proto_msgTypes[480] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -22702,7 +23894,7 @@ func (x *ListOfListOfUser_List) ProtoReflect() protoreflect.Message { // Deprecated: Use ListOfListOfUser_List.ProtoReflect.Descriptor instead. func (*ListOfListOfUser_List) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{13, 0} + return file_product_proto_rawDescGZIP(), []int{14, 0} } func (x *ListOfListOfUser_List) GetItems() []*ListOfUser { @@ -22719,21 +23911,153 @@ type ListOfListOfUserInput_List struct { sizeCache protoimpl.SizeCache } -func (x *ListOfListOfUserInput_List) Reset() { - *x = ListOfListOfUserInput_List{} - mi := &file_product_proto_msgTypes[455] +func (x *ListOfListOfUserInput_List) Reset() { + *x = ListOfListOfUserInput_List{} + mi := &file_product_proto_msgTypes[481] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListOfListOfUserInput_List) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListOfListOfUserInput_List) ProtoMessage() {} + +func (x *ListOfListOfUserInput_List) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[481] + 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 ListOfListOfUserInput_List.ProtoReflect.Descriptor instead. +func (*ListOfListOfUserInput_List) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{15, 0} +} + +func (x *ListOfListOfUserInput_List) GetItems() []*ListOfUserInput { + if x != nil { + return x.Items + } + return nil +} + +type ListOfOrderLine_List struct { + state protoimpl.MessageState `protogen:"open.v1"` + Items []*OrderLine `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListOfOrderLine_List) Reset() { + *x = ListOfOrderLine_List{} + mi := &file_product_proto_msgTypes[482] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListOfOrderLine_List) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListOfOrderLine_List) ProtoMessage() {} + +func (x *ListOfOrderLine_List) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[482] + 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 ListOfOrderLine_List.ProtoReflect.Descriptor instead. +func (*ListOfOrderLine_List) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{16, 0} +} + +func (x *ListOfOrderLine_List) GetItems() []*OrderLine { + if x != nil { + return x.Items + } + return nil +} + +type ListOfProduct_List struct { + state protoimpl.MessageState `protogen:"open.v1"` + Items []*Product `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListOfProduct_List) Reset() { + *x = ListOfProduct_List{} + mi := &file_product_proto_msgTypes[483] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListOfProduct_List) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListOfProduct_List) ProtoMessage() {} + +func (x *ListOfProduct_List) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[483] + 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 ListOfProduct_List.ProtoReflect.Descriptor instead. +func (*ListOfProduct_List) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{17, 0} +} + +func (x *ListOfProduct_List) GetItems() []*Product { + if x != nil { + return x.Items + } + return nil +} + +type ListOfStorage_List struct { + state protoimpl.MessageState `protogen:"open.v1"` + Items []*Storage `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListOfStorage_List) Reset() { + *x = ListOfStorage_List{} + mi := &file_product_proto_msgTypes[484] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ListOfListOfUserInput_List) String() string { +func (x *ListOfStorage_List) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListOfListOfUserInput_List) ProtoMessage() {} +func (*ListOfStorage_List) ProtoMessage() {} -func (x *ListOfListOfUserInput_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[455] +func (x *ListOfStorage_List) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[484] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -22744,40 +24068,40 @@ func (x *ListOfListOfUserInput_List) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ListOfListOfUserInput_List.ProtoReflect.Descriptor instead. -func (*ListOfListOfUserInput_List) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{14, 0} +// Deprecated: Use ListOfStorage_List.ProtoReflect.Descriptor instead. +func (*ListOfStorage_List) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{18, 0} } -func (x *ListOfListOfUserInput_List) GetItems() []*ListOfUserInput { +func (x *ListOfStorage_List) GetItems() []*Storage { if x != nil { return x.Items } return nil } -type ListOfOrderLine_List struct { +type ListOfStorageItem_List struct { state protoimpl.MessageState `protogen:"open.v1"` - Items []*OrderLine `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` + Items []*StorageItem `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ListOfOrderLine_List) Reset() { - *x = ListOfOrderLine_List{} - mi := &file_product_proto_msgTypes[456] +func (x *ListOfStorageItem_List) Reset() { + *x = ListOfStorageItem_List{} + mi := &file_product_proto_msgTypes[485] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ListOfOrderLine_List) String() string { +func (x *ListOfStorageItem_List) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListOfOrderLine_List) ProtoMessage() {} +func (*ListOfStorageItem_List) ProtoMessage() {} -func (x *ListOfOrderLine_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[456] +func (x *ListOfStorageItem_List) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[485] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -22788,40 +24112,40 @@ func (x *ListOfOrderLine_List) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ListOfOrderLine_List.ProtoReflect.Descriptor instead. -func (*ListOfOrderLine_List) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{15, 0} +// Deprecated: Use ListOfStorageItem_List.ProtoReflect.Descriptor instead. +func (*ListOfStorageItem_List) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{19, 0} } -func (x *ListOfOrderLine_List) GetItems() []*OrderLine { +func (x *ListOfStorageItem_List) GetItems() []*StorageItem { if x != nil { return x.Items } return nil } -type ListOfProduct_List struct { +type ListOfStorageMetadata_List struct { state protoimpl.MessageState `protogen:"open.v1"` - Items []*Product `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` + Items []*StorageMetadata `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ListOfProduct_List) Reset() { - *x = ListOfProduct_List{} - mi := &file_product_proto_msgTypes[457] +func (x *ListOfStorageMetadata_List) Reset() { + *x = ListOfStorageMetadata_List{} + mi := &file_product_proto_msgTypes[486] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ListOfProduct_List) String() string { +func (x *ListOfStorageMetadata_List) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListOfProduct_List) ProtoMessage() {} +func (*ListOfStorageMetadata_List) ProtoMessage() {} -func (x *ListOfProduct_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[457] +func (x *ListOfStorageMetadata_List) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[486] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -22832,40 +24156,40 @@ func (x *ListOfProduct_List) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ListOfProduct_List.ProtoReflect.Descriptor instead. -func (*ListOfProduct_List) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{16, 0} +// Deprecated: Use ListOfStorageMetadata_List.ProtoReflect.Descriptor instead. +func (*ListOfStorageMetadata_List) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{20, 0} } -func (x *ListOfProduct_List) GetItems() []*Product { +func (x *ListOfStorageMetadata_List) GetItems() []*StorageMetadata { if x != nil { return x.Items } return nil } -type ListOfStorage_List struct { - state protoimpl.MessageState `protogen:"open.v1"` - Items []*Storage `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` +type ListOfStorageOperationResult_List struct { + state protoimpl.MessageState `protogen:"open.v1"` + Items []*StorageOperationResult `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ListOfStorage_List) Reset() { - *x = ListOfStorage_List{} - mi := &file_product_proto_msgTypes[458] +func (x *ListOfStorageOperationResult_List) Reset() { + *x = ListOfStorageOperationResult_List{} + mi := &file_product_proto_msgTypes[487] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ListOfStorage_List) String() string { +func (x *ListOfStorageOperationResult_List) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListOfStorage_List) ProtoMessage() {} +func (*ListOfStorageOperationResult_List) ProtoMessage() {} -func (x *ListOfStorage_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[458] +func (x *ListOfStorageOperationResult_List) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[487] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -22876,12 +24200,12 @@ func (x *ListOfStorage_List) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ListOfStorage_List.ProtoReflect.Descriptor instead. -func (*ListOfStorage_List) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{17, 0} +// Deprecated: Use ListOfStorageOperationResult_List.ProtoReflect.Descriptor instead. +func (*ListOfStorageOperationResult_List) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{21, 0} } -func (x *ListOfStorage_List) GetItems() []*Storage { +func (x *ListOfStorageOperationResult_List) GetItems() []*StorageOperationResult { if x != nil { return x.Items } @@ -22897,7 +24221,7 @@ type ListOfString_List struct { func (x *ListOfString_List) Reset() { *x = ListOfString_List{} - mi := &file_product_proto_msgTypes[459] + mi := &file_product_proto_msgTypes[488] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -22909,7 +24233,7 @@ func (x *ListOfString_List) String() string { func (*ListOfString_List) ProtoMessage() {} func (x *ListOfString_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[459] + mi := &file_product_proto_msgTypes[488] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -22922,7 +24246,7 @@ func (x *ListOfString_List) ProtoReflect() protoreflect.Message { // Deprecated: Use ListOfString_List.ProtoReflect.Descriptor instead. func (*ListOfString_List) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{18, 0} + return file_product_proto_rawDescGZIP(), []int{22, 0} } func (x *ListOfString_List) GetItems() []string { @@ -22941,7 +24265,7 @@ type ListOfSubcategory_List struct { func (x *ListOfSubcategory_List) Reset() { *x = ListOfSubcategory_List{} - mi := &file_product_proto_msgTypes[460] + mi := &file_product_proto_msgTypes[489] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -22953,7 +24277,7 @@ func (x *ListOfSubcategory_List) String() string { func (*ListOfSubcategory_List) ProtoMessage() {} func (x *ListOfSubcategory_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[460] + mi := &file_product_proto_msgTypes[489] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -22966,7 +24290,7 @@ func (x *ListOfSubcategory_List) ProtoReflect() protoreflect.Message { // Deprecated: Use ListOfSubcategory_List.ProtoReflect.Descriptor instead. func (*ListOfSubcategory_List) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{19, 0} + return file_product_proto_rawDescGZIP(), []int{23, 0} } func (x *ListOfSubcategory_List) GetItems() []*Subcategory { @@ -22985,7 +24309,7 @@ type ListOfUser_List struct { func (x *ListOfUser_List) Reset() { *x = ListOfUser_List{} - mi := &file_product_proto_msgTypes[461] + mi := &file_product_proto_msgTypes[490] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -22997,7 +24321,7 @@ func (x *ListOfUser_List) String() string { func (*ListOfUser_List) ProtoMessage() {} func (x *ListOfUser_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[461] + mi := &file_product_proto_msgTypes[490] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -23010,7 +24334,7 @@ func (x *ListOfUser_List) ProtoReflect() protoreflect.Message { // Deprecated: Use ListOfUser_List.ProtoReflect.Descriptor instead. func (*ListOfUser_List) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{20, 0} + return file_product_proto_rawDescGZIP(), []int{24, 0} } func (x *ListOfUser_List) GetItems() []*User { @@ -23029,7 +24353,7 @@ type ListOfUserInput_List struct { func (x *ListOfUserInput_List) Reset() { *x = ListOfUserInput_List{} - mi := &file_product_proto_msgTypes[462] + mi := &file_product_proto_msgTypes[491] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -23041,7 +24365,7 @@ func (x *ListOfUserInput_List) String() string { func (*ListOfUserInput_List) ProtoMessage() {} func (x *ListOfUserInput_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[462] + mi := &file_product_proto_msgTypes[491] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -23054,7 +24378,7 @@ func (x *ListOfUserInput_List) ProtoReflect() protoreflect.Message { // Deprecated: Use ListOfUserInput_List.ProtoReflect.Descriptor instead. func (*ListOfUserInput_List) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{21, 0} + return file_product_proto_rawDescGZIP(), []int{25, 0} } func (x *ListOfUserInput_List) GetItems() []*UserInput { @@ -23073,7 +24397,7 @@ type RequireStorageStockHealthScoreByIdFields_RestockData struct { func (x *RequireStorageStockHealthScoreByIdFields_RestockData) Reset() { *x = RequireStorageStockHealthScoreByIdFields_RestockData{} - mi := &file_product_proto_msgTypes[463] + mi := &file_product_proto_msgTypes[492] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -23085,7 +24409,7 @@ func (x *RequireStorageStockHealthScoreByIdFields_RestockData) String() string { func (*RequireStorageStockHealthScoreByIdFields_RestockData) ProtoMessage() {} func (x *RequireStorageStockHealthScoreByIdFields_RestockData) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[463] + mi := &file_product_proto_msgTypes[492] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -23098,7 +24422,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{247, 0} + return file_product_proto_rawDescGZIP(), []int{251, 0} } func (x *RequireStorageStockHealthScoreByIdFields_RestockData) GetLastRestockDate() string { @@ -23118,7 +24442,7 @@ type RequireStorageMetadataScoreByIdFields_StorageMetadata struct { func (x *RequireStorageMetadataScoreByIdFields_StorageMetadata) Reset() { *x = RequireStorageMetadataScoreByIdFields_StorageMetadata{} - mi := &file_product_proto_msgTypes[464] + mi := &file_product_proto_msgTypes[493] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -23130,7 +24454,7 @@ func (x *RequireStorageMetadataScoreByIdFields_StorageMetadata) String() string func (*RequireStorageMetadataScoreByIdFields_StorageMetadata) ProtoMessage() {} func (x *RequireStorageMetadataScoreByIdFields_StorageMetadata) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[464] + mi := &file_product_proto_msgTypes[493] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -23143,7 +24467,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{262, 0} + return file_product_proto_rawDescGZIP(), []int{266, 0} } func (x *RequireStorageMetadataScoreByIdFields_StorageMetadata) GetCapacity() int32 { @@ -23171,7 +24495,7 @@ type RequireStorageProcessedMetadataByIdFields_StorageMetadata struct { func (x *RequireStorageProcessedMetadataByIdFields_StorageMetadata) Reset() { *x = RequireStorageProcessedMetadataByIdFields_StorageMetadata{} - mi := &file_product_proto_msgTypes[465] + mi := &file_product_proto_msgTypes[494] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -23183,7 +24507,7 @@ func (x *RequireStorageProcessedMetadataByIdFields_StorageMetadata) String() str func (*RequireStorageProcessedMetadataByIdFields_StorageMetadata) ProtoMessage() {} func (x *RequireStorageProcessedMetadataByIdFields_StorageMetadata) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[465] + mi := &file_product_proto_msgTypes[494] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -23196,7 +24520,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{267, 0} + return file_product_proto_rawDescGZIP(), []int{271, 0} } func (x *RequireStorageProcessedMetadataByIdFields_StorageMetadata) GetCapacity() int32 { @@ -23230,7 +24554,7 @@ type RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata struct { func (x *RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata) Reset() { *x = RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata{} - mi := &file_product_proto_msgTypes[466] + mi := &file_product_proto_msgTypes[495] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -23242,7 +24566,7 @@ func (x *RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata) Stri func (*RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata) ProtoMessage() {} func (x *RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[466] + mi := &file_product_proto_msgTypes[495] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -23255,7 +24579,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{272, 0} + return file_product_proto_rawDescGZIP(), []int{276, 0} } func (x *RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata) GetCapacity() int32 { @@ -23282,7 +24606,7 @@ type RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata struct { func (x *RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata) Reset() { *x = RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata{} - mi := &file_product_proto_msgTypes[467] + mi := &file_product_proto_msgTypes[496] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -23294,7 +24618,7 @@ func (x *RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata) Strin func (*RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata) ProtoMessage() {} func (x *RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[467] + mi := &file_product_proto_msgTypes[496] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -23307,7 +24631,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{287, 0} + return file_product_proto_rawDescGZIP(), []int{291, 0} } func (x *RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata) GetCapacity() int32 { @@ -23324,6 +24648,58 @@ func (x *RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata) GetZo return "" } +type RequireStorageOptionalProcessedMetadataHistoryByIdFields_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"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RequireStorageOptionalProcessedMetadataHistoryByIdFields_StorageMetadata) Reset() { + *x = RequireStorageOptionalProcessedMetadataHistoryByIdFields_StorageMetadata{} + mi := &file_product_proto_msgTypes[497] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireStorageOptionalProcessedMetadataHistoryByIdFields_StorageMetadata) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageOptionalProcessedMetadataHistoryByIdFields_StorageMetadata) ProtoMessage() {} + +func (x *RequireStorageOptionalProcessedMetadataHistoryByIdFields_StorageMetadata) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[497] + 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 RequireStorageOptionalProcessedMetadataHistoryByIdFields_StorageMetadata.ProtoReflect.Descriptor instead. +func (*RequireStorageOptionalProcessedMetadataHistoryByIdFields_StorageMetadata) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{296, 0} +} + +func (x *RequireStorageOptionalProcessedMetadataHistoryByIdFields_StorageMetadata) GetCapacity() int32 { + if x != nil { + return x.Capacity + } + return 0 +} + +func (x *RequireStorageOptionalProcessedMetadataHistoryByIdFields_StorageMetadata) GetZone() string { + if x != nil { + return x.Zone + } + return "" +} + type RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo struct { state protoimpl.MessageState `protogen:"open.v1"` Kind CategoryKind `protobuf:"varint,1,opt,name=kind,proto3,enum=productv1.CategoryKind" json:"kind,omitempty"` @@ -23334,7 +24710,7 @@ type RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo struct { func (x *RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo) Reset() { *x = RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo{} - mi := &file_product_proto_msgTypes[468] + mi := &file_product_proto_msgTypes[498] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -23346,7 +24722,7 @@ func (x *RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo) String func (*RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo) ProtoMessage() {} func (x *RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[468] + mi := &file_product_proto_msgTypes[498] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -23359,7 +24735,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{297, 0} + return file_product_proto_rawDescGZIP(), []int{312, 0} } func (x *RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo) GetKind() CategoryKind { @@ -23386,7 +24762,7 @@ type RequireStorageItemInfoByIdFields_PalletItem struct { func (x *RequireStorageItemInfoByIdFields_PalletItem) Reset() { *x = RequireStorageItemInfoByIdFields_PalletItem{} - mi := &file_product_proto_msgTypes[469] + mi := &file_product_proto_msgTypes[499] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -23398,7 +24774,7 @@ func (x *RequireStorageItemInfoByIdFields_PalletItem) String() string { func (*RequireStorageItemInfoByIdFields_PalletItem) ProtoMessage() {} func (x *RequireStorageItemInfoByIdFields_PalletItem) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[469] + mi := &file_product_proto_msgTypes[499] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -23411,7 +24787,7 @@ func (x *RequireStorageItemInfoByIdFields_PalletItem) ProtoReflect() protoreflec // Deprecated: Use RequireStorageItemInfoByIdFields_PalletItem.ProtoReflect.Descriptor instead. func (*RequireStorageItemInfoByIdFields_PalletItem) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{302, 0} + return file_product_proto_rawDescGZIP(), []int{317, 0} } func (x *RequireStorageItemInfoByIdFields_PalletItem) GetName() string { @@ -23438,7 +24814,7 @@ type RequireStorageItemInfoByIdFields_ContainerItem struct { func (x *RequireStorageItemInfoByIdFields_ContainerItem) Reset() { *x = RequireStorageItemInfoByIdFields_ContainerItem{} - mi := &file_product_proto_msgTypes[470] + mi := &file_product_proto_msgTypes[500] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -23450,7 +24826,7 @@ func (x *RequireStorageItemInfoByIdFields_ContainerItem) String() string { func (*RequireStorageItemInfoByIdFields_ContainerItem) ProtoMessage() {} func (x *RequireStorageItemInfoByIdFields_ContainerItem) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[470] + mi := &file_product_proto_msgTypes[500] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -23463,7 +24839,7 @@ func (x *RequireStorageItemInfoByIdFields_ContainerItem) ProtoReflect() protoref // Deprecated: Use RequireStorageItemInfoByIdFields_ContainerItem.ProtoReflect.Descriptor instead. func (*RequireStorageItemInfoByIdFields_ContainerItem) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{302, 1} + return file_product_proto_rawDescGZIP(), []int{317, 1} } func (x *RequireStorageItemInfoByIdFields_ContainerItem) GetName() string { @@ -23493,7 +24869,7 @@ type RequireStorageItemInfoByIdFields_StorageItem struct { func (x *RequireStorageItemInfoByIdFields_StorageItem) Reset() { *x = RequireStorageItemInfoByIdFields_StorageItem{} - mi := &file_product_proto_msgTypes[471] + mi := &file_product_proto_msgTypes[501] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -23505,7 +24881,7 @@ func (x *RequireStorageItemInfoByIdFields_StorageItem) String() string { func (*RequireStorageItemInfoByIdFields_StorageItem) ProtoMessage() {} func (x *RequireStorageItemInfoByIdFields_StorageItem) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[471] + mi := &file_product_proto_msgTypes[501] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -23518,7 +24894,7 @@ func (x *RequireStorageItemInfoByIdFields_StorageItem) ProtoReflect() protorefle // Deprecated: Use RequireStorageItemInfoByIdFields_StorageItem.ProtoReflect.Descriptor instead. func (*RequireStorageItemInfoByIdFields_StorageItem) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{302, 2} + return file_product_proto_rawDescGZIP(), []int{317, 2} } func (x *RequireStorageItemInfoByIdFields_StorageItem) GetInstance() isRequireStorageItemInfoByIdFields_StorageItem_Instance { @@ -23574,7 +24950,7 @@ type RequireStorageOperationReportByIdFields_StorageSuccess struct { func (x *RequireStorageOperationReportByIdFields_StorageSuccess) Reset() { *x = RequireStorageOperationReportByIdFields_StorageSuccess{} - mi := &file_product_proto_msgTypes[472] + mi := &file_product_proto_msgTypes[502] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -23586,7 +24962,7 @@ func (x *RequireStorageOperationReportByIdFields_StorageSuccess) String() string func (*RequireStorageOperationReportByIdFields_StorageSuccess) ProtoMessage() {} func (x *RequireStorageOperationReportByIdFields_StorageSuccess) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[472] + mi := &file_product_proto_msgTypes[502] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -23599,7 +24975,7 @@ func (x *RequireStorageOperationReportByIdFields_StorageSuccess) ProtoReflect() // Deprecated: Use RequireStorageOperationReportByIdFields_StorageSuccess.ProtoReflect.Descriptor instead. func (*RequireStorageOperationReportByIdFields_StorageSuccess) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{307, 0} + return file_product_proto_rawDescGZIP(), []int{322, 0} } func (x *RequireStorageOperationReportByIdFields_StorageSuccess) GetMessage() string { @@ -23626,7 +25002,7 @@ type RequireStorageOperationReportByIdFields_StorageFailure struct { func (x *RequireStorageOperationReportByIdFields_StorageFailure) Reset() { *x = RequireStorageOperationReportByIdFields_StorageFailure{} - mi := &file_product_proto_msgTypes[473] + mi := &file_product_proto_msgTypes[503] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -23638,7 +25014,7 @@ func (x *RequireStorageOperationReportByIdFields_StorageFailure) String() string func (*RequireStorageOperationReportByIdFields_StorageFailure) ProtoMessage() {} func (x *RequireStorageOperationReportByIdFields_StorageFailure) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[473] + mi := &file_product_proto_msgTypes[503] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -23651,7 +25027,7 @@ func (x *RequireStorageOperationReportByIdFields_StorageFailure) ProtoReflect() // Deprecated: Use RequireStorageOperationReportByIdFields_StorageFailure.ProtoReflect.Descriptor instead. func (*RequireStorageOperationReportByIdFields_StorageFailure) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{307, 1} + return file_product_proto_rawDescGZIP(), []int{322, 1} } func (x *RequireStorageOperationReportByIdFields_StorageFailure) GetMessage() string { @@ -23681,7 +25057,7 @@ type RequireStorageOperationReportByIdFields_StorageOperationResult struct { func (x *RequireStorageOperationReportByIdFields_StorageOperationResult) Reset() { *x = RequireStorageOperationReportByIdFields_StorageOperationResult{} - mi := &file_product_proto_msgTypes[474] + mi := &file_product_proto_msgTypes[504] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -23693,7 +25069,7 @@ func (x *RequireStorageOperationReportByIdFields_StorageOperationResult) String( func (*RequireStorageOperationReportByIdFields_StorageOperationResult) ProtoMessage() {} func (x *RequireStorageOperationReportByIdFields_StorageOperationResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[474] + mi := &file_product_proto_msgTypes[504] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -23706,7 +25082,7 @@ func (x *RequireStorageOperationReportByIdFields_StorageOperationResult) ProtoRe // Deprecated: Use RequireStorageOperationReportByIdFields_StorageOperationResult.ProtoReflect.Descriptor instead. func (*RequireStorageOperationReportByIdFields_StorageOperationResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{307, 2} + return file_product_proto_rawDescGZIP(), []int{322, 2} } func (x *RequireStorageOperationReportByIdFields_StorageOperationResult) GetValue() isRequireStorageOperationReportByIdFields_StorageOperationResult_Value { @@ -23762,7 +25138,7 @@ type RequireStorageSecuritySummaryByIdFields_SecuritySetup struct { func (x *RequireStorageSecuritySummaryByIdFields_SecuritySetup) Reset() { *x = RequireStorageSecuritySummaryByIdFields_SecuritySetup{} - mi := &file_product_proto_msgTypes[475] + mi := &file_product_proto_msgTypes[505] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -23774,7 +25150,7 @@ func (x *RequireStorageSecuritySummaryByIdFields_SecuritySetup) String() string func (*RequireStorageSecuritySummaryByIdFields_SecuritySetup) ProtoMessage() {} func (x *RequireStorageSecuritySummaryByIdFields_SecuritySetup) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[475] + mi := &file_product_proto_msgTypes[505] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -23787,7 +25163,7 @@ func (x *RequireStorageSecuritySummaryByIdFields_SecuritySetup) ProtoReflect() p // Deprecated: Use RequireStorageSecuritySummaryByIdFields_SecuritySetup.ProtoReflect.Descriptor instead. func (*RequireStorageSecuritySummaryByIdFields_SecuritySetup) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{312, 0} + return file_product_proto_rawDescGZIP(), []int{327, 0} } func (x *RequireStorageSecuritySummaryByIdFields_SecuritySetup) GetSecurityLevel() string { @@ -23814,7 +25190,7 @@ type RequireStorageSecuritySummaryByIdFields_SecuritySetup_PalletItem struct { func (x *RequireStorageSecuritySummaryByIdFields_SecuritySetup_PalletItem) Reset() { *x = RequireStorageSecuritySummaryByIdFields_SecuritySetup_PalletItem{} - mi := &file_product_proto_msgTypes[476] + mi := &file_product_proto_msgTypes[506] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -23826,7 +25202,7 @@ func (x *RequireStorageSecuritySummaryByIdFields_SecuritySetup_PalletItem) Strin func (*RequireStorageSecuritySummaryByIdFields_SecuritySetup_PalletItem) ProtoMessage() {} func (x *RequireStorageSecuritySummaryByIdFields_SecuritySetup_PalletItem) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[476] + mi := &file_product_proto_msgTypes[506] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -23839,7 +25215,7 @@ func (x *RequireStorageSecuritySummaryByIdFields_SecuritySetup_PalletItem) Proto // Deprecated: Use RequireStorageSecuritySummaryByIdFields_SecuritySetup_PalletItem.ProtoReflect.Descriptor instead. func (*RequireStorageSecuritySummaryByIdFields_SecuritySetup_PalletItem) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{312, 0, 0} + return file_product_proto_rawDescGZIP(), []int{327, 0, 0} } func (x *RequireStorageSecuritySummaryByIdFields_SecuritySetup_PalletItem) GetName() string { @@ -23866,7 +25242,7 @@ type RequireStorageSecuritySummaryByIdFields_SecuritySetup_ContainerItem struct func (x *RequireStorageSecuritySummaryByIdFields_SecuritySetup_ContainerItem) Reset() { *x = RequireStorageSecuritySummaryByIdFields_SecuritySetup_ContainerItem{} - mi := &file_product_proto_msgTypes[477] + mi := &file_product_proto_msgTypes[507] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -23878,7 +25254,7 @@ func (x *RequireStorageSecuritySummaryByIdFields_SecuritySetup_ContainerItem) St func (*RequireStorageSecuritySummaryByIdFields_SecuritySetup_ContainerItem) ProtoMessage() {} func (x *RequireStorageSecuritySummaryByIdFields_SecuritySetup_ContainerItem) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[477] + mi := &file_product_proto_msgTypes[507] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -23891,7 +25267,7 @@ func (x *RequireStorageSecuritySummaryByIdFields_SecuritySetup_ContainerItem) Pr // Deprecated: Use RequireStorageSecuritySummaryByIdFields_SecuritySetup_ContainerItem.ProtoReflect.Descriptor instead. func (*RequireStorageSecuritySummaryByIdFields_SecuritySetup_ContainerItem) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{312, 0, 1} + return file_product_proto_rawDescGZIP(), []int{327, 0, 1} } func (x *RequireStorageSecuritySummaryByIdFields_SecuritySetup_ContainerItem) GetName() string { @@ -23921,7 +25297,7 @@ type RequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem struct { func (x *RequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem) Reset() { *x = RequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem{} - mi := &file_product_proto_msgTypes[478] + mi := &file_product_proto_msgTypes[508] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -23933,7 +25309,7 @@ func (x *RequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem) Stri func (*RequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem) ProtoMessage() {} func (x *RequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[478] + mi := &file_product_proto_msgTypes[508] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -23946,7 +25322,7 @@ func (x *RequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem) Prot // Deprecated: Use RequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem.ProtoReflect.Descriptor instead. func (*RequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{312, 0, 2} + return file_product_proto_rawDescGZIP(), []int{327, 0, 2} } func (x *RequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem) GetInstance() isRequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem_Instance { @@ -24001,7 +25377,7 @@ type RequireStorageItemHandlerInfoByIdFields_PalletItem struct { func (x *RequireStorageItemHandlerInfoByIdFields_PalletItem) Reset() { *x = RequireStorageItemHandlerInfoByIdFields_PalletItem{} - mi := &file_product_proto_msgTypes[479] + mi := &file_product_proto_msgTypes[509] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -24013,7 +25389,7 @@ func (x *RequireStorageItemHandlerInfoByIdFields_PalletItem) String() string { func (*RequireStorageItemHandlerInfoByIdFields_PalletItem) ProtoMessage() {} func (x *RequireStorageItemHandlerInfoByIdFields_PalletItem) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[479] + mi := &file_product_proto_msgTypes[509] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -24026,7 +25402,7 @@ func (x *RequireStorageItemHandlerInfoByIdFields_PalletItem) ProtoReflect() prot // Deprecated: Use RequireStorageItemHandlerInfoByIdFields_PalletItem.ProtoReflect.Descriptor instead. func (*RequireStorageItemHandlerInfoByIdFields_PalletItem) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{317, 0} + return file_product_proto_rawDescGZIP(), []int{332, 0} } func (x *RequireStorageItemHandlerInfoByIdFields_PalletItem) GetHandler() *RequireStorageItemHandlerInfoByIdFields_PalletItem_ItemHandler { @@ -24045,7 +25421,7 @@ type RequireStorageItemHandlerInfoByIdFields_ContainerItem struct { func (x *RequireStorageItemHandlerInfoByIdFields_ContainerItem) Reset() { *x = RequireStorageItemHandlerInfoByIdFields_ContainerItem{} - mi := &file_product_proto_msgTypes[480] + mi := &file_product_proto_msgTypes[510] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -24057,7 +25433,7 @@ func (x *RequireStorageItemHandlerInfoByIdFields_ContainerItem) String() string func (*RequireStorageItemHandlerInfoByIdFields_ContainerItem) ProtoMessage() {} func (x *RequireStorageItemHandlerInfoByIdFields_ContainerItem) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[480] + mi := &file_product_proto_msgTypes[510] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -24070,7 +25446,7 @@ func (x *RequireStorageItemHandlerInfoByIdFields_ContainerItem) ProtoReflect() p // Deprecated: Use RequireStorageItemHandlerInfoByIdFields_ContainerItem.ProtoReflect.Descriptor instead. func (*RequireStorageItemHandlerInfoByIdFields_ContainerItem) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{317, 1} + return file_product_proto_rawDescGZIP(), []int{332, 1} } func (x *RequireStorageItemHandlerInfoByIdFields_ContainerItem) GetHandler() *RequireStorageItemHandlerInfoByIdFields_ContainerItem_ItemHandler { @@ -24093,7 +25469,7 @@ type RequireStorageItemHandlerInfoByIdFields_StorageItem struct { func (x *RequireStorageItemHandlerInfoByIdFields_StorageItem) Reset() { *x = RequireStorageItemHandlerInfoByIdFields_StorageItem{} - mi := &file_product_proto_msgTypes[481] + mi := &file_product_proto_msgTypes[511] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -24105,7 +25481,7 @@ func (x *RequireStorageItemHandlerInfoByIdFields_StorageItem) String() string { func (*RequireStorageItemHandlerInfoByIdFields_StorageItem) ProtoMessage() {} func (x *RequireStorageItemHandlerInfoByIdFields_StorageItem) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[481] + mi := &file_product_proto_msgTypes[511] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -24118,7 +25494,7 @@ func (x *RequireStorageItemHandlerInfoByIdFields_StorageItem) ProtoReflect() pro // Deprecated: Use RequireStorageItemHandlerInfoByIdFields_StorageItem.ProtoReflect.Descriptor instead. func (*RequireStorageItemHandlerInfoByIdFields_StorageItem) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{317, 2} + return file_product_proto_rawDescGZIP(), []int{332, 2} } func (x *RequireStorageItemHandlerInfoByIdFields_StorageItem) GetInstance() isRequireStorageItemHandlerInfoByIdFields_StorageItem_Instance { @@ -24173,7 +25549,7 @@ type RequireStorageItemHandlerInfoByIdFields_PalletItem_ItemHandler struct { func (x *RequireStorageItemHandlerInfoByIdFields_PalletItem_ItemHandler) Reset() { *x = RequireStorageItemHandlerInfoByIdFields_PalletItem_ItemHandler{} - mi := &file_product_proto_msgTypes[482] + mi := &file_product_proto_msgTypes[512] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -24185,7 +25561,7 @@ func (x *RequireStorageItemHandlerInfoByIdFields_PalletItem_ItemHandler) String( func (*RequireStorageItemHandlerInfoByIdFields_PalletItem_ItemHandler) ProtoMessage() {} func (x *RequireStorageItemHandlerInfoByIdFields_PalletItem_ItemHandler) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[482] + mi := &file_product_proto_msgTypes[512] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -24198,7 +25574,7 @@ func (x *RequireStorageItemHandlerInfoByIdFields_PalletItem_ItemHandler) ProtoRe // Deprecated: Use RequireStorageItemHandlerInfoByIdFields_PalletItem_ItemHandler.ProtoReflect.Descriptor instead. func (*RequireStorageItemHandlerInfoByIdFields_PalletItem_ItemHandler) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{317, 0, 0} + return file_product_proto_rawDescGZIP(), []int{332, 0, 0} } func (x *RequireStorageItemHandlerInfoByIdFields_PalletItem_ItemHandler) GetName() string { @@ -24217,7 +25593,7 @@ type RequireStorageItemHandlerInfoByIdFields_ContainerItem_ItemHandler struct { func (x *RequireStorageItemHandlerInfoByIdFields_ContainerItem_ItemHandler) Reset() { *x = RequireStorageItemHandlerInfoByIdFields_ContainerItem_ItemHandler{} - mi := &file_product_proto_msgTypes[483] + mi := &file_product_proto_msgTypes[513] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -24229,7 +25605,7 @@ func (x *RequireStorageItemHandlerInfoByIdFields_ContainerItem_ItemHandler) Stri func (*RequireStorageItemHandlerInfoByIdFields_ContainerItem_ItemHandler) ProtoMessage() {} func (x *RequireStorageItemHandlerInfoByIdFields_ContainerItem_ItemHandler) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[483] + mi := &file_product_proto_msgTypes[513] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -24242,7 +25618,7 @@ func (x *RequireStorageItemHandlerInfoByIdFields_ContainerItem_ItemHandler) Prot // Deprecated: Use RequireStorageItemHandlerInfoByIdFields_ContainerItem_ItemHandler.ProtoReflect.Descriptor instead. func (*RequireStorageItemHandlerInfoByIdFields_ContainerItem_ItemHandler) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{317, 1, 0} + return file_product_proto_rawDescGZIP(), []int{332, 1, 0} } func (x *RequireStorageItemHandlerInfoByIdFields_ContainerItem_ItemHandler) GetName() string { @@ -24261,7 +25637,7 @@ type RequireStorageItemSpecsInfoByIdFields_PalletItem struct { func (x *RequireStorageItemSpecsInfoByIdFields_PalletItem) Reset() { *x = RequireStorageItemSpecsInfoByIdFields_PalletItem{} - mi := &file_product_proto_msgTypes[484] + mi := &file_product_proto_msgTypes[514] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -24273,7 +25649,7 @@ func (x *RequireStorageItemSpecsInfoByIdFields_PalletItem) String() string { func (*RequireStorageItemSpecsInfoByIdFields_PalletItem) ProtoMessage() {} func (x *RequireStorageItemSpecsInfoByIdFields_PalletItem) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[484] + mi := &file_product_proto_msgTypes[514] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -24286,7 +25662,7 @@ func (x *RequireStorageItemSpecsInfoByIdFields_PalletItem) ProtoReflect() protor // Deprecated: Use RequireStorageItemSpecsInfoByIdFields_PalletItem.ProtoReflect.Descriptor instead. func (*RequireStorageItemSpecsInfoByIdFields_PalletItem) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{322, 0} + return file_product_proto_rawDescGZIP(), []int{337, 0} } func (x *RequireStorageItemSpecsInfoByIdFields_PalletItem) GetSpecs() *RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs { @@ -24305,7 +25681,7 @@ type RequireStorageItemSpecsInfoByIdFields_ContainerItem struct { func (x *RequireStorageItemSpecsInfoByIdFields_ContainerItem) Reset() { *x = RequireStorageItemSpecsInfoByIdFields_ContainerItem{} - mi := &file_product_proto_msgTypes[485] + mi := &file_product_proto_msgTypes[515] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -24317,7 +25693,7 @@ func (x *RequireStorageItemSpecsInfoByIdFields_ContainerItem) String() string { func (*RequireStorageItemSpecsInfoByIdFields_ContainerItem) ProtoMessage() {} func (x *RequireStorageItemSpecsInfoByIdFields_ContainerItem) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[485] + mi := &file_product_proto_msgTypes[515] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -24330,7 +25706,7 @@ func (x *RequireStorageItemSpecsInfoByIdFields_ContainerItem) ProtoReflect() pro // Deprecated: Use RequireStorageItemSpecsInfoByIdFields_ContainerItem.ProtoReflect.Descriptor instead. func (*RequireStorageItemSpecsInfoByIdFields_ContainerItem) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{322, 1} + return file_product_proto_rawDescGZIP(), []int{337, 1} } func (x *RequireStorageItemSpecsInfoByIdFields_ContainerItem) GetSpecs() *RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs { @@ -24353,7 +25729,7 @@ type RequireStorageItemSpecsInfoByIdFields_StorageItem struct { func (x *RequireStorageItemSpecsInfoByIdFields_StorageItem) Reset() { *x = RequireStorageItemSpecsInfoByIdFields_StorageItem{} - mi := &file_product_proto_msgTypes[486] + mi := &file_product_proto_msgTypes[516] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -24365,7 +25741,7 @@ func (x *RequireStorageItemSpecsInfoByIdFields_StorageItem) String() string { func (*RequireStorageItemSpecsInfoByIdFields_StorageItem) ProtoMessage() {} func (x *RequireStorageItemSpecsInfoByIdFields_StorageItem) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[486] + mi := &file_product_proto_msgTypes[516] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -24378,7 +25754,7 @@ func (x *RequireStorageItemSpecsInfoByIdFields_StorageItem) ProtoReflect() proto // Deprecated: Use RequireStorageItemSpecsInfoByIdFields_StorageItem.ProtoReflect.Descriptor instead. func (*RequireStorageItemSpecsInfoByIdFields_StorageItem) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{322, 2} + return file_product_proto_rawDescGZIP(), []int{337, 2} } func (x *RequireStorageItemSpecsInfoByIdFields_StorageItem) GetInstance() isRequireStorageItemSpecsInfoByIdFields_StorageItem_Instance { @@ -24434,7 +25810,7 @@ type RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs struct { func (x *RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs) Reset() { *x = RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs{} - mi := &file_product_proto_msgTypes[487] + mi := &file_product_proto_msgTypes[517] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -24446,7 +25822,7 @@ func (x *RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs) String() func (*RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs) ProtoMessage() {} func (x *RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[487] + mi := &file_product_proto_msgTypes[517] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -24459,7 +25835,7 @@ func (x *RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs) ProtoRefl // Deprecated: Use RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs.ProtoReflect.Descriptor instead. func (*RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{322, 0, 0} + return file_product_proto_rawDescGZIP(), []int{337, 0, 0} } func (x *RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs) GetName() string { @@ -24486,7 +25862,7 @@ type RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs_Dimensions str func (x *RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs_Dimensions) Reset() { *x = RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs_Dimensions{} - mi := &file_product_proto_msgTypes[488] + mi := &file_product_proto_msgTypes[518] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -24498,7 +25874,7 @@ func (x *RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs_Dimensions func (*RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs_Dimensions) ProtoMessage() {} func (x *RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs_Dimensions) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[488] + mi := &file_product_proto_msgTypes[518] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -24511,7 +25887,7 @@ func (x *RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs_Dimensions // Deprecated: Use RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs_Dimensions.ProtoReflect.Descriptor instead. func (*RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs_Dimensions) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{322, 0, 0, 0} + return file_product_proto_rawDescGZIP(), []int{337, 0, 0, 0} } func (x *RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs_Dimensions) GetLength() float64 { @@ -24538,7 +25914,7 @@ type RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs struct { func (x *RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs) Reset() { *x = RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs{} - mi := &file_product_proto_msgTypes[489] + mi := &file_product_proto_msgTypes[519] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -24550,7 +25926,7 @@ func (x *RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs) Str func (*RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs) ProtoMessage() {} func (x *RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[489] + mi := &file_product_proto_msgTypes[519] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -24563,7 +25939,7 @@ func (x *RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs) Pro // Deprecated: Use RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs.ProtoReflect.Descriptor instead. func (*RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{322, 1, 0} + return file_product_proto_rawDescGZIP(), []int{337, 1, 0} } func (x *RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs) GetName() string { @@ -24590,7 +25966,7 @@ type RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs_Dimensio func (x *RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs_Dimensions) Reset() { *x = RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs_Dimensions{} - mi := &file_product_proto_msgTypes[490] + mi := &file_product_proto_msgTypes[520] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -24603,7 +25979,7 @@ func (*RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs_Dimens } func (x *RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs_Dimensions) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[490] + mi := &file_product_proto_msgTypes[520] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -24616,7 +25992,7 @@ func (x *RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs_Dime // Deprecated: Use RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs_Dimensions.ProtoReflect.Descriptor instead. func (*RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs_Dimensions) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{322, 1, 0, 0} + return file_product_proto_rawDescGZIP(), []int{337, 1, 0, 0} } func (x *RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs_Dimensions) GetLength() float64 { @@ -24642,7 +26018,7 @@ type RequireStorageDeepItemInfoByIdFields_PalletItem struct { func (x *RequireStorageDeepItemInfoByIdFields_PalletItem) Reset() { *x = RequireStorageDeepItemInfoByIdFields_PalletItem{} - mi := &file_product_proto_msgTypes[491] + mi := &file_product_proto_msgTypes[521] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -24654,7 +26030,7 @@ func (x *RequireStorageDeepItemInfoByIdFields_PalletItem) String() string { func (*RequireStorageDeepItemInfoByIdFields_PalletItem) ProtoMessage() {} func (x *RequireStorageDeepItemInfoByIdFields_PalletItem) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[491] + mi := &file_product_proto_msgTypes[521] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -24667,7 +26043,7 @@ func (x *RequireStorageDeepItemInfoByIdFields_PalletItem) ProtoReflect() protore // Deprecated: Use RequireStorageDeepItemInfoByIdFields_PalletItem.ProtoReflect.Descriptor instead. func (*RequireStorageDeepItemInfoByIdFields_PalletItem) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{327, 0} + return file_product_proto_rawDescGZIP(), []int{342, 0} } func (x *RequireStorageDeepItemInfoByIdFields_PalletItem) GetHandler() *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler { @@ -24686,7 +26062,7 @@ type RequireStorageDeepItemInfoByIdFields_ContainerItem struct { func (x *RequireStorageDeepItemInfoByIdFields_ContainerItem) Reset() { *x = RequireStorageDeepItemInfoByIdFields_ContainerItem{} - mi := &file_product_proto_msgTypes[492] + mi := &file_product_proto_msgTypes[522] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -24698,7 +26074,7 @@ func (x *RequireStorageDeepItemInfoByIdFields_ContainerItem) String() string { func (*RequireStorageDeepItemInfoByIdFields_ContainerItem) ProtoMessage() {} func (x *RequireStorageDeepItemInfoByIdFields_ContainerItem) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[492] + mi := &file_product_proto_msgTypes[522] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -24711,7 +26087,7 @@ func (x *RequireStorageDeepItemInfoByIdFields_ContainerItem) ProtoReflect() prot // Deprecated: Use RequireStorageDeepItemInfoByIdFields_ContainerItem.ProtoReflect.Descriptor instead. func (*RequireStorageDeepItemInfoByIdFields_ContainerItem) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{327, 1} + return file_product_proto_rawDescGZIP(), []int{342, 1} } func (x *RequireStorageDeepItemInfoByIdFields_ContainerItem) GetHandler() *RequireStorageDeepItemInfoByIdFields_ContainerItem_ItemHandler { @@ -24734,7 +26110,7 @@ type RequireStorageDeepItemInfoByIdFields_StorageItem struct { func (x *RequireStorageDeepItemInfoByIdFields_StorageItem) Reset() { *x = RequireStorageDeepItemInfoByIdFields_StorageItem{} - mi := &file_product_proto_msgTypes[493] + mi := &file_product_proto_msgTypes[523] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -24746,7 +26122,7 @@ func (x *RequireStorageDeepItemInfoByIdFields_StorageItem) String() string { func (*RequireStorageDeepItemInfoByIdFields_StorageItem) ProtoMessage() {} func (x *RequireStorageDeepItemInfoByIdFields_StorageItem) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[493] + mi := &file_product_proto_msgTypes[523] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -24759,7 +26135,7 @@ func (x *RequireStorageDeepItemInfoByIdFields_StorageItem) ProtoReflect() protor // Deprecated: Use RequireStorageDeepItemInfoByIdFields_StorageItem.ProtoReflect.Descriptor instead. func (*RequireStorageDeepItemInfoByIdFields_StorageItem) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{327, 2} + return file_product_proto_rawDescGZIP(), []int{342, 2} } func (x *RequireStorageDeepItemInfoByIdFields_StorageItem) GetInstance() isRequireStorageDeepItemInfoByIdFields_StorageItem_Instance { @@ -24814,7 +26190,7 @@ type RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler struct { func (x *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler) Reset() { *x = RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler{} - mi := &file_product_proto_msgTypes[494] + mi := &file_product_proto_msgTypes[524] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -24826,7 +26202,7 @@ func (x *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler) String() s func (*RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler) ProtoMessage() {} func (x *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[494] + mi := &file_product_proto_msgTypes[524] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -24839,7 +26215,7 @@ func (x *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler) ProtoRefle // Deprecated: Use RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler.ProtoReflect.Descriptor instead. func (*RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{327, 0, 0} + return file_product_proto_rawDescGZIP(), []int{342, 0, 0} } func (x *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler) GetAssignedItem() *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem { @@ -24859,7 +26235,7 @@ type RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_ContainerItem s func (x *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_ContainerItem) Reset() { *x = RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_ContainerItem{} - mi := &file_product_proto_msgTypes[495] + mi := &file_product_proto_msgTypes[525] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -24871,7 +26247,7 @@ func (x *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_ContainerIt func (*RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_ContainerItem) ProtoMessage() {} func (x *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_ContainerItem) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[495] + mi := &file_product_proto_msgTypes[525] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -24884,7 +26260,7 @@ func (x *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_ContainerIt // Deprecated: Use RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_ContainerItem.ProtoReflect.Descriptor instead. func (*RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_ContainerItem) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{327, 0, 0, 0} + return file_product_proto_rawDescGZIP(), []int{342, 0, 0, 0} } func (x *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_ContainerItem) GetName() string { @@ -24911,7 +26287,7 @@ type RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_PalletItem stru func (x *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_PalletItem) Reset() { *x = RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_PalletItem{} - mi := &file_product_proto_msgTypes[496] + mi := &file_product_proto_msgTypes[526] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -24923,7 +26299,7 @@ func (x *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_PalletItem) func (*RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_PalletItem) ProtoMessage() {} func (x *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_PalletItem) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[496] + mi := &file_product_proto_msgTypes[526] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -24936,7 +26312,7 @@ func (x *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_PalletItem) // Deprecated: Use RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_PalletItem.ProtoReflect.Descriptor instead. func (*RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_PalletItem) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{327, 0, 0, 1} + return file_product_proto_rawDescGZIP(), []int{342, 0, 0, 1} } func (x *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_PalletItem) GetName() string { @@ -24966,7 +26342,7 @@ type RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem str func (x *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem) Reset() { *x = RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem{} - mi := &file_product_proto_msgTypes[497] + mi := &file_product_proto_msgTypes[527] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -24978,7 +26354,7 @@ func (x *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem func (*RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem) ProtoMessage() {} func (x *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[497] + mi := &file_product_proto_msgTypes[527] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -24991,7 +26367,7 @@ func (x *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem // Deprecated: Use RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem.ProtoReflect.Descriptor instead. func (*RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{327, 0, 0, 2} + return file_product_proto_rawDescGZIP(), []int{342, 0, 0, 2} } func (x *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem) GetInstance() isRequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem_Instance { @@ -25046,7 +26422,7 @@ type RequireStorageDeepItemInfoByIdFields_ContainerItem_ItemHandler struct { func (x *RequireStorageDeepItemInfoByIdFields_ContainerItem_ItemHandler) Reset() { *x = RequireStorageDeepItemInfoByIdFields_ContainerItem_ItemHandler{} - mi := &file_product_proto_msgTypes[498] + mi := &file_product_proto_msgTypes[528] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -25058,7 +26434,7 @@ func (x *RequireStorageDeepItemInfoByIdFields_ContainerItem_ItemHandler) String( func (*RequireStorageDeepItemInfoByIdFields_ContainerItem_ItemHandler) ProtoMessage() {} func (x *RequireStorageDeepItemInfoByIdFields_ContainerItem_ItemHandler) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[498] + mi := &file_product_proto_msgTypes[528] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -25071,7 +26447,7 @@ func (x *RequireStorageDeepItemInfoByIdFields_ContainerItem_ItemHandler) ProtoRe // Deprecated: Use RequireStorageDeepItemInfoByIdFields_ContainerItem_ItemHandler.ProtoReflect.Descriptor instead. func (*RequireStorageDeepItemInfoByIdFields_ContainerItem_ItemHandler) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{327, 1, 0} + return file_product_proto_rawDescGZIP(), []int{342, 1, 0} } func (x *RequireStorageDeepItemInfoByIdFields_ContainerItem_ItemHandler) GetName() string { @@ -25091,7 +26467,7 @@ type RequireStorageRecommendedItemByIdFields_StorageMetadata struct { func (x *RequireStorageRecommendedItemByIdFields_StorageMetadata) Reset() { *x = RequireStorageRecommendedItemByIdFields_StorageMetadata{} - mi := &file_product_proto_msgTypes[499] + mi := &file_product_proto_msgTypes[529] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -25103,7 +26479,7 @@ func (x *RequireStorageRecommendedItemByIdFields_StorageMetadata) String() strin func (*RequireStorageRecommendedItemByIdFields_StorageMetadata) ProtoMessage() {} func (x *RequireStorageRecommendedItemByIdFields_StorageMetadata) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[499] + mi := &file_product_proto_msgTypes[529] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -25116,7 +26492,7 @@ func (x *RequireStorageRecommendedItemByIdFields_StorageMetadata) ProtoReflect() // Deprecated: Use RequireStorageRecommendedItemByIdFields_StorageMetadata.ProtoReflect.Descriptor instead. func (*RequireStorageRecommendedItemByIdFields_StorageMetadata) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{332, 0} + return file_product_proto_rawDescGZIP(), []int{347, 0} } func (x *RequireStorageRecommendedItemByIdFields_StorageMetadata) GetCapacity() int32 { @@ -25142,7 +26518,7 @@ type RequireWarehouseStockHealthScoreByIdFields_RestockData struct { func (x *RequireWarehouseStockHealthScoreByIdFields_RestockData) Reset() { *x = RequireWarehouseStockHealthScoreByIdFields_RestockData{} - mi := &file_product_proto_msgTypes[500] + mi := &file_product_proto_msgTypes[530] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -25154,7 +26530,7 @@ func (x *RequireWarehouseStockHealthScoreByIdFields_RestockData) String() string func (*RequireWarehouseStockHealthScoreByIdFields_RestockData) ProtoMessage() {} func (x *RequireWarehouseStockHealthScoreByIdFields_RestockData) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[500] + mi := &file_product_proto_msgTypes[530] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -25167,7 +26543,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{370, 0} + return file_product_proto_rawDescGZIP(), []int{395, 0} } func (x *RequireWarehouseStockHealthScoreByIdFields_RestockData) GetLastRestockDate() string { @@ -25221,7 +26597,11 @@ const file_product_proto_rawDesc = "" + "\vListOfFloat\x12/\n" + "\x04list\x18\x01 \x01(\v2\x1b.productv1.ListOfFloat.ListR\x04list\x1a\x1c\n" + "\x04List\x12\x14\n" + - "\x05items\x18\x01 \x03(\x01R\x05items\"\x89\x01\n" + + "\x05items\x18\x01 \x03(\x01R\x05items\"X\n" + + "\tListOfInt\x12-\n" + + "\x04list\x18\x01 \x01(\v2\x19.productv1.ListOfInt.ListR\x04list\x1a\x1c\n" + + "\x04List\x12\x14\n" + + "\x05items\x18\x01 \x03(\x05R\x05items\"\x89\x01\n" + "\x14ListOfListOfCategory\x128\n" + "\x04list\x18\x01 \x01(\v2$.productv1.ListOfListOfCategory.ListR\x04list\x1a7\n" + "\x04List\x12/\n" + @@ -25253,7 +26633,19 @@ const file_product_proto_rawDesc = "" + "\rListOfStorage\x121\n" + "\x04list\x18\x01 \x01(\v2\x1d.productv1.ListOfStorage.ListR\x04list\x1a0\n" + "\x04List\x12(\n" + - "\x05items\x18\x01 \x03(\v2\x12.productv1.StorageR\x05items\"^\n" + + "\x05items\x18\x01 \x03(\v2\x12.productv1.StorageR\x05items\"\x80\x01\n" + + "\x11ListOfStorageItem\x125\n" + + "\x04list\x18\x01 \x01(\v2!.productv1.ListOfStorageItem.ListR\x04list\x1a4\n" + + "\x04List\x12,\n" + + "\x05items\x18\x01 \x03(\v2\x16.productv1.StorageItemR\x05items\"\x8c\x01\n" + + "\x15ListOfStorageMetadata\x129\n" + + "\x04list\x18\x01 \x01(\v2%.productv1.ListOfStorageMetadata.ListR\x04list\x1a8\n" + + "\x04List\x120\n" + + "\x05items\x18\x01 \x03(\v2\x1a.productv1.StorageMetadataR\x05items\"\xa1\x01\n" + + "\x1cListOfStorageOperationResult\x12@\n" + + "\x04list\x18\x01 \x01(\v2,.productv1.ListOfStorageOperationResult.ListR\x04list\x1a?\n" + + "\x04List\x127\n" + + "\x05items\x18\x01 \x03(\v2!.productv1.StorageOperationResultR\x05items\"^\n" + "\fListOfString\x120\n" + "\x04list\x18\x01 \x01(\v2\x1c.productv1.ListOfString.ListR\x04list\x1a\x1c\n" + "\x04List\x12\x14\n" + @@ -25898,7 +27290,36 @@ const file_product_proto_rawDesc = "" + "\x10metadata_history\x18\x01 \x03(\v2K.productv1.RequireStorageProcessedMetadataHistoryByIdFields.StorageMetadataR\x0fmetadataHistory\x1aA\n" + "\x0fStorageMetadata\x12\x1a\n" + "\bcapacity\x18\x01 \x01(\x05R\bcapacity\x12\x12\n" + - "\x04zone\x18\x02 \x01(\tR\x04zone\"q\n" + + "\x04zone\x18\x02 \x01(\tR\x04zone\"\x9b\x01\n" + + "9RequireStorageOptionalProcessedMetadataHistoryByIdRequest\x12^\n" + + "\acontext\x18\x01 \x03(\v2D.productv1.RequireStorageOptionalProcessedMetadataHistoryByIdContextR\acontext\"\xd2\x01\n" + + "9RequireStorageOptionalProcessedMetadataHistoryByIdContext\x128\n" + + "\x03key\x18\x01 \x01(\v2&.productv1.LookupStorageByIdRequestKeyR\x03key\x12[\n" + + "\x06fields\x18\x02 \x01(\v2C.productv1.RequireStorageOptionalProcessedMetadataHistoryByIdFieldsR\x06fields\"\x99\x01\n" + + ":RequireStorageOptionalProcessedMetadataHistoryByIdResponse\x12[\n" + + "\x06result\x18\x01 \x03(\v2C.productv1.RequireStorageOptionalProcessedMetadataHistoryByIdResultR\x06result\"\xab\x01\n" + + "8RequireStorageOptionalProcessedMetadataHistoryByIdResult\x12o\n" + + "#optional_processed_metadata_history\x18\x01 \x01(\v2 .productv1.ListOfStorageMetadataR optionalProcessedMetadataHistory\"\xfd\x01\n" + + "8RequireStorageOptionalProcessedMetadataHistoryByIdFields\x12~\n" + + "\x10metadata_history\x18\x01 \x03(\v2S.productv1.RequireStorageOptionalProcessedMetadataHistoryByIdFields.StorageMetadataR\x0fmetadataHistory\x1aA\n" + + "\x0fStorageMetadata\x12\x1a\n" + + "\bcapacity\x18\x01 \x01(\x05R\bcapacity\x12\x12\n" + + "\x04zone\x18\x02 \x01(\tR\x04zone\"\xc4\x01\n" + + "&RequireStorageTagsByLengthsByIdRequest\x12K\n" + + "\acontext\x18\x01 \x03(\v21.productv1.RequireStorageTagsByLengthsByIdContextR\acontext\x12M\n" + + "\n" + + "field_args\x18\x02 \x01(\v2..productv1.RequireStorageTagsByLengthsByIdArgsR\tfieldArgs\"\xac\x01\n" + + "&RequireStorageTagsByLengthsByIdContext\x128\n" + + "\x03key\x18\x01 \x01(\v2&.productv1.LookupStorageByIdRequestKeyR\x03key\x12H\n" + + "\x06fields\x18\x02 \x01(\v20.productv1.RequireStorageTagsByLengthsByIdFieldsR\x06fields\"U\n" + + "#RequireStorageTagsByLengthsByIdArgs\x12.\n" + + "\alengths\x18\x01 \x01(\v2\x14.productv1.ListOfIntR\alengths\"s\n" + + "'RequireStorageTagsByLengthsByIdResponse\x12H\n" + + "\x06result\x18\x01 \x03(\v20.productv1.RequireStorageTagsByLengthsByIdResultR\x06result\"h\n" + + "%RequireStorageTagsByLengthsByIdResult\x12?\n" + + "\x0ftags_by_lengths\x18\x01 \x01(\v2\x17.productv1.ListOfStringR\rtagsByLengths\";\n" + + "%RequireStorageTagsByLengthsByIdFields\x12\x12\n" + + "\x04tags\x18\x01 \x03(\tR\x04tags\"q\n" + "$RequireStorageKindSummaryByIdRequest\x12I\n" + "\acontext\x18\x01 \x03(\v2/.productv1.RequireStorageKindSummaryByIdContextR\acontext\"\xa8\x01\n" + "$RequireStorageKindSummaryByIdContext\x128\n" + @@ -26148,7 +27569,29 @@ const file_product_proto_rawDesc = "" + "/RequireStorageOptionalLatestOperationByIdResult\x12]\n" + "\x19optional_latest_operation\x18\x01 \x01(\v2!.productv1.StorageOperationResultR\x17optionalLatestOperation\"o\n" + "/RequireStorageOptionalLatestOperationByIdFields\x12<\n" + - "\roptional_tags\x18\x01 \x01(\v2\x17.productv1.ListOfStringR\foptionalTags\"\xd3\x01\n" + + "\roptional_tags\x18\x01 \x01(\v2\x17.productv1.ListOfStringR\foptionalTags\"\x8b\x01\n" + + "1RequireStorageOptionalRecommendedItemsByIdRequest\x12V\n" + + "\acontext\x18\x01 \x03(\v2<.productv1.RequireStorageOptionalRecommendedItemsByIdContextR\acontext\"\xc2\x01\n" + + "1RequireStorageOptionalRecommendedItemsByIdContext\x128\n" + + "\x03key\x18\x01 \x01(\v2&.productv1.LookupStorageByIdRequestKeyR\x03key\x12S\n" + + "\x06fields\x18\x02 \x01(\v2;.productv1.RequireStorageOptionalRecommendedItemsByIdFieldsR\x06fields\"\x89\x01\n" + + "2RequireStorageOptionalRecommendedItemsByIdResponse\x12S\n" + + "\x06result\x18\x01 \x03(\v2;.productv1.RequireStorageOptionalRecommendedItemsByIdResultR\x06result\"\x8e\x01\n" + + "0RequireStorageOptionalRecommendedItemsByIdResult\x12Z\n" + + "\x1aoptional_recommended_items\x18\x01 \x01(\v2\x1c.productv1.ListOfStorageItemR\x18optionalRecommendedItems\"F\n" + + "0RequireStorageOptionalRecommendedItemsByIdFields\x12\x12\n" + + "\x04tags\x18\x01 \x03(\tR\x04tags\"\x8b\x01\n" + + "1RequireStorageOptionalOperationHistoryByIdRequest\x12V\n" + + "\acontext\x18\x01 \x03(\v2<.productv1.RequireStorageOptionalOperationHistoryByIdContextR\acontext\"\xc2\x01\n" + + "1RequireStorageOptionalOperationHistoryByIdContext\x128\n" + + "\x03key\x18\x01 \x01(\v2&.productv1.LookupStorageByIdRequestKeyR\x03key\x12S\n" + + "\x06fields\x18\x02 \x01(\v2;.productv1.RequireStorageOptionalOperationHistoryByIdFieldsR\x06fields\"\x89\x01\n" + + "2RequireStorageOptionalOperationHistoryByIdResponse\x12S\n" + + "\x06result\x18\x01 \x03(\v2;.productv1.RequireStorageOptionalOperationHistoryByIdResultR\x06result\"\x99\x01\n" + + "0RequireStorageOptionalOperationHistoryByIdResult\x12e\n" + + "\x1aoptional_operation_history\x18\x01 \x01(\v2'.productv1.ListOfStorageOperationResultR\x18optionalOperationHistory\"n\n" + + "0RequireStorageOptionalOperationHistoryByIdFields\x12:\n" + + "\fstorage_kind\x18\x01 \x01(\x0e2\x17.productv1.CategoryKindR\vstorageKind\"\xd3\x01\n" + "+RequireStorageFilteredTagSummaryByIdRequest\x12P\n" + "\acontext\x18\x01 \x03(\v26.productv1.RequireStorageFilteredTagSummaryByIdContextR\acontext\x12R\n" + "\n" + @@ -26609,7 +28052,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\xa4b\n" + + "\"SHIPPING_DESTINATION_INTERNATIONAL\x10\x032\xd3g\n" + "\x0eProductService\x12`\n" + "\x11LookupProductById\x12#.productv1.LookupProductByIdRequest\x1a$.productv1.LookupProductByIdResponse\"\x00\x12`\n" + "\x11LookupStorageById\x12#.productv1.LookupStorageByIdRequest\x1a$.productv1.LookupStorageByIdResponse\"\x00\x12f\n" + @@ -26673,9 +28116,12 @@ const file_product_proto_rawDesc = "" + ")RequireStorageMultiFilteredTagSummaryById\x12;.productv1.RequireStorageMultiFilteredTagSummaryByIdRequest\x1a<.productv1.RequireStorageMultiFilteredTagSummaryByIdResponse\"\x00\x12\xb1\x01\n" + ",RequireStorageNullableFilteredTagSummaryById\x12>.productv1.RequireStorageNullableFilteredTagSummaryByIdRequest\x1a?.productv1.RequireStorageNullableFilteredTagSummaryByIdResponse\"\x00\x12\x90\x01\n" + "!RequireStorageOperationReportById\x123.productv1.RequireStorageOperationReportByIdRequest\x1a4.productv1.RequireStorageOperationReportByIdResponse\"\x00\x12\xa8\x01\n" + - ")RequireStorageOptionalLatestOperationById\x12;.productv1.RequireStorageOptionalLatestOperationByIdRequest\x1a<.productv1.RequireStorageOptionalLatestOperationByIdResponse\"\x00\x12\xae\x01\n" + - "+RequireStorageOptionalProcessedMetadataById\x12=.productv1.RequireStorageOptionalProcessedMetadataByIdRequest\x1a>.productv1.RequireStorageOptionalProcessedMetadataByIdResponse\"\x00\x12\xa2\x01\n" + - "'RequireStorageOptionalProcessedTagsById\x129.productv1.RequireStorageOptionalProcessedTagsByIdRequest\x1a:.productv1.RequireStorageOptionalProcessedTagsByIdResponse\"\x00\x12\x99\x01\n" + + ")RequireStorageOptionalLatestOperationById\x12;.productv1.RequireStorageOptionalLatestOperationByIdRequest\x1a<.productv1.RequireStorageOptionalLatestOperationByIdResponse\"\x00\x12\xab\x01\n" + + "*RequireStorageOptionalOperationHistoryById\x12<.productv1.RequireStorageOptionalOperationHistoryByIdRequest\x1a=.productv1.RequireStorageOptionalOperationHistoryByIdResponse\"\x00\x12\xae\x01\n" + + "+RequireStorageOptionalProcessedMetadataById\x12=.productv1.RequireStorageOptionalProcessedMetadataByIdRequest\x1a>.productv1.RequireStorageOptionalProcessedMetadataByIdResponse\"\x00\x12\xc3\x01\n" + + "2RequireStorageOptionalProcessedMetadataHistoryById\x12D.productv1.RequireStorageOptionalProcessedMetadataHistoryByIdRequest\x1aE.productv1.RequireStorageOptionalProcessedMetadataHistoryByIdResponse\"\x00\x12\xa2\x01\n" + + "'RequireStorageOptionalProcessedTagsById\x129.productv1.RequireStorageOptionalProcessedTagsByIdRequest\x1a:.productv1.RequireStorageOptionalProcessedTagsByIdResponse\"\x00\x12\xab\x01\n" + + "*RequireStorageOptionalRecommendedItemsById\x12<.productv1.RequireStorageOptionalRecommendedItemsByIdRequest\x1a=.productv1.RequireStorageOptionalRecommendedItemsByIdResponse\"\x00\x12\x99\x01\n" + "$RequireStorageOptionalTagSummaryById\x126.productv1.RequireStorageOptionalTagSummaryByIdRequest\x1a7.productv1.RequireStorageOptionalTagSummaryByIdResponse\"\x00\x12\x96\x01\n" + "#RequireStorageProcessedMetadataById\x125.productv1.RequireStorageProcessedMetadataByIdRequest\x1a6.productv1.RequireStorageProcessedMetadataByIdResponse\"\x00\x12\xab\x01\n" + "*RequireStorageProcessedMetadataHistoryById\x12<.productv1.RequireStorageProcessedMetadataHistoryByIdRequest\x1a=.productv1.RequireStorageProcessedMetadataHistoryByIdResponse\"\x00\x12\x8a\x01\n" + @@ -26684,7 +28130,8 @@ const file_product_proto_rawDesc = "" + "\"RequireStorageRecommendedItemsById\x124.productv1.RequireStorageRecommendedItemsByIdRequest\x1a5.productv1.RequireStorageRecommendedItemsByIdResponse\"\x00\x12\x90\x01\n" + "!RequireStorageSecuritySummaryById\x123.productv1.RequireStorageSecuritySummaryByIdRequest\x1a4.productv1.RequireStorageSecuritySummaryByIdResponse\"\x00\x12\x93\x01\n" + "\"RequireStorageStockHealthScoreById\x124.productv1.RequireStorageStockHealthScoreByIdRequest\x1a5.productv1.RequireStorageStockHealthScoreByIdResponse\"\x00\x12\x81\x01\n" + - "\x1cRequireStorageTagSummaryById\x12..productv1.RequireStorageTagSummaryByIdRequest\x1a/.productv1.RequireStorageTagSummaryByIdResponse\"\x00\x12\x99\x01\n" + + "\x1cRequireStorageTagSummaryById\x12..productv1.RequireStorageTagSummaryByIdRequest\x1a/.productv1.RequireStorageTagSummaryByIdResponse\"\x00\x12\x8a\x01\n" + + "\x1fRequireStorageTagsByLengthsById\x121.productv1.RequireStorageTagsByLengthsByIdRequest\x1a2.productv1.RequireStorageTagsByLengthsByIdResponse\"\x00\x12\x99\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" + @@ -26725,1222 +28172,1291 @@ func file_product_proto_rawDescGZIP() []byte { } var file_product_proto_enumTypes = make([]protoimpl.EnumInfo, 2) -var file_product_proto_msgTypes = make([]protoimpl.MessageInfo, 501) +var file_product_proto_msgTypes = make([]protoimpl.MessageInfo, 531) var file_product_proto_goTypes = []any{ - (CategoryKind)(0), // 0: productv1.CategoryKind - (ShippingDestination)(0), // 1: productv1.ShippingDestination - (*ListOfAuthorFilter)(nil), // 2: productv1.ListOfAuthorFilter - (*ListOfAuthorInput)(nil), // 3: productv1.ListOfAuthorInput - (*ListOfBlogPost)(nil), // 4: productv1.ListOfBlogPost - (*ListOfBlogPostFilter)(nil), // 5: productv1.ListOfBlogPostFilter - (*ListOfBlogPostInput)(nil), // 6: productv1.ListOfBlogPostInput - (*ListOfBoolean)(nil), // 7: productv1.ListOfBoolean - (*ListOfCategory)(nil), // 8: productv1.ListOfCategory - (*ListOfCategoryInput)(nil), // 9: productv1.ListOfCategoryInput - (*ListOfConditionsInput)(nil), // 10: productv1.ListOfConditionsInput - (*ListOfFloat)(nil), // 11: productv1.ListOfFloat - (*ListOfListOfCategory)(nil), // 12: productv1.ListOfListOfCategory - (*ListOfListOfCategoryInput)(nil), // 13: productv1.ListOfListOfCategoryInput - (*ListOfListOfString)(nil), // 14: productv1.ListOfListOfString - (*ListOfListOfUser)(nil), // 15: productv1.ListOfListOfUser - (*ListOfListOfUserInput)(nil), // 16: productv1.ListOfListOfUserInput - (*ListOfOrderLine)(nil), // 17: productv1.ListOfOrderLine - (*ListOfProduct)(nil), // 18: productv1.ListOfProduct - (*ListOfStorage)(nil), // 19: productv1.ListOfStorage - (*ListOfString)(nil), // 20: productv1.ListOfString - (*ListOfSubcategory)(nil), // 21: productv1.ListOfSubcategory - (*ListOfUser)(nil), // 22: productv1.ListOfUser - (*ListOfUserInput)(nil), // 23: productv1.ListOfUserInput - (*LookupProductByIdRequestKey)(nil), // 24: productv1.LookupProductByIdRequestKey - (*LookupProductByIdRequest)(nil), // 25: productv1.LookupProductByIdRequest - (*LookupProductByIdResponse)(nil), // 26: productv1.LookupProductByIdResponse - (*LookupStorageByIdRequestKey)(nil), // 27: productv1.LookupStorageByIdRequestKey - (*LookupStorageByIdRequest)(nil), // 28: productv1.LookupStorageByIdRequest - (*LookupStorageByIdResponse)(nil), // 29: productv1.LookupStorageByIdResponse - (*LookupWarehouseByIdRequestKey)(nil), // 30: productv1.LookupWarehouseByIdRequestKey - (*LookupWarehouseByIdRequest)(nil), // 31: productv1.LookupWarehouseByIdRequest - (*LookupWarehouseByIdResponse)(nil), // 32: productv1.LookupWarehouseByIdResponse - (*QueryUsersRequest)(nil), // 33: productv1.QueryUsersRequest - (*QueryUsersResponse)(nil), // 34: productv1.QueryUsersResponse - (*QueryUserRequest)(nil), // 35: productv1.QueryUserRequest - (*QueryUserResponse)(nil), // 36: productv1.QueryUserResponse - (*QueryNestedTypeRequest)(nil), // 37: productv1.QueryNestedTypeRequest - (*QueryNestedTypeResponse)(nil), // 38: productv1.QueryNestedTypeResponse - (*QueryRecursiveTypeRequest)(nil), // 39: productv1.QueryRecursiveTypeRequest - (*QueryRecursiveTypeResponse)(nil), // 40: productv1.QueryRecursiveTypeResponse - (*QueryTypeFilterWithArgumentsRequest)(nil), // 41: productv1.QueryTypeFilterWithArgumentsRequest - (*QueryTypeFilterWithArgumentsResponse)(nil), // 42: productv1.QueryTypeFilterWithArgumentsResponse - (*QueryTypeWithMultipleFilterFieldsRequest)(nil), // 43: productv1.QueryTypeWithMultipleFilterFieldsRequest - (*QueryTypeWithMultipleFilterFieldsResponse)(nil), // 44: productv1.QueryTypeWithMultipleFilterFieldsResponse - (*QueryComplexFilterTypeRequest)(nil), // 45: productv1.QueryComplexFilterTypeRequest - (*QueryComplexFilterTypeResponse)(nil), // 46: productv1.QueryComplexFilterTypeResponse - (*QueryCalculateTotalsRequest)(nil), // 47: productv1.QueryCalculateTotalsRequest - (*QueryCalculateTotalsResponse)(nil), // 48: productv1.QueryCalculateTotalsResponse - (*QueryCategoriesRequest)(nil), // 49: productv1.QueryCategoriesRequest - (*QueryCategoriesResponse)(nil), // 50: productv1.QueryCategoriesResponse - (*QueryCategoryRequest)(nil), // 51: productv1.QueryCategoryRequest - (*QueryCategoryResponse)(nil), // 52: productv1.QueryCategoryResponse - (*QueryCategoriesByKindRequest)(nil), // 53: productv1.QueryCategoriesByKindRequest - (*QueryCategoriesByKindResponse)(nil), // 54: productv1.QueryCategoriesByKindResponse - (*QueryCategoriesByKindsRequest)(nil), // 55: productv1.QueryCategoriesByKindsRequest - (*QueryCategoriesByKindsResponse)(nil), // 56: productv1.QueryCategoriesByKindsResponse - (*QueryFilterCategoriesRequest)(nil), // 57: productv1.QueryFilterCategoriesRequest - (*QueryFilterCategoriesResponse)(nil), // 58: productv1.QueryFilterCategoriesResponse - (*QueryRandomPetRequest)(nil), // 59: productv1.QueryRandomPetRequest - (*QueryRandomPetResponse)(nil), // 60: productv1.QueryRandomPetResponse - (*QueryAllPetsRequest)(nil), // 61: productv1.QueryAllPetsRequest - (*QueryAllPetsResponse)(nil), // 62: productv1.QueryAllPetsResponse - (*QuerySearchRequest)(nil), // 63: productv1.QuerySearchRequest - (*QuerySearchResponse)(nil), // 64: productv1.QuerySearchResponse - (*QueryRandomSearchResultRequest)(nil), // 65: productv1.QueryRandomSearchResultRequest - (*QueryRandomSearchResultResponse)(nil), // 66: productv1.QueryRandomSearchResultResponse - (*QueryNullableFieldsTypeRequest)(nil), // 67: productv1.QueryNullableFieldsTypeRequest - (*QueryNullableFieldsTypeResponse)(nil), // 68: productv1.QueryNullableFieldsTypeResponse - (*QueryNullableFieldsTypeByIdRequest)(nil), // 69: productv1.QueryNullableFieldsTypeByIdRequest - (*QueryNullableFieldsTypeByIdResponse)(nil), // 70: productv1.QueryNullableFieldsTypeByIdResponse - (*QueryNullableFieldsTypeWithFilterRequest)(nil), // 71: productv1.QueryNullableFieldsTypeWithFilterRequest - (*QueryNullableFieldsTypeWithFilterResponse)(nil), // 72: productv1.QueryNullableFieldsTypeWithFilterResponse - (*QueryAllNullableFieldsTypesRequest)(nil), // 73: productv1.QueryAllNullableFieldsTypesRequest - (*QueryAllNullableFieldsTypesResponse)(nil), // 74: productv1.QueryAllNullableFieldsTypesResponse - (*QueryBlogPostRequest)(nil), // 75: productv1.QueryBlogPostRequest - (*QueryBlogPostResponse)(nil), // 76: productv1.QueryBlogPostResponse - (*QueryBlogPostByIdRequest)(nil), // 77: productv1.QueryBlogPostByIdRequest - (*QueryBlogPostByIdResponse)(nil), // 78: productv1.QueryBlogPostByIdResponse - (*QueryBlogPostsWithFilterRequest)(nil), // 79: productv1.QueryBlogPostsWithFilterRequest - (*QueryBlogPostsWithFilterResponse)(nil), // 80: productv1.QueryBlogPostsWithFilterResponse - (*QueryAllBlogPostsRequest)(nil), // 81: productv1.QueryAllBlogPostsRequest - (*QueryAllBlogPostsResponse)(nil), // 82: productv1.QueryAllBlogPostsResponse - (*QueryAuthorRequest)(nil), // 83: productv1.QueryAuthorRequest - (*QueryAuthorResponse)(nil), // 84: productv1.QueryAuthorResponse - (*QueryAuthorByIdRequest)(nil), // 85: productv1.QueryAuthorByIdRequest - (*QueryAuthorByIdResponse)(nil), // 86: productv1.QueryAuthorByIdResponse - (*QueryAuthorsWithFilterRequest)(nil), // 87: productv1.QueryAuthorsWithFilterRequest - (*QueryAuthorsWithFilterResponse)(nil), // 88: productv1.QueryAuthorsWithFilterResponse - (*QueryAllAuthorsRequest)(nil), // 89: productv1.QueryAllAuthorsRequest - (*QueryAllAuthorsResponse)(nil), // 90: productv1.QueryAllAuthorsResponse - (*QueryBulkSearchAuthorsRequest)(nil), // 91: productv1.QueryBulkSearchAuthorsRequest - (*QueryBulkSearchAuthorsResponse)(nil), // 92: productv1.QueryBulkSearchAuthorsResponse - (*QueryBulkSearchBlogPostsRequest)(nil), // 93: productv1.QueryBulkSearchBlogPostsRequest - (*QueryBulkSearchBlogPostsResponse)(nil), // 94: productv1.QueryBulkSearchBlogPostsResponse - (*QueryTestContainerRequest)(nil), // 95: productv1.QueryTestContainerRequest - (*QueryTestContainerResponse)(nil), // 96: productv1.QueryTestContainerResponse - (*QueryTestContainersRequest)(nil), // 97: productv1.QueryTestContainersRequest - (*QueryTestContainersResponse)(nil), // 98: productv1.QueryTestContainersResponse - (*QueryConditionalSearchRequest)(nil), // 99: productv1.QueryConditionalSearchRequest - (*QueryConditionalSearchResponse)(nil), // 100: productv1.QueryConditionalSearchResponse - (*MutationCreateUserRequest)(nil), // 101: productv1.MutationCreateUserRequest - (*MutationCreateUserResponse)(nil), // 102: productv1.MutationCreateUserResponse - (*MutationPerformActionRequest)(nil), // 103: productv1.MutationPerformActionRequest - (*MutationPerformActionResponse)(nil), // 104: productv1.MutationPerformActionResponse - (*MutationCreateNullableFieldsTypeRequest)(nil), // 105: productv1.MutationCreateNullableFieldsTypeRequest - (*MutationCreateNullableFieldsTypeResponse)(nil), // 106: productv1.MutationCreateNullableFieldsTypeResponse - (*MutationUpdateNullableFieldsTypeRequest)(nil), // 107: productv1.MutationUpdateNullableFieldsTypeRequest - (*MutationUpdateNullableFieldsTypeResponse)(nil), // 108: productv1.MutationUpdateNullableFieldsTypeResponse - (*MutationCreateBlogPostRequest)(nil), // 109: productv1.MutationCreateBlogPostRequest - (*MutationCreateBlogPostResponse)(nil), // 110: productv1.MutationCreateBlogPostResponse - (*MutationUpdateBlogPostRequest)(nil), // 111: productv1.MutationUpdateBlogPostRequest - (*MutationUpdateBlogPostResponse)(nil), // 112: productv1.MutationUpdateBlogPostResponse - (*MutationCreateAuthorRequest)(nil), // 113: productv1.MutationCreateAuthorRequest - (*MutationCreateAuthorResponse)(nil), // 114: productv1.MutationCreateAuthorResponse - (*MutationUpdateAuthorRequest)(nil), // 115: productv1.MutationUpdateAuthorRequest - (*MutationUpdateAuthorResponse)(nil), // 116: productv1.MutationUpdateAuthorResponse - (*MutationBulkCreateAuthorsRequest)(nil), // 117: productv1.MutationBulkCreateAuthorsRequest - (*MutationBulkCreateAuthorsResponse)(nil), // 118: productv1.MutationBulkCreateAuthorsResponse - (*MutationBulkUpdateAuthorsRequest)(nil), // 119: productv1.MutationBulkUpdateAuthorsRequest - (*MutationBulkUpdateAuthorsResponse)(nil), // 120: productv1.MutationBulkUpdateAuthorsResponse - (*MutationBulkCreateBlogPostsRequest)(nil), // 121: productv1.MutationBulkCreateBlogPostsRequest - (*MutationBulkCreateBlogPostsResponse)(nil), // 122: productv1.MutationBulkCreateBlogPostsResponse - (*MutationBulkUpdateBlogPostsRequest)(nil), // 123: productv1.MutationBulkUpdateBlogPostsRequest - (*MutationBulkUpdateBlogPostsResponse)(nil), // 124: productv1.MutationBulkUpdateBlogPostsResponse - (*ResolveProductShippingEstimateArgs)(nil), // 125: productv1.ResolveProductShippingEstimateArgs - (*ResolveProductShippingEstimateContext)(nil), // 126: productv1.ResolveProductShippingEstimateContext - (*ResolveProductShippingEstimateRequest)(nil), // 127: productv1.ResolveProductShippingEstimateRequest - (*ResolveProductShippingEstimateResult)(nil), // 128: productv1.ResolveProductShippingEstimateResult - (*ResolveProductShippingEstimateResponse)(nil), // 129: productv1.ResolveProductShippingEstimateResponse - (*ResolveProductRecommendedCategoryArgs)(nil), // 130: productv1.ResolveProductRecommendedCategoryArgs - (*ResolveProductRecommendedCategoryContext)(nil), // 131: productv1.ResolveProductRecommendedCategoryContext - (*ResolveProductRecommendedCategoryRequest)(nil), // 132: productv1.ResolveProductRecommendedCategoryRequest - (*ResolveProductRecommendedCategoryResult)(nil), // 133: productv1.ResolveProductRecommendedCategoryResult - (*ResolveProductRecommendedCategoryResponse)(nil), // 134: productv1.ResolveProductRecommendedCategoryResponse - (*ResolveProductMascotRecommendationArgs)(nil), // 135: productv1.ResolveProductMascotRecommendationArgs - (*ResolveProductMascotRecommendationContext)(nil), // 136: productv1.ResolveProductMascotRecommendationContext - (*ResolveProductMascotRecommendationRequest)(nil), // 137: productv1.ResolveProductMascotRecommendationRequest - (*ResolveProductMascotRecommendationResult)(nil), // 138: productv1.ResolveProductMascotRecommendationResult - (*ResolveProductMascotRecommendationResponse)(nil), // 139: productv1.ResolveProductMascotRecommendationResponse - (*ResolveProductStockStatusArgs)(nil), // 140: productv1.ResolveProductStockStatusArgs - (*ResolveProductStockStatusContext)(nil), // 141: productv1.ResolveProductStockStatusContext - (*ResolveProductStockStatusRequest)(nil), // 142: productv1.ResolveProductStockStatusRequest - (*ResolveProductStockStatusResult)(nil), // 143: productv1.ResolveProductStockStatusResult - (*ResolveProductStockStatusResponse)(nil), // 144: productv1.ResolveProductStockStatusResponse - (*ResolveProductProductDetailsArgs)(nil), // 145: productv1.ResolveProductProductDetailsArgs - (*ResolveProductProductDetailsContext)(nil), // 146: productv1.ResolveProductProductDetailsContext - (*ResolveProductProductDetailsRequest)(nil), // 147: productv1.ResolveProductProductDetailsRequest - (*ResolveProductProductDetailsResult)(nil), // 148: productv1.ResolveProductProductDetailsResult - (*ResolveProductProductDetailsResponse)(nil), // 149: productv1.ResolveProductProductDetailsResponse - (*ResolveStorageStorageStatusArgs)(nil), // 150: productv1.ResolveStorageStorageStatusArgs - (*ResolveStorageStorageStatusContext)(nil), // 151: productv1.ResolveStorageStorageStatusContext - (*ResolveStorageStorageStatusRequest)(nil), // 152: productv1.ResolveStorageStorageStatusRequest - (*ResolveStorageStorageStatusResult)(nil), // 153: productv1.ResolveStorageStorageStatusResult - (*ResolveStorageStorageStatusResponse)(nil), // 154: productv1.ResolveStorageStorageStatusResponse - (*ResolveStorageLinkedStoragesArgs)(nil), // 155: productv1.ResolveStorageLinkedStoragesArgs - (*ResolveStorageLinkedStoragesContext)(nil), // 156: productv1.ResolveStorageLinkedStoragesContext - (*ResolveStorageLinkedStoragesRequest)(nil), // 157: productv1.ResolveStorageLinkedStoragesRequest - (*ResolveStorageLinkedStoragesResult)(nil), // 158: productv1.ResolveStorageLinkedStoragesResult - (*ResolveStorageLinkedStoragesResponse)(nil), // 159: productv1.ResolveStorageLinkedStoragesResponse - (*ResolveStorageNearbyStoragesArgs)(nil), // 160: productv1.ResolveStorageNearbyStoragesArgs - (*ResolveStorageNearbyStoragesContext)(nil), // 161: productv1.ResolveStorageNearbyStoragesContext - (*ResolveStorageNearbyStoragesRequest)(nil), // 162: productv1.ResolveStorageNearbyStoragesRequest - (*ResolveStorageNearbyStoragesResult)(nil), // 163: productv1.ResolveStorageNearbyStoragesResult - (*ResolveStorageNearbyStoragesResponse)(nil), // 164: productv1.ResolveStorageNearbyStoragesResponse - (*ResolveCategoryProductCountArgs)(nil), // 165: productv1.ResolveCategoryProductCountArgs - (*ResolveCategoryProductCountContext)(nil), // 166: productv1.ResolveCategoryProductCountContext - (*ResolveCategoryProductCountRequest)(nil), // 167: productv1.ResolveCategoryProductCountRequest - (*ResolveCategoryProductCountResult)(nil), // 168: productv1.ResolveCategoryProductCountResult - (*ResolveCategoryProductCountResponse)(nil), // 169: productv1.ResolveCategoryProductCountResponse - (*ResolveCategoryPopularityScoreArgs)(nil), // 170: productv1.ResolveCategoryPopularityScoreArgs - (*ResolveCategoryPopularityScoreContext)(nil), // 171: productv1.ResolveCategoryPopularityScoreContext - (*ResolveCategoryPopularityScoreRequest)(nil), // 172: productv1.ResolveCategoryPopularityScoreRequest - (*ResolveCategoryPopularityScoreResult)(nil), // 173: productv1.ResolveCategoryPopularityScoreResult - (*ResolveCategoryPopularityScoreResponse)(nil), // 174: productv1.ResolveCategoryPopularityScoreResponse - (*ResolveCategoryCategoryMetricsArgs)(nil), // 175: productv1.ResolveCategoryCategoryMetricsArgs - (*ResolveCategoryCategoryMetricsContext)(nil), // 176: productv1.ResolveCategoryCategoryMetricsContext - (*ResolveCategoryCategoryMetricsRequest)(nil), // 177: productv1.ResolveCategoryCategoryMetricsRequest - (*ResolveCategoryCategoryMetricsResult)(nil), // 178: productv1.ResolveCategoryCategoryMetricsResult - (*ResolveCategoryCategoryMetricsResponse)(nil), // 179: productv1.ResolveCategoryCategoryMetricsResponse - (*ResolveCategoryMascotArgs)(nil), // 180: productv1.ResolveCategoryMascotArgs - (*ResolveCategoryMascotContext)(nil), // 181: productv1.ResolveCategoryMascotContext - (*ResolveCategoryMascotRequest)(nil), // 182: productv1.ResolveCategoryMascotRequest - (*ResolveCategoryMascotResult)(nil), // 183: productv1.ResolveCategoryMascotResult - (*ResolveCategoryMascotResponse)(nil), // 184: productv1.ResolveCategoryMascotResponse - (*ResolveCategoryCategoryStatusArgs)(nil), // 185: productv1.ResolveCategoryCategoryStatusArgs - (*ResolveCategoryCategoryStatusContext)(nil), // 186: productv1.ResolveCategoryCategoryStatusContext - (*ResolveCategoryCategoryStatusRequest)(nil), // 187: productv1.ResolveCategoryCategoryStatusRequest - (*ResolveCategoryCategoryStatusResult)(nil), // 188: productv1.ResolveCategoryCategoryStatusResult - (*ResolveCategoryCategoryStatusResponse)(nil), // 189: productv1.ResolveCategoryCategoryStatusResponse - (*ResolveCategoryChildCategoriesArgs)(nil), // 190: productv1.ResolveCategoryChildCategoriesArgs - (*ResolveCategoryChildCategoriesContext)(nil), // 191: productv1.ResolveCategoryChildCategoriesContext - (*ResolveCategoryChildCategoriesRequest)(nil), // 192: productv1.ResolveCategoryChildCategoriesRequest - (*ResolveCategoryChildCategoriesResult)(nil), // 193: productv1.ResolveCategoryChildCategoriesResult - (*ResolveCategoryChildCategoriesResponse)(nil), // 194: productv1.ResolveCategoryChildCategoriesResponse - (*ResolveCategoryOptionalCategoriesArgs)(nil), // 195: productv1.ResolveCategoryOptionalCategoriesArgs - (*ResolveCategoryOptionalCategoriesContext)(nil), // 196: productv1.ResolveCategoryOptionalCategoriesContext - (*ResolveCategoryOptionalCategoriesRequest)(nil), // 197: productv1.ResolveCategoryOptionalCategoriesRequest - (*ResolveCategoryOptionalCategoriesResult)(nil), // 198: productv1.ResolveCategoryOptionalCategoriesResult - (*ResolveCategoryOptionalCategoriesResponse)(nil), // 199: productv1.ResolveCategoryOptionalCategoriesResponse - (*ResolveCategoryTotalProductsContext)(nil), // 200: productv1.ResolveCategoryTotalProductsContext - (*ResolveCategoryTotalProductsRequest)(nil), // 201: productv1.ResolveCategoryTotalProductsRequest - (*ResolveCategoryTotalProductsResult)(nil), // 202: productv1.ResolveCategoryTotalProductsResult - (*ResolveCategoryTotalProductsResponse)(nil), // 203: productv1.ResolveCategoryTotalProductsResponse - (*ResolveCategoryTopSubcategoryContext)(nil), // 204: productv1.ResolveCategoryTopSubcategoryContext - (*ResolveCategoryTopSubcategoryRequest)(nil), // 205: productv1.ResolveCategoryTopSubcategoryRequest - (*ResolveCategoryTopSubcategoryResult)(nil), // 206: productv1.ResolveCategoryTopSubcategoryResult - (*ResolveCategoryTopSubcategoryResponse)(nil), // 207: productv1.ResolveCategoryTopSubcategoryResponse - (*ResolveCategoryActiveSubcategoriesContext)(nil), // 208: productv1.ResolveCategoryActiveSubcategoriesContext - (*ResolveCategoryActiveSubcategoriesRequest)(nil), // 209: productv1.ResolveCategoryActiveSubcategoriesRequest - (*ResolveCategoryActiveSubcategoriesResult)(nil), // 210: productv1.ResolveCategoryActiveSubcategoriesResult - (*ResolveCategoryActiveSubcategoriesResponse)(nil), // 211: productv1.ResolveCategoryActiveSubcategoriesResponse - (*ResolveSubcategoryItemCountArgs)(nil), // 212: productv1.ResolveSubcategoryItemCountArgs - (*ResolveSubcategoryItemCountContext)(nil), // 213: productv1.ResolveSubcategoryItemCountContext - (*ResolveSubcategoryItemCountRequest)(nil), // 214: productv1.ResolveSubcategoryItemCountRequest - (*ResolveSubcategoryItemCountResult)(nil), // 215: productv1.ResolveSubcategoryItemCountResult - (*ResolveSubcategoryItemCountResponse)(nil), // 216: productv1.ResolveSubcategoryItemCountResponse - (*ResolveSubcategoryFeaturedCategoryArgs)(nil), // 217: productv1.ResolveSubcategoryFeaturedCategoryArgs - (*ResolveSubcategoryFeaturedCategoryContext)(nil), // 218: productv1.ResolveSubcategoryFeaturedCategoryContext - (*ResolveSubcategoryFeaturedCategoryRequest)(nil), // 219: productv1.ResolveSubcategoryFeaturedCategoryRequest - (*ResolveSubcategoryFeaturedCategoryResult)(nil), // 220: productv1.ResolveSubcategoryFeaturedCategoryResult - (*ResolveSubcategoryFeaturedCategoryResponse)(nil), // 221: productv1.ResolveSubcategoryFeaturedCategoryResponse - (*ResolveSubcategoryParentCategoryContext)(nil), // 222: productv1.ResolveSubcategoryParentCategoryContext - (*ResolveSubcategoryParentCategoryRequest)(nil), // 223: productv1.ResolveSubcategoryParentCategoryRequest - (*ResolveSubcategoryParentCategoryResult)(nil), // 224: productv1.ResolveSubcategoryParentCategoryResult - (*ResolveSubcategoryParentCategoryResponse)(nil), // 225: productv1.ResolveSubcategoryParentCategoryResponse - (*ResolveCategoryMetricsNormalizedScoreArgs)(nil), // 226: productv1.ResolveCategoryMetricsNormalizedScoreArgs - (*ResolveCategoryMetricsNormalizedScoreContext)(nil), // 227: productv1.ResolveCategoryMetricsNormalizedScoreContext - (*ResolveCategoryMetricsNormalizedScoreRequest)(nil), // 228: productv1.ResolveCategoryMetricsNormalizedScoreRequest - (*ResolveCategoryMetricsNormalizedScoreResult)(nil), // 229: productv1.ResolveCategoryMetricsNormalizedScoreResult - (*ResolveCategoryMetricsNormalizedScoreResponse)(nil), // 230: productv1.ResolveCategoryMetricsNormalizedScoreResponse - (*ResolveCategoryMetricsRelatedCategoryArgs)(nil), // 231: productv1.ResolveCategoryMetricsRelatedCategoryArgs - (*ResolveCategoryMetricsRelatedCategoryContext)(nil), // 232: productv1.ResolveCategoryMetricsRelatedCategoryContext - (*ResolveCategoryMetricsRelatedCategoryRequest)(nil), // 233: productv1.ResolveCategoryMetricsRelatedCategoryRequest - (*ResolveCategoryMetricsRelatedCategoryResult)(nil), // 234: productv1.ResolveCategoryMetricsRelatedCategoryResult - (*ResolveCategoryMetricsRelatedCategoryResponse)(nil), // 235: productv1.ResolveCategoryMetricsRelatedCategoryResponse - (*ResolveCategoryMetricsAverageScoreContext)(nil), // 236: productv1.ResolveCategoryMetricsAverageScoreContext - (*ResolveCategoryMetricsAverageScoreRequest)(nil), // 237: productv1.ResolveCategoryMetricsAverageScoreRequest - (*ResolveCategoryMetricsAverageScoreResult)(nil), // 238: productv1.ResolveCategoryMetricsAverageScoreResult - (*ResolveCategoryMetricsAverageScoreResponse)(nil), // 239: productv1.ResolveCategoryMetricsAverageScoreResponse - (*ResolveTestContainerDetailsArgs)(nil), // 240: productv1.ResolveTestContainerDetailsArgs - (*ResolveTestContainerDetailsContext)(nil), // 241: productv1.ResolveTestContainerDetailsContext - (*ResolveTestContainerDetailsRequest)(nil), // 242: productv1.ResolveTestContainerDetailsRequest - (*ResolveTestContainerDetailsResult)(nil), // 243: productv1.ResolveTestContainerDetailsResult - (*ResolveTestContainerDetailsResponse)(nil), // 244: productv1.ResolveTestContainerDetailsResponse - (*RequireStorageStockHealthScoreByIdRequest)(nil), // 245: productv1.RequireStorageStockHealthScoreByIdRequest - (*RequireStorageStockHealthScoreByIdContext)(nil), // 246: productv1.RequireStorageStockHealthScoreByIdContext - (*RequireStorageStockHealthScoreByIdResponse)(nil), // 247: productv1.RequireStorageStockHealthScoreByIdResponse - (*RequireStorageStockHealthScoreByIdResult)(nil), // 248: productv1.RequireStorageStockHealthScoreByIdResult - (*RequireStorageStockHealthScoreByIdFields)(nil), // 249: productv1.RequireStorageStockHealthScoreByIdFields - (*RequireStorageTagSummaryByIdRequest)(nil), // 250: productv1.RequireStorageTagSummaryByIdRequest - (*RequireStorageTagSummaryByIdContext)(nil), // 251: productv1.RequireStorageTagSummaryByIdContext - (*RequireStorageTagSummaryByIdResponse)(nil), // 252: productv1.RequireStorageTagSummaryByIdResponse - (*RequireStorageTagSummaryByIdResult)(nil), // 253: productv1.RequireStorageTagSummaryByIdResult - (*RequireStorageTagSummaryByIdFields)(nil), // 254: productv1.RequireStorageTagSummaryByIdFields - (*RequireStorageOptionalTagSummaryByIdRequest)(nil), // 255: productv1.RequireStorageOptionalTagSummaryByIdRequest - (*RequireStorageOptionalTagSummaryByIdContext)(nil), // 256: productv1.RequireStorageOptionalTagSummaryByIdContext - (*RequireStorageOptionalTagSummaryByIdResponse)(nil), // 257: productv1.RequireStorageOptionalTagSummaryByIdResponse - (*RequireStorageOptionalTagSummaryByIdResult)(nil), // 258: productv1.RequireStorageOptionalTagSummaryByIdResult - (*RequireStorageOptionalTagSummaryByIdFields)(nil), // 259: productv1.RequireStorageOptionalTagSummaryByIdFields - (*RequireStorageMetadataScoreByIdRequest)(nil), // 260: productv1.RequireStorageMetadataScoreByIdRequest - (*RequireStorageMetadataScoreByIdContext)(nil), // 261: productv1.RequireStorageMetadataScoreByIdContext - (*RequireStorageMetadataScoreByIdResponse)(nil), // 262: productv1.RequireStorageMetadataScoreByIdResponse - (*RequireStorageMetadataScoreByIdResult)(nil), // 263: productv1.RequireStorageMetadataScoreByIdResult - (*RequireStorageMetadataScoreByIdFields)(nil), // 264: productv1.RequireStorageMetadataScoreByIdFields - (*RequireStorageProcessedMetadataByIdRequest)(nil), // 265: productv1.RequireStorageProcessedMetadataByIdRequest - (*RequireStorageProcessedMetadataByIdContext)(nil), // 266: productv1.RequireStorageProcessedMetadataByIdContext - (*RequireStorageProcessedMetadataByIdResponse)(nil), // 267: productv1.RequireStorageProcessedMetadataByIdResponse - (*RequireStorageProcessedMetadataByIdResult)(nil), // 268: productv1.RequireStorageProcessedMetadataByIdResult - (*RequireStorageProcessedMetadataByIdFields)(nil), // 269: productv1.RequireStorageProcessedMetadataByIdFields - (*RequireStorageOptionalProcessedMetadataByIdRequest)(nil), // 270: productv1.RequireStorageOptionalProcessedMetadataByIdRequest - (*RequireStorageOptionalProcessedMetadataByIdContext)(nil), // 271: productv1.RequireStorageOptionalProcessedMetadataByIdContext - (*RequireStorageOptionalProcessedMetadataByIdResponse)(nil), // 272: productv1.RequireStorageOptionalProcessedMetadataByIdResponse - (*RequireStorageOptionalProcessedMetadataByIdResult)(nil), // 273: productv1.RequireStorageOptionalProcessedMetadataByIdResult - (*RequireStorageOptionalProcessedMetadataByIdFields)(nil), // 274: productv1.RequireStorageOptionalProcessedMetadataByIdFields - (*RequireStorageProcessedTagsByIdRequest)(nil), // 275: productv1.RequireStorageProcessedTagsByIdRequest - (*RequireStorageProcessedTagsByIdContext)(nil), // 276: productv1.RequireStorageProcessedTagsByIdContext - (*RequireStorageProcessedTagsByIdResponse)(nil), // 277: productv1.RequireStorageProcessedTagsByIdResponse - (*RequireStorageProcessedTagsByIdResult)(nil), // 278: productv1.RequireStorageProcessedTagsByIdResult - (*RequireStorageProcessedTagsByIdFields)(nil), // 279: productv1.RequireStorageProcessedTagsByIdFields - (*RequireStorageOptionalProcessedTagsByIdRequest)(nil), // 280: productv1.RequireStorageOptionalProcessedTagsByIdRequest - (*RequireStorageOptionalProcessedTagsByIdContext)(nil), // 281: productv1.RequireStorageOptionalProcessedTagsByIdContext - (*RequireStorageOptionalProcessedTagsByIdResponse)(nil), // 282: productv1.RequireStorageOptionalProcessedTagsByIdResponse - (*RequireStorageOptionalProcessedTagsByIdResult)(nil), // 283: productv1.RequireStorageOptionalProcessedTagsByIdResult - (*RequireStorageOptionalProcessedTagsByIdFields)(nil), // 284: productv1.RequireStorageOptionalProcessedTagsByIdFields - (*RequireStorageProcessedMetadataHistoryByIdRequest)(nil), // 285: productv1.RequireStorageProcessedMetadataHistoryByIdRequest - (*RequireStorageProcessedMetadataHistoryByIdContext)(nil), // 286: productv1.RequireStorageProcessedMetadataHistoryByIdContext - (*RequireStorageProcessedMetadataHistoryByIdResponse)(nil), // 287: productv1.RequireStorageProcessedMetadataHistoryByIdResponse - (*RequireStorageProcessedMetadataHistoryByIdResult)(nil), // 288: productv1.RequireStorageProcessedMetadataHistoryByIdResult - (*RequireStorageProcessedMetadataHistoryByIdFields)(nil), // 289: productv1.RequireStorageProcessedMetadataHistoryByIdFields - (*RequireStorageKindSummaryByIdRequest)(nil), // 290: productv1.RequireStorageKindSummaryByIdRequest - (*RequireStorageKindSummaryByIdContext)(nil), // 291: productv1.RequireStorageKindSummaryByIdContext - (*RequireStorageKindSummaryByIdResponse)(nil), // 292: productv1.RequireStorageKindSummaryByIdResponse - (*RequireStorageKindSummaryByIdResult)(nil), // 293: productv1.RequireStorageKindSummaryByIdResult - (*RequireStorageKindSummaryByIdFields)(nil), // 294: productv1.RequireStorageKindSummaryByIdFields - (*RequireStorageCategoryInfoSummaryByIdRequest)(nil), // 295: productv1.RequireStorageCategoryInfoSummaryByIdRequest - (*RequireStorageCategoryInfoSummaryByIdContext)(nil), // 296: productv1.RequireStorageCategoryInfoSummaryByIdContext - (*RequireStorageCategoryInfoSummaryByIdResponse)(nil), // 297: productv1.RequireStorageCategoryInfoSummaryByIdResponse - (*RequireStorageCategoryInfoSummaryByIdResult)(nil), // 298: productv1.RequireStorageCategoryInfoSummaryByIdResult - (*RequireStorageCategoryInfoSummaryByIdFields)(nil), // 299: productv1.RequireStorageCategoryInfoSummaryByIdFields - (*RequireStorageItemInfoByIdRequest)(nil), // 300: productv1.RequireStorageItemInfoByIdRequest - (*RequireStorageItemInfoByIdContext)(nil), // 301: productv1.RequireStorageItemInfoByIdContext - (*RequireStorageItemInfoByIdResponse)(nil), // 302: productv1.RequireStorageItemInfoByIdResponse - (*RequireStorageItemInfoByIdResult)(nil), // 303: productv1.RequireStorageItemInfoByIdResult - (*RequireStorageItemInfoByIdFields)(nil), // 304: productv1.RequireStorageItemInfoByIdFields - (*RequireStorageOperationReportByIdRequest)(nil), // 305: productv1.RequireStorageOperationReportByIdRequest - (*RequireStorageOperationReportByIdContext)(nil), // 306: productv1.RequireStorageOperationReportByIdContext - (*RequireStorageOperationReportByIdResponse)(nil), // 307: productv1.RequireStorageOperationReportByIdResponse - (*RequireStorageOperationReportByIdResult)(nil), // 308: productv1.RequireStorageOperationReportByIdResult - (*RequireStorageOperationReportByIdFields)(nil), // 309: productv1.RequireStorageOperationReportByIdFields - (*RequireStorageSecuritySummaryByIdRequest)(nil), // 310: productv1.RequireStorageSecuritySummaryByIdRequest - (*RequireStorageSecuritySummaryByIdContext)(nil), // 311: productv1.RequireStorageSecuritySummaryByIdContext - (*RequireStorageSecuritySummaryByIdResponse)(nil), // 312: productv1.RequireStorageSecuritySummaryByIdResponse - (*RequireStorageSecuritySummaryByIdResult)(nil), // 313: productv1.RequireStorageSecuritySummaryByIdResult - (*RequireStorageSecuritySummaryByIdFields)(nil), // 314: productv1.RequireStorageSecuritySummaryByIdFields - (*RequireStorageItemHandlerInfoByIdRequest)(nil), // 315: productv1.RequireStorageItemHandlerInfoByIdRequest - (*RequireStorageItemHandlerInfoByIdContext)(nil), // 316: productv1.RequireStorageItemHandlerInfoByIdContext - (*RequireStorageItemHandlerInfoByIdResponse)(nil), // 317: productv1.RequireStorageItemHandlerInfoByIdResponse - (*RequireStorageItemHandlerInfoByIdResult)(nil), // 318: productv1.RequireStorageItemHandlerInfoByIdResult - (*RequireStorageItemHandlerInfoByIdFields)(nil), // 319: productv1.RequireStorageItemHandlerInfoByIdFields - (*RequireStorageItemSpecsInfoByIdRequest)(nil), // 320: productv1.RequireStorageItemSpecsInfoByIdRequest - (*RequireStorageItemSpecsInfoByIdContext)(nil), // 321: productv1.RequireStorageItemSpecsInfoByIdContext - (*RequireStorageItemSpecsInfoByIdResponse)(nil), // 322: productv1.RequireStorageItemSpecsInfoByIdResponse - (*RequireStorageItemSpecsInfoByIdResult)(nil), // 323: productv1.RequireStorageItemSpecsInfoByIdResult - (*RequireStorageItemSpecsInfoByIdFields)(nil), // 324: productv1.RequireStorageItemSpecsInfoByIdFields - (*RequireStorageDeepItemInfoByIdRequest)(nil), // 325: productv1.RequireStorageDeepItemInfoByIdRequest - (*RequireStorageDeepItemInfoByIdContext)(nil), // 326: productv1.RequireStorageDeepItemInfoByIdContext - (*RequireStorageDeepItemInfoByIdResponse)(nil), // 327: productv1.RequireStorageDeepItemInfoByIdResponse - (*RequireStorageDeepItemInfoByIdResult)(nil), // 328: productv1.RequireStorageDeepItemInfoByIdResult - (*RequireStorageDeepItemInfoByIdFields)(nil), // 329: productv1.RequireStorageDeepItemInfoByIdFields - (*RequireStorageRecommendedItemByIdRequest)(nil), // 330: productv1.RequireStorageRecommendedItemByIdRequest - (*RequireStorageRecommendedItemByIdContext)(nil), // 331: productv1.RequireStorageRecommendedItemByIdContext - (*RequireStorageRecommendedItemByIdResponse)(nil), // 332: productv1.RequireStorageRecommendedItemByIdResponse - (*RequireStorageRecommendedItemByIdResult)(nil), // 333: productv1.RequireStorageRecommendedItemByIdResult - (*RequireStorageRecommendedItemByIdFields)(nil), // 334: productv1.RequireStorageRecommendedItemByIdFields - (*RequireStorageRecommendedItemsByIdRequest)(nil), // 335: productv1.RequireStorageRecommendedItemsByIdRequest - (*RequireStorageRecommendedItemsByIdContext)(nil), // 336: productv1.RequireStorageRecommendedItemsByIdContext - (*RequireStorageRecommendedItemsByIdResponse)(nil), // 337: productv1.RequireStorageRecommendedItemsByIdResponse - (*RequireStorageRecommendedItemsByIdResult)(nil), // 338: productv1.RequireStorageRecommendedItemsByIdResult - (*RequireStorageRecommendedItemsByIdFields)(nil), // 339: productv1.RequireStorageRecommendedItemsByIdFields - (*RequireStorageLatestOperationByIdRequest)(nil), // 340: productv1.RequireStorageLatestOperationByIdRequest - (*RequireStorageLatestOperationByIdContext)(nil), // 341: productv1.RequireStorageLatestOperationByIdContext - (*RequireStorageLatestOperationByIdResponse)(nil), // 342: productv1.RequireStorageLatestOperationByIdResponse - (*RequireStorageLatestOperationByIdResult)(nil), // 343: productv1.RequireStorageLatestOperationByIdResult - (*RequireStorageLatestOperationByIdFields)(nil), // 344: productv1.RequireStorageLatestOperationByIdFields - (*RequireStorageOptionalLatestOperationByIdRequest)(nil), // 345: productv1.RequireStorageOptionalLatestOperationByIdRequest - (*RequireStorageOptionalLatestOperationByIdContext)(nil), // 346: productv1.RequireStorageOptionalLatestOperationByIdContext - (*RequireStorageOptionalLatestOperationByIdResponse)(nil), // 347: productv1.RequireStorageOptionalLatestOperationByIdResponse - (*RequireStorageOptionalLatestOperationByIdResult)(nil), // 348: productv1.RequireStorageOptionalLatestOperationByIdResult - (*RequireStorageOptionalLatestOperationByIdFields)(nil), // 349: productv1.RequireStorageOptionalLatestOperationByIdFields - (*RequireStorageFilteredTagSummaryByIdRequest)(nil), // 350: productv1.RequireStorageFilteredTagSummaryByIdRequest - (*RequireStorageFilteredTagSummaryByIdContext)(nil), // 351: productv1.RequireStorageFilteredTagSummaryByIdContext - (*RequireStorageFilteredTagSummaryByIdArgs)(nil), // 352: productv1.RequireStorageFilteredTagSummaryByIdArgs - (*RequireStorageFilteredTagSummaryByIdResponse)(nil), // 353: productv1.RequireStorageFilteredTagSummaryByIdResponse - (*RequireStorageFilteredTagSummaryByIdResult)(nil), // 354: productv1.RequireStorageFilteredTagSummaryByIdResult - (*RequireStorageFilteredTagSummaryByIdFields)(nil), // 355: productv1.RequireStorageFilteredTagSummaryByIdFields - (*RequireStorageMultiFilteredTagSummaryByIdRequest)(nil), // 356: productv1.RequireStorageMultiFilteredTagSummaryByIdRequest - (*RequireStorageMultiFilteredTagSummaryByIdContext)(nil), // 357: productv1.RequireStorageMultiFilteredTagSummaryByIdContext - (*RequireStorageMultiFilteredTagSummaryByIdArgs)(nil), // 358: productv1.RequireStorageMultiFilteredTagSummaryByIdArgs - (*RequireStorageMultiFilteredTagSummaryByIdResponse)(nil), // 359: productv1.RequireStorageMultiFilteredTagSummaryByIdResponse - (*RequireStorageMultiFilteredTagSummaryByIdResult)(nil), // 360: productv1.RequireStorageMultiFilteredTagSummaryByIdResult - (*RequireStorageMultiFilteredTagSummaryByIdFields)(nil), // 361: productv1.RequireStorageMultiFilteredTagSummaryByIdFields - (*RequireStorageNullableFilteredTagSummaryByIdRequest)(nil), // 362: productv1.RequireStorageNullableFilteredTagSummaryByIdRequest - (*RequireStorageNullableFilteredTagSummaryByIdContext)(nil), // 363: productv1.RequireStorageNullableFilteredTagSummaryByIdContext - (*RequireStorageNullableFilteredTagSummaryByIdArgs)(nil), // 364: productv1.RequireStorageNullableFilteredTagSummaryByIdArgs - (*RequireStorageNullableFilteredTagSummaryByIdResponse)(nil), // 365: productv1.RequireStorageNullableFilteredTagSummaryByIdResponse - (*RequireStorageNullableFilteredTagSummaryByIdResult)(nil), // 366: productv1.RequireStorageNullableFilteredTagSummaryByIdResult - (*RequireStorageNullableFilteredTagSummaryByIdFields)(nil), // 367: productv1.RequireStorageNullableFilteredTagSummaryByIdFields - (*RequireWarehouseStockHealthScoreByIdRequest)(nil), // 368: productv1.RequireWarehouseStockHealthScoreByIdRequest - (*RequireWarehouseStockHealthScoreByIdContext)(nil), // 369: productv1.RequireWarehouseStockHealthScoreByIdContext - (*RequireWarehouseStockHealthScoreByIdResponse)(nil), // 370: productv1.RequireWarehouseStockHealthScoreByIdResponse - (*RequireWarehouseStockHealthScoreByIdResult)(nil), // 371: productv1.RequireWarehouseStockHealthScoreByIdResult - (*RequireWarehouseStockHealthScoreByIdFields)(nil), // 372: productv1.RequireWarehouseStockHealthScoreByIdFields - (*Product)(nil), // 373: productv1.Product - (*Storage)(nil), // 374: productv1.Storage - (*Warehouse)(nil), // 375: productv1.Warehouse - (*User)(nil), // 376: productv1.User - (*NestedTypeA)(nil), // 377: productv1.NestedTypeA - (*RecursiveType)(nil), // 378: productv1.RecursiveType - (*TypeWithMultipleFilterFields)(nil), // 379: productv1.TypeWithMultipleFilterFields - (*FilterTypeInput)(nil), // 380: productv1.FilterTypeInput - (*ComplexFilterTypeInput)(nil), // 381: productv1.ComplexFilterTypeInput - (*TypeWithComplexFilterInput)(nil), // 382: productv1.TypeWithComplexFilterInput - (*OrderInput)(nil), // 383: productv1.OrderInput - (*Order)(nil), // 384: productv1.Order - (*Category)(nil), // 385: productv1.Category - (*CategoryFilter)(nil), // 386: productv1.CategoryFilter - (*Animal)(nil), // 387: productv1.Animal - (*SearchInput)(nil), // 388: productv1.SearchInput - (*SearchResult)(nil), // 389: productv1.SearchResult - (*NullableFieldsType)(nil), // 390: productv1.NullableFieldsType - (*NullableFieldsFilter)(nil), // 391: productv1.NullableFieldsFilter - (*BlogPost)(nil), // 392: productv1.BlogPost - (*BlogPostFilter)(nil), // 393: productv1.BlogPostFilter - (*Author)(nil), // 394: productv1.Author - (*AuthorFilter)(nil), // 395: productv1.AuthorFilter - (*TestContainer)(nil), // 396: productv1.TestContainer - (*ConditionsInput)(nil), // 397: productv1.ConditionsInput - (*ConditionalSearchResult)(nil), // 398: productv1.ConditionalSearchResult - (*UserInput)(nil), // 399: productv1.UserInput - (*ActionInput)(nil), // 400: productv1.ActionInput - (*ActionResult)(nil), // 401: productv1.ActionResult - (*NullableFieldsInput)(nil), // 402: productv1.NullableFieldsInput - (*BlogPostInput)(nil), // 403: productv1.BlogPostInput - (*AuthorInput)(nil), // 404: productv1.AuthorInput - (*ProductDetails)(nil), // 405: productv1.ProductDetails - (*RestockData)(nil), // 406: productv1.RestockData - (*StorageMetadata)(nil), // 407: productv1.StorageMetadata - (*StorageCategoryInfo)(nil), // 408: productv1.StorageCategoryInfo - (*NestedTypeB)(nil), // 409: productv1.NestedTypeB - (*NestedTypeC)(nil), // 410: productv1.NestedTypeC - (*FilterType)(nil), // 411: productv1.FilterType - (*Pagination)(nil), // 412: productv1.Pagination - (*OrderLineInput)(nil), // 413: productv1.OrderLineInput - (*OrderLine)(nil), // 414: productv1.OrderLine - (*Subcategory)(nil), // 415: productv1.Subcategory - (*CategoryMetrics)(nil), // 416: productv1.CategoryMetrics - (*Cat)(nil), // 417: productv1.Cat - (*Dog)(nil), // 418: productv1.Dog - (*Owner)(nil), // 419: productv1.Owner - (*ContactInfo)(nil), // 420: productv1.ContactInfo - (*Address)(nil), // 421: productv1.Address - (*CatBreed)(nil), // 422: productv1.CatBreed - (*DogBreed)(nil), // 423: productv1.DogBreed - (*BreedCharacteristics)(nil), // 424: productv1.BreedCharacteristics - (*StorageItem)(nil), // 425: productv1.StorageItem - (*PalletItem)(nil), // 426: productv1.PalletItem - (*ContainerItem)(nil), // 427: productv1.ContainerItem - (*ItemHandler)(nil), // 428: productv1.ItemHandler - (*PalletSpecs)(nil), // 429: productv1.PalletSpecs - (*ContainerSpecs)(nil), // 430: productv1.ContainerSpecs - (*Dimensions)(nil), // 431: productv1.Dimensions - (*StorageOperationResult)(nil), // 432: productv1.StorageOperationResult - (*StorageSuccess)(nil), // 433: productv1.StorageSuccess - (*StorageFailure)(nil), // 434: productv1.StorageFailure - (*SecuritySetup)(nil), // 435: productv1.SecuritySetup - (*ActionSuccess)(nil), // 436: productv1.ActionSuccess - (*ActionError)(nil), // 437: productv1.ActionError - (*TestDetails)(nil), // 438: productv1.TestDetails - (*CategoryInput)(nil), // 439: productv1.CategoryInput - (*ProductCountFilter)(nil), // 440: productv1.ProductCountFilter - (*SubcategoryItemFilter)(nil), // 441: productv1.SubcategoryItemFilter - (*ShippingEstimateInput)(nil), // 442: productv1.ShippingEstimateInput - (*ListOfAuthorFilter_List)(nil), // 443: productv1.ListOfAuthorFilter.List - (*ListOfAuthorInput_List)(nil), // 444: productv1.ListOfAuthorInput.List - (*ListOfBlogPost_List)(nil), // 445: productv1.ListOfBlogPost.List - (*ListOfBlogPostFilter_List)(nil), // 446: productv1.ListOfBlogPostFilter.List - (*ListOfBlogPostInput_List)(nil), // 447: productv1.ListOfBlogPostInput.List - (*ListOfBoolean_List)(nil), // 448: productv1.ListOfBoolean.List - (*ListOfCategory_List)(nil), // 449: productv1.ListOfCategory.List - (*ListOfCategoryInput_List)(nil), // 450: productv1.ListOfCategoryInput.List - (*ListOfConditionsInput_List)(nil), // 451: productv1.ListOfConditionsInput.List - (*ListOfFloat_List)(nil), // 452: productv1.ListOfFloat.List - (*ListOfListOfCategory_List)(nil), // 453: productv1.ListOfListOfCategory.List - (*ListOfListOfCategoryInput_List)(nil), // 454: productv1.ListOfListOfCategoryInput.List - (*ListOfListOfString_List)(nil), // 455: productv1.ListOfListOfString.List - (*ListOfListOfUser_List)(nil), // 456: productv1.ListOfListOfUser.List - (*ListOfListOfUserInput_List)(nil), // 457: productv1.ListOfListOfUserInput.List - (*ListOfOrderLine_List)(nil), // 458: productv1.ListOfOrderLine.List - (*ListOfProduct_List)(nil), // 459: productv1.ListOfProduct.List - (*ListOfStorage_List)(nil), // 460: productv1.ListOfStorage.List - (*ListOfString_List)(nil), // 461: productv1.ListOfString.List - (*ListOfSubcategory_List)(nil), // 462: productv1.ListOfSubcategory.List - (*ListOfUser_List)(nil), // 463: productv1.ListOfUser.List - (*ListOfUserInput_List)(nil), // 464: productv1.ListOfUserInput.List - (*RequireStorageStockHealthScoreByIdFields_RestockData)(nil), // 465: productv1.RequireStorageStockHealthScoreByIdFields.RestockData - (*RequireStorageMetadataScoreByIdFields_StorageMetadata)(nil), // 466: productv1.RequireStorageMetadataScoreByIdFields.StorageMetadata - (*RequireStorageProcessedMetadataByIdFields_StorageMetadata)(nil), // 467: productv1.RequireStorageProcessedMetadataByIdFields.StorageMetadata - (*RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata)(nil), // 468: productv1.RequireStorageOptionalProcessedMetadataByIdFields.StorageMetadata - (*RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata)(nil), // 469: productv1.RequireStorageProcessedMetadataHistoryByIdFields.StorageMetadata - (*RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo)(nil), // 470: productv1.RequireStorageCategoryInfoSummaryByIdFields.StorageCategoryInfo - (*RequireStorageItemInfoByIdFields_PalletItem)(nil), // 471: productv1.RequireStorageItemInfoByIdFields.PalletItem - (*RequireStorageItemInfoByIdFields_ContainerItem)(nil), // 472: productv1.RequireStorageItemInfoByIdFields.ContainerItem - (*RequireStorageItemInfoByIdFields_StorageItem)(nil), // 473: productv1.RequireStorageItemInfoByIdFields.StorageItem - (*RequireStorageOperationReportByIdFields_StorageSuccess)(nil), // 474: productv1.RequireStorageOperationReportByIdFields.StorageSuccess - (*RequireStorageOperationReportByIdFields_StorageFailure)(nil), // 475: productv1.RequireStorageOperationReportByIdFields.StorageFailure - (*RequireStorageOperationReportByIdFields_StorageOperationResult)(nil), // 476: productv1.RequireStorageOperationReportByIdFields.StorageOperationResult - (*RequireStorageSecuritySummaryByIdFields_SecuritySetup)(nil), // 477: productv1.RequireStorageSecuritySummaryByIdFields.SecuritySetup - (*RequireStorageSecuritySummaryByIdFields_SecuritySetup_PalletItem)(nil), // 478: productv1.RequireStorageSecuritySummaryByIdFields.SecuritySetup.PalletItem - (*RequireStorageSecuritySummaryByIdFields_SecuritySetup_ContainerItem)(nil), // 479: productv1.RequireStorageSecuritySummaryByIdFields.SecuritySetup.ContainerItem - (*RequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem)(nil), // 480: productv1.RequireStorageSecuritySummaryByIdFields.SecuritySetup.StorageItem - (*RequireStorageItemHandlerInfoByIdFields_PalletItem)(nil), // 481: productv1.RequireStorageItemHandlerInfoByIdFields.PalletItem - (*RequireStorageItemHandlerInfoByIdFields_ContainerItem)(nil), // 482: productv1.RequireStorageItemHandlerInfoByIdFields.ContainerItem - (*RequireStorageItemHandlerInfoByIdFields_StorageItem)(nil), // 483: productv1.RequireStorageItemHandlerInfoByIdFields.StorageItem - (*RequireStorageItemHandlerInfoByIdFields_PalletItem_ItemHandler)(nil), // 484: productv1.RequireStorageItemHandlerInfoByIdFields.PalletItem.ItemHandler - (*RequireStorageItemHandlerInfoByIdFields_ContainerItem_ItemHandler)(nil), // 485: productv1.RequireStorageItemHandlerInfoByIdFields.ContainerItem.ItemHandler - (*RequireStorageItemSpecsInfoByIdFields_PalletItem)(nil), // 486: productv1.RequireStorageItemSpecsInfoByIdFields.PalletItem - (*RequireStorageItemSpecsInfoByIdFields_ContainerItem)(nil), // 487: productv1.RequireStorageItemSpecsInfoByIdFields.ContainerItem - (*RequireStorageItemSpecsInfoByIdFields_StorageItem)(nil), // 488: productv1.RequireStorageItemSpecsInfoByIdFields.StorageItem - (*RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs)(nil), // 489: productv1.RequireStorageItemSpecsInfoByIdFields.PalletItem.PalletSpecs - (*RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs_Dimensions)(nil), // 490: productv1.RequireStorageItemSpecsInfoByIdFields.PalletItem.PalletSpecs.Dimensions - (*RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs)(nil), // 491: productv1.RequireStorageItemSpecsInfoByIdFields.ContainerItem.ContainerSpecs - (*RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs_Dimensions)(nil), // 492: productv1.RequireStorageItemSpecsInfoByIdFields.ContainerItem.ContainerSpecs.Dimensions - (*RequireStorageDeepItemInfoByIdFields_PalletItem)(nil), // 493: productv1.RequireStorageDeepItemInfoByIdFields.PalletItem - (*RequireStorageDeepItemInfoByIdFields_ContainerItem)(nil), // 494: productv1.RequireStorageDeepItemInfoByIdFields.ContainerItem - (*RequireStorageDeepItemInfoByIdFields_StorageItem)(nil), // 495: productv1.RequireStorageDeepItemInfoByIdFields.StorageItem - (*RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler)(nil), // 496: productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.ItemHandler - (*RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_ContainerItem)(nil), // 497: productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.ItemHandler.ContainerItem - (*RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_PalletItem)(nil), // 498: productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.ItemHandler.PalletItem - (*RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem)(nil), // 499: productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.ItemHandler.StorageItem - (*RequireStorageDeepItemInfoByIdFields_ContainerItem_ItemHandler)(nil), // 500: productv1.RequireStorageDeepItemInfoByIdFields.ContainerItem.ItemHandler - (*RequireStorageRecommendedItemByIdFields_StorageMetadata)(nil), // 501: productv1.RequireStorageRecommendedItemByIdFields.StorageMetadata - (*RequireWarehouseStockHealthScoreByIdFields_RestockData)(nil), // 502: productv1.RequireWarehouseStockHealthScoreByIdFields.RestockData - (*wrapperspb.Int32Value)(nil), // 503: google.protobuf.Int32Value - (*wrapperspb.BoolValue)(nil), // 504: google.protobuf.BoolValue - (*wrapperspb.StringValue)(nil), // 505: google.protobuf.StringValue - (*wrapperspb.DoubleValue)(nil), // 506: google.protobuf.DoubleValue + (CategoryKind)(0), // 0: productv1.CategoryKind + (ShippingDestination)(0), // 1: productv1.ShippingDestination + (*ListOfAuthorFilter)(nil), // 2: productv1.ListOfAuthorFilter + (*ListOfAuthorInput)(nil), // 3: productv1.ListOfAuthorInput + (*ListOfBlogPost)(nil), // 4: productv1.ListOfBlogPost + (*ListOfBlogPostFilter)(nil), // 5: productv1.ListOfBlogPostFilter + (*ListOfBlogPostInput)(nil), // 6: productv1.ListOfBlogPostInput + (*ListOfBoolean)(nil), // 7: productv1.ListOfBoolean + (*ListOfCategory)(nil), // 8: productv1.ListOfCategory + (*ListOfCategoryInput)(nil), // 9: productv1.ListOfCategoryInput + (*ListOfConditionsInput)(nil), // 10: productv1.ListOfConditionsInput + (*ListOfFloat)(nil), // 11: productv1.ListOfFloat + (*ListOfInt)(nil), // 12: productv1.ListOfInt + (*ListOfListOfCategory)(nil), // 13: productv1.ListOfListOfCategory + (*ListOfListOfCategoryInput)(nil), // 14: productv1.ListOfListOfCategoryInput + (*ListOfListOfString)(nil), // 15: productv1.ListOfListOfString + (*ListOfListOfUser)(nil), // 16: productv1.ListOfListOfUser + (*ListOfListOfUserInput)(nil), // 17: productv1.ListOfListOfUserInput + (*ListOfOrderLine)(nil), // 18: productv1.ListOfOrderLine + (*ListOfProduct)(nil), // 19: productv1.ListOfProduct + (*ListOfStorage)(nil), // 20: productv1.ListOfStorage + (*ListOfStorageItem)(nil), // 21: productv1.ListOfStorageItem + (*ListOfStorageMetadata)(nil), // 22: productv1.ListOfStorageMetadata + (*ListOfStorageOperationResult)(nil), // 23: productv1.ListOfStorageOperationResult + (*ListOfString)(nil), // 24: productv1.ListOfString + (*ListOfSubcategory)(nil), // 25: productv1.ListOfSubcategory + (*ListOfUser)(nil), // 26: productv1.ListOfUser + (*ListOfUserInput)(nil), // 27: productv1.ListOfUserInput + (*LookupProductByIdRequestKey)(nil), // 28: productv1.LookupProductByIdRequestKey + (*LookupProductByIdRequest)(nil), // 29: productv1.LookupProductByIdRequest + (*LookupProductByIdResponse)(nil), // 30: productv1.LookupProductByIdResponse + (*LookupStorageByIdRequestKey)(nil), // 31: productv1.LookupStorageByIdRequestKey + (*LookupStorageByIdRequest)(nil), // 32: productv1.LookupStorageByIdRequest + (*LookupStorageByIdResponse)(nil), // 33: productv1.LookupStorageByIdResponse + (*LookupWarehouseByIdRequestKey)(nil), // 34: productv1.LookupWarehouseByIdRequestKey + (*LookupWarehouseByIdRequest)(nil), // 35: productv1.LookupWarehouseByIdRequest + (*LookupWarehouseByIdResponse)(nil), // 36: productv1.LookupWarehouseByIdResponse + (*QueryUsersRequest)(nil), // 37: productv1.QueryUsersRequest + (*QueryUsersResponse)(nil), // 38: productv1.QueryUsersResponse + (*QueryUserRequest)(nil), // 39: productv1.QueryUserRequest + (*QueryUserResponse)(nil), // 40: productv1.QueryUserResponse + (*QueryNestedTypeRequest)(nil), // 41: productv1.QueryNestedTypeRequest + (*QueryNestedTypeResponse)(nil), // 42: productv1.QueryNestedTypeResponse + (*QueryRecursiveTypeRequest)(nil), // 43: productv1.QueryRecursiveTypeRequest + (*QueryRecursiveTypeResponse)(nil), // 44: productv1.QueryRecursiveTypeResponse + (*QueryTypeFilterWithArgumentsRequest)(nil), // 45: productv1.QueryTypeFilterWithArgumentsRequest + (*QueryTypeFilterWithArgumentsResponse)(nil), // 46: productv1.QueryTypeFilterWithArgumentsResponse + (*QueryTypeWithMultipleFilterFieldsRequest)(nil), // 47: productv1.QueryTypeWithMultipleFilterFieldsRequest + (*QueryTypeWithMultipleFilterFieldsResponse)(nil), // 48: productv1.QueryTypeWithMultipleFilterFieldsResponse + (*QueryComplexFilterTypeRequest)(nil), // 49: productv1.QueryComplexFilterTypeRequest + (*QueryComplexFilterTypeResponse)(nil), // 50: productv1.QueryComplexFilterTypeResponse + (*QueryCalculateTotalsRequest)(nil), // 51: productv1.QueryCalculateTotalsRequest + (*QueryCalculateTotalsResponse)(nil), // 52: productv1.QueryCalculateTotalsResponse + (*QueryCategoriesRequest)(nil), // 53: productv1.QueryCategoriesRequest + (*QueryCategoriesResponse)(nil), // 54: productv1.QueryCategoriesResponse + (*QueryCategoryRequest)(nil), // 55: productv1.QueryCategoryRequest + (*QueryCategoryResponse)(nil), // 56: productv1.QueryCategoryResponse + (*QueryCategoriesByKindRequest)(nil), // 57: productv1.QueryCategoriesByKindRequest + (*QueryCategoriesByKindResponse)(nil), // 58: productv1.QueryCategoriesByKindResponse + (*QueryCategoriesByKindsRequest)(nil), // 59: productv1.QueryCategoriesByKindsRequest + (*QueryCategoriesByKindsResponse)(nil), // 60: productv1.QueryCategoriesByKindsResponse + (*QueryFilterCategoriesRequest)(nil), // 61: productv1.QueryFilterCategoriesRequest + (*QueryFilterCategoriesResponse)(nil), // 62: productv1.QueryFilterCategoriesResponse + (*QueryRandomPetRequest)(nil), // 63: productv1.QueryRandomPetRequest + (*QueryRandomPetResponse)(nil), // 64: productv1.QueryRandomPetResponse + (*QueryAllPetsRequest)(nil), // 65: productv1.QueryAllPetsRequest + (*QueryAllPetsResponse)(nil), // 66: productv1.QueryAllPetsResponse + (*QuerySearchRequest)(nil), // 67: productv1.QuerySearchRequest + (*QuerySearchResponse)(nil), // 68: productv1.QuerySearchResponse + (*QueryRandomSearchResultRequest)(nil), // 69: productv1.QueryRandomSearchResultRequest + (*QueryRandomSearchResultResponse)(nil), // 70: productv1.QueryRandomSearchResultResponse + (*QueryNullableFieldsTypeRequest)(nil), // 71: productv1.QueryNullableFieldsTypeRequest + (*QueryNullableFieldsTypeResponse)(nil), // 72: productv1.QueryNullableFieldsTypeResponse + (*QueryNullableFieldsTypeByIdRequest)(nil), // 73: productv1.QueryNullableFieldsTypeByIdRequest + (*QueryNullableFieldsTypeByIdResponse)(nil), // 74: productv1.QueryNullableFieldsTypeByIdResponse + (*QueryNullableFieldsTypeWithFilterRequest)(nil), // 75: productv1.QueryNullableFieldsTypeWithFilterRequest + (*QueryNullableFieldsTypeWithFilterResponse)(nil), // 76: productv1.QueryNullableFieldsTypeWithFilterResponse + (*QueryAllNullableFieldsTypesRequest)(nil), // 77: productv1.QueryAllNullableFieldsTypesRequest + (*QueryAllNullableFieldsTypesResponse)(nil), // 78: productv1.QueryAllNullableFieldsTypesResponse + (*QueryBlogPostRequest)(nil), // 79: productv1.QueryBlogPostRequest + (*QueryBlogPostResponse)(nil), // 80: productv1.QueryBlogPostResponse + (*QueryBlogPostByIdRequest)(nil), // 81: productv1.QueryBlogPostByIdRequest + (*QueryBlogPostByIdResponse)(nil), // 82: productv1.QueryBlogPostByIdResponse + (*QueryBlogPostsWithFilterRequest)(nil), // 83: productv1.QueryBlogPostsWithFilterRequest + (*QueryBlogPostsWithFilterResponse)(nil), // 84: productv1.QueryBlogPostsWithFilterResponse + (*QueryAllBlogPostsRequest)(nil), // 85: productv1.QueryAllBlogPostsRequest + (*QueryAllBlogPostsResponse)(nil), // 86: productv1.QueryAllBlogPostsResponse + (*QueryAuthorRequest)(nil), // 87: productv1.QueryAuthorRequest + (*QueryAuthorResponse)(nil), // 88: productv1.QueryAuthorResponse + (*QueryAuthorByIdRequest)(nil), // 89: productv1.QueryAuthorByIdRequest + (*QueryAuthorByIdResponse)(nil), // 90: productv1.QueryAuthorByIdResponse + (*QueryAuthorsWithFilterRequest)(nil), // 91: productv1.QueryAuthorsWithFilterRequest + (*QueryAuthorsWithFilterResponse)(nil), // 92: productv1.QueryAuthorsWithFilterResponse + (*QueryAllAuthorsRequest)(nil), // 93: productv1.QueryAllAuthorsRequest + (*QueryAllAuthorsResponse)(nil), // 94: productv1.QueryAllAuthorsResponse + (*QueryBulkSearchAuthorsRequest)(nil), // 95: productv1.QueryBulkSearchAuthorsRequest + (*QueryBulkSearchAuthorsResponse)(nil), // 96: productv1.QueryBulkSearchAuthorsResponse + (*QueryBulkSearchBlogPostsRequest)(nil), // 97: productv1.QueryBulkSearchBlogPostsRequest + (*QueryBulkSearchBlogPostsResponse)(nil), // 98: productv1.QueryBulkSearchBlogPostsResponse + (*QueryTestContainerRequest)(nil), // 99: productv1.QueryTestContainerRequest + (*QueryTestContainerResponse)(nil), // 100: productv1.QueryTestContainerResponse + (*QueryTestContainersRequest)(nil), // 101: productv1.QueryTestContainersRequest + (*QueryTestContainersResponse)(nil), // 102: productv1.QueryTestContainersResponse + (*QueryConditionalSearchRequest)(nil), // 103: productv1.QueryConditionalSearchRequest + (*QueryConditionalSearchResponse)(nil), // 104: productv1.QueryConditionalSearchResponse + (*MutationCreateUserRequest)(nil), // 105: productv1.MutationCreateUserRequest + (*MutationCreateUserResponse)(nil), // 106: productv1.MutationCreateUserResponse + (*MutationPerformActionRequest)(nil), // 107: productv1.MutationPerformActionRequest + (*MutationPerformActionResponse)(nil), // 108: productv1.MutationPerformActionResponse + (*MutationCreateNullableFieldsTypeRequest)(nil), // 109: productv1.MutationCreateNullableFieldsTypeRequest + (*MutationCreateNullableFieldsTypeResponse)(nil), // 110: productv1.MutationCreateNullableFieldsTypeResponse + (*MutationUpdateNullableFieldsTypeRequest)(nil), // 111: productv1.MutationUpdateNullableFieldsTypeRequest + (*MutationUpdateNullableFieldsTypeResponse)(nil), // 112: productv1.MutationUpdateNullableFieldsTypeResponse + (*MutationCreateBlogPostRequest)(nil), // 113: productv1.MutationCreateBlogPostRequest + (*MutationCreateBlogPostResponse)(nil), // 114: productv1.MutationCreateBlogPostResponse + (*MutationUpdateBlogPostRequest)(nil), // 115: productv1.MutationUpdateBlogPostRequest + (*MutationUpdateBlogPostResponse)(nil), // 116: productv1.MutationUpdateBlogPostResponse + (*MutationCreateAuthorRequest)(nil), // 117: productv1.MutationCreateAuthorRequest + (*MutationCreateAuthorResponse)(nil), // 118: productv1.MutationCreateAuthorResponse + (*MutationUpdateAuthorRequest)(nil), // 119: productv1.MutationUpdateAuthorRequest + (*MutationUpdateAuthorResponse)(nil), // 120: productv1.MutationUpdateAuthorResponse + (*MutationBulkCreateAuthorsRequest)(nil), // 121: productv1.MutationBulkCreateAuthorsRequest + (*MutationBulkCreateAuthorsResponse)(nil), // 122: productv1.MutationBulkCreateAuthorsResponse + (*MutationBulkUpdateAuthorsRequest)(nil), // 123: productv1.MutationBulkUpdateAuthorsRequest + (*MutationBulkUpdateAuthorsResponse)(nil), // 124: productv1.MutationBulkUpdateAuthorsResponse + (*MutationBulkCreateBlogPostsRequest)(nil), // 125: productv1.MutationBulkCreateBlogPostsRequest + (*MutationBulkCreateBlogPostsResponse)(nil), // 126: productv1.MutationBulkCreateBlogPostsResponse + (*MutationBulkUpdateBlogPostsRequest)(nil), // 127: productv1.MutationBulkUpdateBlogPostsRequest + (*MutationBulkUpdateBlogPostsResponse)(nil), // 128: productv1.MutationBulkUpdateBlogPostsResponse + (*ResolveProductShippingEstimateArgs)(nil), // 129: productv1.ResolveProductShippingEstimateArgs + (*ResolveProductShippingEstimateContext)(nil), // 130: productv1.ResolveProductShippingEstimateContext + (*ResolveProductShippingEstimateRequest)(nil), // 131: productv1.ResolveProductShippingEstimateRequest + (*ResolveProductShippingEstimateResult)(nil), // 132: productv1.ResolveProductShippingEstimateResult + (*ResolveProductShippingEstimateResponse)(nil), // 133: productv1.ResolveProductShippingEstimateResponse + (*ResolveProductRecommendedCategoryArgs)(nil), // 134: productv1.ResolveProductRecommendedCategoryArgs + (*ResolveProductRecommendedCategoryContext)(nil), // 135: productv1.ResolveProductRecommendedCategoryContext + (*ResolveProductRecommendedCategoryRequest)(nil), // 136: productv1.ResolveProductRecommendedCategoryRequest + (*ResolveProductRecommendedCategoryResult)(nil), // 137: productv1.ResolveProductRecommendedCategoryResult + (*ResolveProductRecommendedCategoryResponse)(nil), // 138: productv1.ResolveProductRecommendedCategoryResponse + (*ResolveProductMascotRecommendationArgs)(nil), // 139: productv1.ResolveProductMascotRecommendationArgs + (*ResolveProductMascotRecommendationContext)(nil), // 140: productv1.ResolveProductMascotRecommendationContext + (*ResolveProductMascotRecommendationRequest)(nil), // 141: productv1.ResolveProductMascotRecommendationRequest + (*ResolveProductMascotRecommendationResult)(nil), // 142: productv1.ResolveProductMascotRecommendationResult + (*ResolveProductMascotRecommendationResponse)(nil), // 143: productv1.ResolveProductMascotRecommendationResponse + (*ResolveProductStockStatusArgs)(nil), // 144: productv1.ResolveProductStockStatusArgs + (*ResolveProductStockStatusContext)(nil), // 145: productv1.ResolveProductStockStatusContext + (*ResolveProductStockStatusRequest)(nil), // 146: productv1.ResolveProductStockStatusRequest + (*ResolveProductStockStatusResult)(nil), // 147: productv1.ResolveProductStockStatusResult + (*ResolveProductStockStatusResponse)(nil), // 148: productv1.ResolveProductStockStatusResponse + (*ResolveProductProductDetailsArgs)(nil), // 149: productv1.ResolveProductProductDetailsArgs + (*ResolveProductProductDetailsContext)(nil), // 150: productv1.ResolveProductProductDetailsContext + (*ResolveProductProductDetailsRequest)(nil), // 151: productv1.ResolveProductProductDetailsRequest + (*ResolveProductProductDetailsResult)(nil), // 152: productv1.ResolveProductProductDetailsResult + (*ResolveProductProductDetailsResponse)(nil), // 153: productv1.ResolveProductProductDetailsResponse + (*ResolveStorageStorageStatusArgs)(nil), // 154: productv1.ResolveStorageStorageStatusArgs + (*ResolveStorageStorageStatusContext)(nil), // 155: productv1.ResolveStorageStorageStatusContext + (*ResolveStorageStorageStatusRequest)(nil), // 156: productv1.ResolveStorageStorageStatusRequest + (*ResolveStorageStorageStatusResult)(nil), // 157: productv1.ResolveStorageStorageStatusResult + (*ResolveStorageStorageStatusResponse)(nil), // 158: productv1.ResolveStorageStorageStatusResponse + (*ResolveStorageLinkedStoragesArgs)(nil), // 159: productv1.ResolveStorageLinkedStoragesArgs + (*ResolveStorageLinkedStoragesContext)(nil), // 160: productv1.ResolveStorageLinkedStoragesContext + (*ResolveStorageLinkedStoragesRequest)(nil), // 161: productv1.ResolveStorageLinkedStoragesRequest + (*ResolveStorageLinkedStoragesResult)(nil), // 162: productv1.ResolveStorageLinkedStoragesResult + (*ResolveStorageLinkedStoragesResponse)(nil), // 163: productv1.ResolveStorageLinkedStoragesResponse + (*ResolveStorageNearbyStoragesArgs)(nil), // 164: productv1.ResolveStorageNearbyStoragesArgs + (*ResolveStorageNearbyStoragesContext)(nil), // 165: productv1.ResolveStorageNearbyStoragesContext + (*ResolveStorageNearbyStoragesRequest)(nil), // 166: productv1.ResolveStorageNearbyStoragesRequest + (*ResolveStorageNearbyStoragesResult)(nil), // 167: productv1.ResolveStorageNearbyStoragesResult + (*ResolveStorageNearbyStoragesResponse)(nil), // 168: productv1.ResolveStorageNearbyStoragesResponse + (*ResolveCategoryProductCountArgs)(nil), // 169: productv1.ResolveCategoryProductCountArgs + (*ResolveCategoryProductCountContext)(nil), // 170: productv1.ResolveCategoryProductCountContext + (*ResolveCategoryProductCountRequest)(nil), // 171: productv1.ResolveCategoryProductCountRequest + (*ResolveCategoryProductCountResult)(nil), // 172: productv1.ResolveCategoryProductCountResult + (*ResolveCategoryProductCountResponse)(nil), // 173: productv1.ResolveCategoryProductCountResponse + (*ResolveCategoryPopularityScoreArgs)(nil), // 174: productv1.ResolveCategoryPopularityScoreArgs + (*ResolveCategoryPopularityScoreContext)(nil), // 175: productv1.ResolveCategoryPopularityScoreContext + (*ResolveCategoryPopularityScoreRequest)(nil), // 176: productv1.ResolveCategoryPopularityScoreRequest + (*ResolveCategoryPopularityScoreResult)(nil), // 177: productv1.ResolveCategoryPopularityScoreResult + (*ResolveCategoryPopularityScoreResponse)(nil), // 178: productv1.ResolveCategoryPopularityScoreResponse + (*ResolveCategoryCategoryMetricsArgs)(nil), // 179: productv1.ResolveCategoryCategoryMetricsArgs + (*ResolveCategoryCategoryMetricsContext)(nil), // 180: productv1.ResolveCategoryCategoryMetricsContext + (*ResolveCategoryCategoryMetricsRequest)(nil), // 181: productv1.ResolveCategoryCategoryMetricsRequest + (*ResolveCategoryCategoryMetricsResult)(nil), // 182: productv1.ResolveCategoryCategoryMetricsResult + (*ResolveCategoryCategoryMetricsResponse)(nil), // 183: productv1.ResolveCategoryCategoryMetricsResponse + (*ResolveCategoryMascotArgs)(nil), // 184: productv1.ResolveCategoryMascotArgs + (*ResolveCategoryMascotContext)(nil), // 185: productv1.ResolveCategoryMascotContext + (*ResolveCategoryMascotRequest)(nil), // 186: productv1.ResolveCategoryMascotRequest + (*ResolveCategoryMascotResult)(nil), // 187: productv1.ResolveCategoryMascotResult + (*ResolveCategoryMascotResponse)(nil), // 188: productv1.ResolveCategoryMascotResponse + (*ResolveCategoryCategoryStatusArgs)(nil), // 189: productv1.ResolveCategoryCategoryStatusArgs + (*ResolveCategoryCategoryStatusContext)(nil), // 190: productv1.ResolveCategoryCategoryStatusContext + (*ResolveCategoryCategoryStatusRequest)(nil), // 191: productv1.ResolveCategoryCategoryStatusRequest + (*ResolveCategoryCategoryStatusResult)(nil), // 192: productv1.ResolveCategoryCategoryStatusResult + (*ResolveCategoryCategoryStatusResponse)(nil), // 193: productv1.ResolveCategoryCategoryStatusResponse + (*ResolveCategoryChildCategoriesArgs)(nil), // 194: productv1.ResolveCategoryChildCategoriesArgs + (*ResolveCategoryChildCategoriesContext)(nil), // 195: productv1.ResolveCategoryChildCategoriesContext + (*ResolveCategoryChildCategoriesRequest)(nil), // 196: productv1.ResolveCategoryChildCategoriesRequest + (*ResolveCategoryChildCategoriesResult)(nil), // 197: productv1.ResolveCategoryChildCategoriesResult + (*ResolveCategoryChildCategoriesResponse)(nil), // 198: productv1.ResolveCategoryChildCategoriesResponse + (*ResolveCategoryOptionalCategoriesArgs)(nil), // 199: productv1.ResolveCategoryOptionalCategoriesArgs + (*ResolveCategoryOptionalCategoriesContext)(nil), // 200: productv1.ResolveCategoryOptionalCategoriesContext + (*ResolveCategoryOptionalCategoriesRequest)(nil), // 201: productv1.ResolveCategoryOptionalCategoriesRequest + (*ResolveCategoryOptionalCategoriesResult)(nil), // 202: productv1.ResolveCategoryOptionalCategoriesResult + (*ResolveCategoryOptionalCategoriesResponse)(nil), // 203: productv1.ResolveCategoryOptionalCategoriesResponse + (*ResolveCategoryTotalProductsContext)(nil), // 204: productv1.ResolveCategoryTotalProductsContext + (*ResolveCategoryTotalProductsRequest)(nil), // 205: productv1.ResolveCategoryTotalProductsRequest + (*ResolveCategoryTotalProductsResult)(nil), // 206: productv1.ResolveCategoryTotalProductsResult + (*ResolveCategoryTotalProductsResponse)(nil), // 207: productv1.ResolveCategoryTotalProductsResponse + (*ResolveCategoryTopSubcategoryContext)(nil), // 208: productv1.ResolveCategoryTopSubcategoryContext + (*ResolveCategoryTopSubcategoryRequest)(nil), // 209: productv1.ResolveCategoryTopSubcategoryRequest + (*ResolveCategoryTopSubcategoryResult)(nil), // 210: productv1.ResolveCategoryTopSubcategoryResult + (*ResolveCategoryTopSubcategoryResponse)(nil), // 211: productv1.ResolveCategoryTopSubcategoryResponse + (*ResolveCategoryActiveSubcategoriesContext)(nil), // 212: productv1.ResolveCategoryActiveSubcategoriesContext + (*ResolveCategoryActiveSubcategoriesRequest)(nil), // 213: productv1.ResolveCategoryActiveSubcategoriesRequest + (*ResolveCategoryActiveSubcategoriesResult)(nil), // 214: productv1.ResolveCategoryActiveSubcategoriesResult + (*ResolveCategoryActiveSubcategoriesResponse)(nil), // 215: productv1.ResolveCategoryActiveSubcategoriesResponse + (*ResolveSubcategoryItemCountArgs)(nil), // 216: productv1.ResolveSubcategoryItemCountArgs + (*ResolveSubcategoryItemCountContext)(nil), // 217: productv1.ResolveSubcategoryItemCountContext + (*ResolveSubcategoryItemCountRequest)(nil), // 218: productv1.ResolveSubcategoryItemCountRequest + (*ResolveSubcategoryItemCountResult)(nil), // 219: productv1.ResolveSubcategoryItemCountResult + (*ResolveSubcategoryItemCountResponse)(nil), // 220: productv1.ResolveSubcategoryItemCountResponse + (*ResolveSubcategoryFeaturedCategoryArgs)(nil), // 221: productv1.ResolveSubcategoryFeaturedCategoryArgs + (*ResolveSubcategoryFeaturedCategoryContext)(nil), // 222: productv1.ResolveSubcategoryFeaturedCategoryContext + (*ResolveSubcategoryFeaturedCategoryRequest)(nil), // 223: productv1.ResolveSubcategoryFeaturedCategoryRequest + (*ResolveSubcategoryFeaturedCategoryResult)(nil), // 224: productv1.ResolveSubcategoryFeaturedCategoryResult + (*ResolveSubcategoryFeaturedCategoryResponse)(nil), // 225: productv1.ResolveSubcategoryFeaturedCategoryResponse + (*ResolveSubcategoryParentCategoryContext)(nil), // 226: productv1.ResolveSubcategoryParentCategoryContext + (*ResolveSubcategoryParentCategoryRequest)(nil), // 227: productv1.ResolveSubcategoryParentCategoryRequest + (*ResolveSubcategoryParentCategoryResult)(nil), // 228: productv1.ResolveSubcategoryParentCategoryResult + (*ResolveSubcategoryParentCategoryResponse)(nil), // 229: productv1.ResolveSubcategoryParentCategoryResponse + (*ResolveCategoryMetricsNormalizedScoreArgs)(nil), // 230: productv1.ResolveCategoryMetricsNormalizedScoreArgs + (*ResolveCategoryMetricsNormalizedScoreContext)(nil), // 231: productv1.ResolveCategoryMetricsNormalizedScoreContext + (*ResolveCategoryMetricsNormalizedScoreRequest)(nil), // 232: productv1.ResolveCategoryMetricsNormalizedScoreRequest + (*ResolveCategoryMetricsNormalizedScoreResult)(nil), // 233: productv1.ResolveCategoryMetricsNormalizedScoreResult + (*ResolveCategoryMetricsNormalizedScoreResponse)(nil), // 234: productv1.ResolveCategoryMetricsNormalizedScoreResponse + (*ResolveCategoryMetricsRelatedCategoryArgs)(nil), // 235: productv1.ResolveCategoryMetricsRelatedCategoryArgs + (*ResolveCategoryMetricsRelatedCategoryContext)(nil), // 236: productv1.ResolveCategoryMetricsRelatedCategoryContext + (*ResolveCategoryMetricsRelatedCategoryRequest)(nil), // 237: productv1.ResolveCategoryMetricsRelatedCategoryRequest + (*ResolveCategoryMetricsRelatedCategoryResult)(nil), // 238: productv1.ResolveCategoryMetricsRelatedCategoryResult + (*ResolveCategoryMetricsRelatedCategoryResponse)(nil), // 239: productv1.ResolveCategoryMetricsRelatedCategoryResponse + (*ResolveCategoryMetricsAverageScoreContext)(nil), // 240: productv1.ResolveCategoryMetricsAverageScoreContext + (*ResolveCategoryMetricsAverageScoreRequest)(nil), // 241: productv1.ResolveCategoryMetricsAverageScoreRequest + (*ResolveCategoryMetricsAverageScoreResult)(nil), // 242: productv1.ResolveCategoryMetricsAverageScoreResult + (*ResolveCategoryMetricsAverageScoreResponse)(nil), // 243: productv1.ResolveCategoryMetricsAverageScoreResponse + (*ResolveTestContainerDetailsArgs)(nil), // 244: productv1.ResolveTestContainerDetailsArgs + (*ResolveTestContainerDetailsContext)(nil), // 245: productv1.ResolveTestContainerDetailsContext + (*ResolveTestContainerDetailsRequest)(nil), // 246: productv1.ResolveTestContainerDetailsRequest + (*ResolveTestContainerDetailsResult)(nil), // 247: productv1.ResolveTestContainerDetailsResult + (*ResolveTestContainerDetailsResponse)(nil), // 248: productv1.ResolveTestContainerDetailsResponse + (*RequireStorageStockHealthScoreByIdRequest)(nil), // 249: productv1.RequireStorageStockHealthScoreByIdRequest + (*RequireStorageStockHealthScoreByIdContext)(nil), // 250: productv1.RequireStorageStockHealthScoreByIdContext + (*RequireStorageStockHealthScoreByIdResponse)(nil), // 251: productv1.RequireStorageStockHealthScoreByIdResponse + (*RequireStorageStockHealthScoreByIdResult)(nil), // 252: productv1.RequireStorageStockHealthScoreByIdResult + (*RequireStorageStockHealthScoreByIdFields)(nil), // 253: productv1.RequireStorageStockHealthScoreByIdFields + (*RequireStorageTagSummaryByIdRequest)(nil), // 254: productv1.RequireStorageTagSummaryByIdRequest + (*RequireStorageTagSummaryByIdContext)(nil), // 255: productv1.RequireStorageTagSummaryByIdContext + (*RequireStorageTagSummaryByIdResponse)(nil), // 256: productv1.RequireStorageTagSummaryByIdResponse + (*RequireStorageTagSummaryByIdResult)(nil), // 257: productv1.RequireStorageTagSummaryByIdResult + (*RequireStorageTagSummaryByIdFields)(nil), // 258: productv1.RequireStorageTagSummaryByIdFields + (*RequireStorageOptionalTagSummaryByIdRequest)(nil), // 259: productv1.RequireStorageOptionalTagSummaryByIdRequest + (*RequireStorageOptionalTagSummaryByIdContext)(nil), // 260: productv1.RequireStorageOptionalTagSummaryByIdContext + (*RequireStorageOptionalTagSummaryByIdResponse)(nil), // 261: productv1.RequireStorageOptionalTagSummaryByIdResponse + (*RequireStorageOptionalTagSummaryByIdResult)(nil), // 262: productv1.RequireStorageOptionalTagSummaryByIdResult + (*RequireStorageOptionalTagSummaryByIdFields)(nil), // 263: productv1.RequireStorageOptionalTagSummaryByIdFields + (*RequireStorageMetadataScoreByIdRequest)(nil), // 264: productv1.RequireStorageMetadataScoreByIdRequest + (*RequireStorageMetadataScoreByIdContext)(nil), // 265: productv1.RequireStorageMetadataScoreByIdContext + (*RequireStorageMetadataScoreByIdResponse)(nil), // 266: productv1.RequireStorageMetadataScoreByIdResponse + (*RequireStorageMetadataScoreByIdResult)(nil), // 267: productv1.RequireStorageMetadataScoreByIdResult + (*RequireStorageMetadataScoreByIdFields)(nil), // 268: productv1.RequireStorageMetadataScoreByIdFields + (*RequireStorageProcessedMetadataByIdRequest)(nil), // 269: productv1.RequireStorageProcessedMetadataByIdRequest + (*RequireStorageProcessedMetadataByIdContext)(nil), // 270: productv1.RequireStorageProcessedMetadataByIdContext + (*RequireStorageProcessedMetadataByIdResponse)(nil), // 271: productv1.RequireStorageProcessedMetadataByIdResponse + (*RequireStorageProcessedMetadataByIdResult)(nil), // 272: productv1.RequireStorageProcessedMetadataByIdResult + (*RequireStorageProcessedMetadataByIdFields)(nil), // 273: productv1.RequireStorageProcessedMetadataByIdFields + (*RequireStorageOptionalProcessedMetadataByIdRequest)(nil), // 274: productv1.RequireStorageOptionalProcessedMetadataByIdRequest + (*RequireStorageOptionalProcessedMetadataByIdContext)(nil), // 275: productv1.RequireStorageOptionalProcessedMetadataByIdContext + (*RequireStorageOptionalProcessedMetadataByIdResponse)(nil), // 276: productv1.RequireStorageOptionalProcessedMetadataByIdResponse + (*RequireStorageOptionalProcessedMetadataByIdResult)(nil), // 277: productv1.RequireStorageOptionalProcessedMetadataByIdResult + (*RequireStorageOptionalProcessedMetadataByIdFields)(nil), // 278: productv1.RequireStorageOptionalProcessedMetadataByIdFields + (*RequireStorageProcessedTagsByIdRequest)(nil), // 279: productv1.RequireStorageProcessedTagsByIdRequest + (*RequireStorageProcessedTagsByIdContext)(nil), // 280: productv1.RequireStorageProcessedTagsByIdContext + (*RequireStorageProcessedTagsByIdResponse)(nil), // 281: productv1.RequireStorageProcessedTagsByIdResponse + (*RequireStorageProcessedTagsByIdResult)(nil), // 282: productv1.RequireStorageProcessedTagsByIdResult + (*RequireStorageProcessedTagsByIdFields)(nil), // 283: productv1.RequireStorageProcessedTagsByIdFields + (*RequireStorageOptionalProcessedTagsByIdRequest)(nil), // 284: productv1.RequireStorageOptionalProcessedTagsByIdRequest + (*RequireStorageOptionalProcessedTagsByIdContext)(nil), // 285: productv1.RequireStorageOptionalProcessedTagsByIdContext + (*RequireStorageOptionalProcessedTagsByIdResponse)(nil), // 286: productv1.RequireStorageOptionalProcessedTagsByIdResponse + (*RequireStorageOptionalProcessedTagsByIdResult)(nil), // 287: productv1.RequireStorageOptionalProcessedTagsByIdResult + (*RequireStorageOptionalProcessedTagsByIdFields)(nil), // 288: productv1.RequireStorageOptionalProcessedTagsByIdFields + (*RequireStorageProcessedMetadataHistoryByIdRequest)(nil), // 289: productv1.RequireStorageProcessedMetadataHistoryByIdRequest + (*RequireStorageProcessedMetadataHistoryByIdContext)(nil), // 290: productv1.RequireStorageProcessedMetadataHistoryByIdContext + (*RequireStorageProcessedMetadataHistoryByIdResponse)(nil), // 291: productv1.RequireStorageProcessedMetadataHistoryByIdResponse + (*RequireStorageProcessedMetadataHistoryByIdResult)(nil), // 292: productv1.RequireStorageProcessedMetadataHistoryByIdResult + (*RequireStorageProcessedMetadataHistoryByIdFields)(nil), // 293: productv1.RequireStorageProcessedMetadataHistoryByIdFields + (*RequireStorageOptionalProcessedMetadataHistoryByIdRequest)(nil), // 294: productv1.RequireStorageOptionalProcessedMetadataHistoryByIdRequest + (*RequireStorageOptionalProcessedMetadataHistoryByIdContext)(nil), // 295: productv1.RequireStorageOptionalProcessedMetadataHistoryByIdContext + (*RequireStorageOptionalProcessedMetadataHistoryByIdResponse)(nil), // 296: productv1.RequireStorageOptionalProcessedMetadataHistoryByIdResponse + (*RequireStorageOptionalProcessedMetadataHistoryByIdResult)(nil), // 297: productv1.RequireStorageOptionalProcessedMetadataHistoryByIdResult + (*RequireStorageOptionalProcessedMetadataHistoryByIdFields)(nil), // 298: productv1.RequireStorageOptionalProcessedMetadataHistoryByIdFields + (*RequireStorageTagsByLengthsByIdRequest)(nil), // 299: productv1.RequireStorageTagsByLengthsByIdRequest + (*RequireStorageTagsByLengthsByIdContext)(nil), // 300: productv1.RequireStorageTagsByLengthsByIdContext + (*RequireStorageTagsByLengthsByIdArgs)(nil), // 301: productv1.RequireStorageTagsByLengthsByIdArgs + (*RequireStorageTagsByLengthsByIdResponse)(nil), // 302: productv1.RequireStorageTagsByLengthsByIdResponse + (*RequireStorageTagsByLengthsByIdResult)(nil), // 303: productv1.RequireStorageTagsByLengthsByIdResult + (*RequireStorageTagsByLengthsByIdFields)(nil), // 304: productv1.RequireStorageTagsByLengthsByIdFields + (*RequireStorageKindSummaryByIdRequest)(nil), // 305: productv1.RequireStorageKindSummaryByIdRequest + (*RequireStorageKindSummaryByIdContext)(nil), // 306: productv1.RequireStorageKindSummaryByIdContext + (*RequireStorageKindSummaryByIdResponse)(nil), // 307: productv1.RequireStorageKindSummaryByIdResponse + (*RequireStorageKindSummaryByIdResult)(nil), // 308: productv1.RequireStorageKindSummaryByIdResult + (*RequireStorageKindSummaryByIdFields)(nil), // 309: productv1.RequireStorageKindSummaryByIdFields + (*RequireStorageCategoryInfoSummaryByIdRequest)(nil), // 310: productv1.RequireStorageCategoryInfoSummaryByIdRequest + (*RequireStorageCategoryInfoSummaryByIdContext)(nil), // 311: productv1.RequireStorageCategoryInfoSummaryByIdContext + (*RequireStorageCategoryInfoSummaryByIdResponse)(nil), // 312: productv1.RequireStorageCategoryInfoSummaryByIdResponse + (*RequireStorageCategoryInfoSummaryByIdResult)(nil), // 313: productv1.RequireStorageCategoryInfoSummaryByIdResult + (*RequireStorageCategoryInfoSummaryByIdFields)(nil), // 314: productv1.RequireStorageCategoryInfoSummaryByIdFields + (*RequireStorageItemInfoByIdRequest)(nil), // 315: productv1.RequireStorageItemInfoByIdRequest + (*RequireStorageItemInfoByIdContext)(nil), // 316: productv1.RequireStorageItemInfoByIdContext + (*RequireStorageItemInfoByIdResponse)(nil), // 317: productv1.RequireStorageItemInfoByIdResponse + (*RequireStorageItemInfoByIdResult)(nil), // 318: productv1.RequireStorageItemInfoByIdResult + (*RequireStorageItemInfoByIdFields)(nil), // 319: productv1.RequireStorageItemInfoByIdFields + (*RequireStorageOperationReportByIdRequest)(nil), // 320: productv1.RequireStorageOperationReportByIdRequest + (*RequireStorageOperationReportByIdContext)(nil), // 321: productv1.RequireStorageOperationReportByIdContext + (*RequireStorageOperationReportByIdResponse)(nil), // 322: productv1.RequireStorageOperationReportByIdResponse + (*RequireStorageOperationReportByIdResult)(nil), // 323: productv1.RequireStorageOperationReportByIdResult + (*RequireStorageOperationReportByIdFields)(nil), // 324: productv1.RequireStorageOperationReportByIdFields + (*RequireStorageSecuritySummaryByIdRequest)(nil), // 325: productv1.RequireStorageSecuritySummaryByIdRequest + (*RequireStorageSecuritySummaryByIdContext)(nil), // 326: productv1.RequireStorageSecuritySummaryByIdContext + (*RequireStorageSecuritySummaryByIdResponse)(nil), // 327: productv1.RequireStorageSecuritySummaryByIdResponse + (*RequireStorageSecuritySummaryByIdResult)(nil), // 328: productv1.RequireStorageSecuritySummaryByIdResult + (*RequireStorageSecuritySummaryByIdFields)(nil), // 329: productv1.RequireStorageSecuritySummaryByIdFields + (*RequireStorageItemHandlerInfoByIdRequest)(nil), // 330: productv1.RequireStorageItemHandlerInfoByIdRequest + (*RequireStorageItemHandlerInfoByIdContext)(nil), // 331: productv1.RequireStorageItemHandlerInfoByIdContext + (*RequireStorageItemHandlerInfoByIdResponse)(nil), // 332: productv1.RequireStorageItemHandlerInfoByIdResponse + (*RequireStorageItemHandlerInfoByIdResult)(nil), // 333: productv1.RequireStorageItemHandlerInfoByIdResult + (*RequireStorageItemHandlerInfoByIdFields)(nil), // 334: productv1.RequireStorageItemHandlerInfoByIdFields + (*RequireStorageItemSpecsInfoByIdRequest)(nil), // 335: productv1.RequireStorageItemSpecsInfoByIdRequest + (*RequireStorageItemSpecsInfoByIdContext)(nil), // 336: productv1.RequireStorageItemSpecsInfoByIdContext + (*RequireStorageItemSpecsInfoByIdResponse)(nil), // 337: productv1.RequireStorageItemSpecsInfoByIdResponse + (*RequireStorageItemSpecsInfoByIdResult)(nil), // 338: productv1.RequireStorageItemSpecsInfoByIdResult + (*RequireStorageItemSpecsInfoByIdFields)(nil), // 339: productv1.RequireStorageItemSpecsInfoByIdFields + (*RequireStorageDeepItemInfoByIdRequest)(nil), // 340: productv1.RequireStorageDeepItemInfoByIdRequest + (*RequireStorageDeepItemInfoByIdContext)(nil), // 341: productv1.RequireStorageDeepItemInfoByIdContext + (*RequireStorageDeepItemInfoByIdResponse)(nil), // 342: productv1.RequireStorageDeepItemInfoByIdResponse + (*RequireStorageDeepItemInfoByIdResult)(nil), // 343: productv1.RequireStorageDeepItemInfoByIdResult + (*RequireStorageDeepItemInfoByIdFields)(nil), // 344: productv1.RequireStorageDeepItemInfoByIdFields + (*RequireStorageRecommendedItemByIdRequest)(nil), // 345: productv1.RequireStorageRecommendedItemByIdRequest + (*RequireStorageRecommendedItemByIdContext)(nil), // 346: productv1.RequireStorageRecommendedItemByIdContext + (*RequireStorageRecommendedItemByIdResponse)(nil), // 347: productv1.RequireStorageRecommendedItemByIdResponse + (*RequireStorageRecommendedItemByIdResult)(nil), // 348: productv1.RequireStorageRecommendedItemByIdResult + (*RequireStorageRecommendedItemByIdFields)(nil), // 349: productv1.RequireStorageRecommendedItemByIdFields + (*RequireStorageRecommendedItemsByIdRequest)(nil), // 350: productv1.RequireStorageRecommendedItemsByIdRequest + (*RequireStorageRecommendedItemsByIdContext)(nil), // 351: productv1.RequireStorageRecommendedItemsByIdContext + (*RequireStorageRecommendedItemsByIdResponse)(nil), // 352: productv1.RequireStorageRecommendedItemsByIdResponse + (*RequireStorageRecommendedItemsByIdResult)(nil), // 353: productv1.RequireStorageRecommendedItemsByIdResult + (*RequireStorageRecommendedItemsByIdFields)(nil), // 354: productv1.RequireStorageRecommendedItemsByIdFields + (*RequireStorageLatestOperationByIdRequest)(nil), // 355: productv1.RequireStorageLatestOperationByIdRequest + (*RequireStorageLatestOperationByIdContext)(nil), // 356: productv1.RequireStorageLatestOperationByIdContext + (*RequireStorageLatestOperationByIdResponse)(nil), // 357: productv1.RequireStorageLatestOperationByIdResponse + (*RequireStorageLatestOperationByIdResult)(nil), // 358: productv1.RequireStorageLatestOperationByIdResult + (*RequireStorageLatestOperationByIdFields)(nil), // 359: productv1.RequireStorageLatestOperationByIdFields + (*RequireStorageOptionalLatestOperationByIdRequest)(nil), // 360: productv1.RequireStorageOptionalLatestOperationByIdRequest + (*RequireStorageOptionalLatestOperationByIdContext)(nil), // 361: productv1.RequireStorageOptionalLatestOperationByIdContext + (*RequireStorageOptionalLatestOperationByIdResponse)(nil), // 362: productv1.RequireStorageOptionalLatestOperationByIdResponse + (*RequireStorageOptionalLatestOperationByIdResult)(nil), // 363: productv1.RequireStorageOptionalLatestOperationByIdResult + (*RequireStorageOptionalLatestOperationByIdFields)(nil), // 364: productv1.RequireStorageOptionalLatestOperationByIdFields + (*RequireStorageOptionalRecommendedItemsByIdRequest)(nil), // 365: productv1.RequireStorageOptionalRecommendedItemsByIdRequest + (*RequireStorageOptionalRecommendedItemsByIdContext)(nil), // 366: productv1.RequireStorageOptionalRecommendedItemsByIdContext + (*RequireStorageOptionalRecommendedItemsByIdResponse)(nil), // 367: productv1.RequireStorageOptionalRecommendedItemsByIdResponse + (*RequireStorageOptionalRecommendedItemsByIdResult)(nil), // 368: productv1.RequireStorageOptionalRecommendedItemsByIdResult + (*RequireStorageOptionalRecommendedItemsByIdFields)(nil), // 369: productv1.RequireStorageOptionalRecommendedItemsByIdFields + (*RequireStorageOptionalOperationHistoryByIdRequest)(nil), // 370: productv1.RequireStorageOptionalOperationHistoryByIdRequest + (*RequireStorageOptionalOperationHistoryByIdContext)(nil), // 371: productv1.RequireStorageOptionalOperationHistoryByIdContext + (*RequireStorageOptionalOperationHistoryByIdResponse)(nil), // 372: productv1.RequireStorageOptionalOperationHistoryByIdResponse + (*RequireStorageOptionalOperationHistoryByIdResult)(nil), // 373: productv1.RequireStorageOptionalOperationHistoryByIdResult + (*RequireStorageOptionalOperationHistoryByIdFields)(nil), // 374: productv1.RequireStorageOptionalOperationHistoryByIdFields + (*RequireStorageFilteredTagSummaryByIdRequest)(nil), // 375: productv1.RequireStorageFilteredTagSummaryByIdRequest + (*RequireStorageFilteredTagSummaryByIdContext)(nil), // 376: productv1.RequireStorageFilteredTagSummaryByIdContext + (*RequireStorageFilteredTagSummaryByIdArgs)(nil), // 377: productv1.RequireStorageFilteredTagSummaryByIdArgs + (*RequireStorageFilteredTagSummaryByIdResponse)(nil), // 378: productv1.RequireStorageFilteredTagSummaryByIdResponse + (*RequireStorageFilteredTagSummaryByIdResult)(nil), // 379: productv1.RequireStorageFilteredTagSummaryByIdResult + (*RequireStorageFilteredTagSummaryByIdFields)(nil), // 380: productv1.RequireStorageFilteredTagSummaryByIdFields + (*RequireStorageMultiFilteredTagSummaryByIdRequest)(nil), // 381: productv1.RequireStorageMultiFilteredTagSummaryByIdRequest + (*RequireStorageMultiFilteredTagSummaryByIdContext)(nil), // 382: productv1.RequireStorageMultiFilteredTagSummaryByIdContext + (*RequireStorageMultiFilteredTagSummaryByIdArgs)(nil), // 383: productv1.RequireStorageMultiFilteredTagSummaryByIdArgs + (*RequireStorageMultiFilteredTagSummaryByIdResponse)(nil), // 384: productv1.RequireStorageMultiFilteredTagSummaryByIdResponse + (*RequireStorageMultiFilteredTagSummaryByIdResult)(nil), // 385: productv1.RequireStorageMultiFilteredTagSummaryByIdResult + (*RequireStorageMultiFilteredTagSummaryByIdFields)(nil), // 386: productv1.RequireStorageMultiFilteredTagSummaryByIdFields + (*RequireStorageNullableFilteredTagSummaryByIdRequest)(nil), // 387: productv1.RequireStorageNullableFilteredTagSummaryByIdRequest + (*RequireStorageNullableFilteredTagSummaryByIdContext)(nil), // 388: productv1.RequireStorageNullableFilteredTagSummaryByIdContext + (*RequireStorageNullableFilteredTagSummaryByIdArgs)(nil), // 389: productv1.RequireStorageNullableFilteredTagSummaryByIdArgs + (*RequireStorageNullableFilteredTagSummaryByIdResponse)(nil), // 390: productv1.RequireStorageNullableFilteredTagSummaryByIdResponse + (*RequireStorageNullableFilteredTagSummaryByIdResult)(nil), // 391: productv1.RequireStorageNullableFilteredTagSummaryByIdResult + (*RequireStorageNullableFilteredTagSummaryByIdFields)(nil), // 392: productv1.RequireStorageNullableFilteredTagSummaryByIdFields + (*RequireWarehouseStockHealthScoreByIdRequest)(nil), // 393: productv1.RequireWarehouseStockHealthScoreByIdRequest + (*RequireWarehouseStockHealthScoreByIdContext)(nil), // 394: productv1.RequireWarehouseStockHealthScoreByIdContext + (*RequireWarehouseStockHealthScoreByIdResponse)(nil), // 395: productv1.RequireWarehouseStockHealthScoreByIdResponse + (*RequireWarehouseStockHealthScoreByIdResult)(nil), // 396: productv1.RequireWarehouseStockHealthScoreByIdResult + (*RequireWarehouseStockHealthScoreByIdFields)(nil), // 397: productv1.RequireWarehouseStockHealthScoreByIdFields + (*Product)(nil), // 398: productv1.Product + (*Storage)(nil), // 399: productv1.Storage + (*Warehouse)(nil), // 400: productv1.Warehouse + (*User)(nil), // 401: productv1.User + (*NestedTypeA)(nil), // 402: productv1.NestedTypeA + (*RecursiveType)(nil), // 403: productv1.RecursiveType + (*TypeWithMultipleFilterFields)(nil), // 404: productv1.TypeWithMultipleFilterFields + (*FilterTypeInput)(nil), // 405: productv1.FilterTypeInput + (*ComplexFilterTypeInput)(nil), // 406: productv1.ComplexFilterTypeInput + (*TypeWithComplexFilterInput)(nil), // 407: productv1.TypeWithComplexFilterInput + (*OrderInput)(nil), // 408: productv1.OrderInput + (*Order)(nil), // 409: productv1.Order + (*Category)(nil), // 410: productv1.Category + (*CategoryFilter)(nil), // 411: productv1.CategoryFilter + (*Animal)(nil), // 412: productv1.Animal + (*SearchInput)(nil), // 413: productv1.SearchInput + (*SearchResult)(nil), // 414: productv1.SearchResult + (*NullableFieldsType)(nil), // 415: productv1.NullableFieldsType + (*NullableFieldsFilter)(nil), // 416: productv1.NullableFieldsFilter + (*BlogPost)(nil), // 417: productv1.BlogPost + (*BlogPostFilter)(nil), // 418: productv1.BlogPostFilter + (*Author)(nil), // 419: productv1.Author + (*AuthorFilter)(nil), // 420: productv1.AuthorFilter + (*TestContainer)(nil), // 421: productv1.TestContainer + (*ConditionsInput)(nil), // 422: productv1.ConditionsInput + (*ConditionalSearchResult)(nil), // 423: productv1.ConditionalSearchResult + (*UserInput)(nil), // 424: productv1.UserInput + (*ActionInput)(nil), // 425: productv1.ActionInput + (*ActionResult)(nil), // 426: productv1.ActionResult + (*NullableFieldsInput)(nil), // 427: productv1.NullableFieldsInput + (*BlogPostInput)(nil), // 428: productv1.BlogPostInput + (*AuthorInput)(nil), // 429: productv1.AuthorInput + (*ProductDetails)(nil), // 430: productv1.ProductDetails + (*RestockData)(nil), // 431: productv1.RestockData + (*StorageMetadata)(nil), // 432: productv1.StorageMetadata + (*StorageCategoryInfo)(nil), // 433: productv1.StorageCategoryInfo + (*NestedTypeB)(nil), // 434: productv1.NestedTypeB + (*NestedTypeC)(nil), // 435: productv1.NestedTypeC + (*FilterType)(nil), // 436: productv1.FilterType + (*Pagination)(nil), // 437: productv1.Pagination + (*OrderLineInput)(nil), // 438: productv1.OrderLineInput + (*OrderLine)(nil), // 439: productv1.OrderLine + (*Subcategory)(nil), // 440: productv1.Subcategory + (*CategoryMetrics)(nil), // 441: productv1.CategoryMetrics + (*Cat)(nil), // 442: productv1.Cat + (*Dog)(nil), // 443: productv1.Dog + (*Owner)(nil), // 444: productv1.Owner + (*ContactInfo)(nil), // 445: productv1.ContactInfo + (*Address)(nil), // 446: productv1.Address + (*CatBreed)(nil), // 447: productv1.CatBreed + (*DogBreed)(nil), // 448: productv1.DogBreed + (*BreedCharacteristics)(nil), // 449: productv1.BreedCharacteristics + (*StorageItem)(nil), // 450: productv1.StorageItem + (*PalletItem)(nil), // 451: productv1.PalletItem + (*ContainerItem)(nil), // 452: productv1.ContainerItem + (*ItemHandler)(nil), // 453: productv1.ItemHandler + (*PalletSpecs)(nil), // 454: productv1.PalletSpecs + (*ContainerSpecs)(nil), // 455: productv1.ContainerSpecs + (*Dimensions)(nil), // 456: productv1.Dimensions + (*StorageOperationResult)(nil), // 457: productv1.StorageOperationResult + (*StorageSuccess)(nil), // 458: productv1.StorageSuccess + (*StorageFailure)(nil), // 459: productv1.StorageFailure + (*SecuritySetup)(nil), // 460: productv1.SecuritySetup + (*ActionSuccess)(nil), // 461: productv1.ActionSuccess + (*ActionError)(nil), // 462: productv1.ActionError + (*TestDetails)(nil), // 463: productv1.TestDetails + (*CategoryInput)(nil), // 464: productv1.CategoryInput + (*ProductCountFilter)(nil), // 465: productv1.ProductCountFilter + (*SubcategoryItemFilter)(nil), // 466: productv1.SubcategoryItemFilter + (*ShippingEstimateInput)(nil), // 467: productv1.ShippingEstimateInput + (*ListOfAuthorFilter_List)(nil), // 468: productv1.ListOfAuthorFilter.List + (*ListOfAuthorInput_List)(nil), // 469: productv1.ListOfAuthorInput.List + (*ListOfBlogPost_List)(nil), // 470: productv1.ListOfBlogPost.List + (*ListOfBlogPostFilter_List)(nil), // 471: productv1.ListOfBlogPostFilter.List + (*ListOfBlogPostInput_List)(nil), // 472: productv1.ListOfBlogPostInput.List + (*ListOfBoolean_List)(nil), // 473: productv1.ListOfBoolean.List + (*ListOfCategory_List)(nil), // 474: productv1.ListOfCategory.List + (*ListOfCategoryInput_List)(nil), // 475: productv1.ListOfCategoryInput.List + (*ListOfConditionsInput_List)(nil), // 476: productv1.ListOfConditionsInput.List + (*ListOfFloat_List)(nil), // 477: productv1.ListOfFloat.List + (*ListOfInt_List)(nil), // 478: productv1.ListOfInt.List + (*ListOfListOfCategory_List)(nil), // 479: productv1.ListOfListOfCategory.List + (*ListOfListOfCategoryInput_List)(nil), // 480: productv1.ListOfListOfCategoryInput.List + (*ListOfListOfString_List)(nil), // 481: productv1.ListOfListOfString.List + (*ListOfListOfUser_List)(nil), // 482: productv1.ListOfListOfUser.List + (*ListOfListOfUserInput_List)(nil), // 483: productv1.ListOfListOfUserInput.List + (*ListOfOrderLine_List)(nil), // 484: productv1.ListOfOrderLine.List + (*ListOfProduct_List)(nil), // 485: productv1.ListOfProduct.List + (*ListOfStorage_List)(nil), // 486: productv1.ListOfStorage.List + (*ListOfStorageItem_List)(nil), // 487: productv1.ListOfStorageItem.List + (*ListOfStorageMetadata_List)(nil), // 488: productv1.ListOfStorageMetadata.List + (*ListOfStorageOperationResult_List)(nil), // 489: productv1.ListOfStorageOperationResult.List + (*ListOfString_List)(nil), // 490: productv1.ListOfString.List + (*ListOfSubcategory_List)(nil), // 491: productv1.ListOfSubcategory.List + (*ListOfUser_List)(nil), // 492: productv1.ListOfUser.List + (*ListOfUserInput_List)(nil), // 493: productv1.ListOfUserInput.List + (*RequireStorageStockHealthScoreByIdFields_RestockData)(nil), // 494: productv1.RequireStorageStockHealthScoreByIdFields.RestockData + (*RequireStorageMetadataScoreByIdFields_StorageMetadata)(nil), // 495: productv1.RequireStorageMetadataScoreByIdFields.StorageMetadata + (*RequireStorageProcessedMetadataByIdFields_StorageMetadata)(nil), // 496: productv1.RequireStorageProcessedMetadataByIdFields.StorageMetadata + (*RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata)(nil), // 497: productv1.RequireStorageOptionalProcessedMetadataByIdFields.StorageMetadata + (*RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata)(nil), // 498: productv1.RequireStorageProcessedMetadataHistoryByIdFields.StorageMetadata + (*RequireStorageOptionalProcessedMetadataHistoryByIdFields_StorageMetadata)(nil), // 499: productv1.RequireStorageOptionalProcessedMetadataHistoryByIdFields.StorageMetadata + (*RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo)(nil), // 500: productv1.RequireStorageCategoryInfoSummaryByIdFields.StorageCategoryInfo + (*RequireStorageItemInfoByIdFields_PalletItem)(nil), // 501: productv1.RequireStorageItemInfoByIdFields.PalletItem + (*RequireStorageItemInfoByIdFields_ContainerItem)(nil), // 502: productv1.RequireStorageItemInfoByIdFields.ContainerItem + (*RequireStorageItemInfoByIdFields_StorageItem)(nil), // 503: productv1.RequireStorageItemInfoByIdFields.StorageItem + (*RequireStorageOperationReportByIdFields_StorageSuccess)(nil), // 504: productv1.RequireStorageOperationReportByIdFields.StorageSuccess + (*RequireStorageOperationReportByIdFields_StorageFailure)(nil), // 505: productv1.RequireStorageOperationReportByIdFields.StorageFailure + (*RequireStorageOperationReportByIdFields_StorageOperationResult)(nil), // 506: productv1.RequireStorageOperationReportByIdFields.StorageOperationResult + (*RequireStorageSecuritySummaryByIdFields_SecuritySetup)(nil), // 507: productv1.RequireStorageSecuritySummaryByIdFields.SecuritySetup + (*RequireStorageSecuritySummaryByIdFields_SecuritySetup_PalletItem)(nil), // 508: productv1.RequireStorageSecuritySummaryByIdFields.SecuritySetup.PalletItem + (*RequireStorageSecuritySummaryByIdFields_SecuritySetup_ContainerItem)(nil), // 509: productv1.RequireStorageSecuritySummaryByIdFields.SecuritySetup.ContainerItem + (*RequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem)(nil), // 510: productv1.RequireStorageSecuritySummaryByIdFields.SecuritySetup.StorageItem + (*RequireStorageItemHandlerInfoByIdFields_PalletItem)(nil), // 511: productv1.RequireStorageItemHandlerInfoByIdFields.PalletItem + (*RequireStorageItemHandlerInfoByIdFields_ContainerItem)(nil), // 512: productv1.RequireStorageItemHandlerInfoByIdFields.ContainerItem + (*RequireStorageItemHandlerInfoByIdFields_StorageItem)(nil), // 513: productv1.RequireStorageItemHandlerInfoByIdFields.StorageItem + (*RequireStorageItemHandlerInfoByIdFields_PalletItem_ItemHandler)(nil), // 514: productv1.RequireStorageItemHandlerInfoByIdFields.PalletItem.ItemHandler + (*RequireStorageItemHandlerInfoByIdFields_ContainerItem_ItemHandler)(nil), // 515: productv1.RequireStorageItemHandlerInfoByIdFields.ContainerItem.ItemHandler + (*RequireStorageItemSpecsInfoByIdFields_PalletItem)(nil), // 516: productv1.RequireStorageItemSpecsInfoByIdFields.PalletItem + (*RequireStorageItemSpecsInfoByIdFields_ContainerItem)(nil), // 517: productv1.RequireStorageItemSpecsInfoByIdFields.ContainerItem + (*RequireStorageItemSpecsInfoByIdFields_StorageItem)(nil), // 518: productv1.RequireStorageItemSpecsInfoByIdFields.StorageItem + (*RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs)(nil), // 519: productv1.RequireStorageItemSpecsInfoByIdFields.PalletItem.PalletSpecs + (*RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs_Dimensions)(nil), // 520: productv1.RequireStorageItemSpecsInfoByIdFields.PalletItem.PalletSpecs.Dimensions + (*RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs)(nil), // 521: productv1.RequireStorageItemSpecsInfoByIdFields.ContainerItem.ContainerSpecs + (*RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs_Dimensions)(nil), // 522: productv1.RequireStorageItemSpecsInfoByIdFields.ContainerItem.ContainerSpecs.Dimensions + (*RequireStorageDeepItemInfoByIdFields_PalletItem)(nil), // 523: productv1.RequireStorageDeepItemInfoByIdFields.PalletItem + (*RequireStorageDeepItemInfoByIdFields_ContainerItem)(nil), // 524: productv1.RequireStorageDeepItemInfoByIdFields.ContainerItem + (*RequireStorageDeepItemInfoByIdFields_StorageItem)(nil), // 525: productv1.RequireStorageDeepItemInfoByIdFields.StorageItem + (*RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler)(nil), // 526: productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.ItemHandler + (*RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_ContainerItem)(nil), // 527: productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.ItemHandler.ContainerItem + (*RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_PalletItem)(nil), // 528: productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.ItemHandler.PalletItem + (*RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem)(nil), // 529: productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.ItemHandler.StorageItem + (*RequireStorageDeepItemInfoByIdFields_ContainerItem_ItemHandler)(nil), // 530: productv1.RequireStorageDeepItemInfoByIdFields.ContainerItem.ItemHandler + (*RequireStorageRecommendedItemByIdFields_StorageMetadata)(nil), // 531: productv1.RequireStorageRecommendedItemByIdFields.StorageMetadata + (*RequireWarehouseStockHealthScoreByIdFields_RestockData)(nil), // 532: productv1.RequireWarehouseStockHealthScoreByIdFields.RestockData + (*wrapperspb.Int32Value)(nil), // 533: google.protobuf.Int32Value + (*wrapperspb.BoolValue)(nil), // 534: google.protobuf.BoolValue + (*wrapperspb.StringValue)(nil), // 535: google.protobuf.StringValue + (*wrapperspb.DoubleValue)(nil), // 536: google.protobuf.DoubleValue } var file_product_proto_depIdxs = []int32{ - 443, // 0: productv1.ListOfAuthorFilter.list:type_name -> productv1.ListOfAuthorFilter.List - 444, // 1: productv1.ListOfAuthorInput.list:type_name -> productv1.ListOfAuthorInput.List - 445, // 2: productv1.ListOfBlogPost.list:type_name -> productv1.ListOfBlogPost.List - 446, // 3: productv1.ListOfBlogPostFilter.list:type_name -> productv1.ListOfBlogPostFilter.List - 447, // 4: productv1.ListOfBlogPostInput.list:type_name -> productv1.ListOfBlogPostInput.List - 448, // 5: productv1.ListOfBoolean.list:type_name -> productv1.ListOfBoolean.List - 449, // 6: productv1.ListOfCategory.list:type_name -> productv1.ListOfCategory.List - 450, // 7: productv1.ListOfCategoryInput.list:type_name -> productv1.ListOfCategoryInput.List - 451, // 8: productv1.ListOfConditionsInput.list:type_name -> productv1.ListOfConditionsInput.List - 452, // 9: productv1.ListOfFloat.list:type_name -> productv1.ListOfFloat.List - 453, // 10: productv1.ListOfListOfCategory.list:type_name -> productv1.ListOfListOfCategory.List - 454, // 11: productv1.ListOfListOfCategoryInput.list:type_name -> productv1.ListOfListOfCategoryInput.List - 455, // 12: productv1.ListOfListOfString.list:type_name -> productv1.ListOfListOfString.List - 456, // 13: productv1.ListOfListOfUser.list:type_name -> productv1.ListOfListOfUser.List - 457, // 14: productv1.ListOfListOfUserInput.list:type_name -> productv1.ListOfListOfUserInput.List - 458, // 15: productv1.ListOfOrderLine.list:type_name -> productv1.ListOfOrderLine.List - 459, // 16: productv1.ListOfProduct.list:type_name -> productv1.ListOfProduct.List - 460, // 17: productv1.ListOfStorage.list:type_name -> productv1.ListOfStorage.List - 461, // 18: productv1.ListOfString.list:type_name -> productv1.ListOfString.List - 462, // 19: productv1.ListOfSubcategory.list:type_name -> productv1.ListOfSubcategory.List - 463, // 20: productv1.ListOfUser.list:type_name -> productv1.ListOfUser.List - 464, // 21: productv1.ListOfUserInput.list:type_name -> productv1.ListOfUserInput.List - 24, // 22: productv1.LookupProductByIdRequest.keys:type_name -> productv1.LookupProductByIdRequestKey - 373, // 23: productv1.LookupProductByIdResponse.result:type_name -> productv1.Product - 27, // 24: productv1.LookupStorageByIdRequest.keys:type_name -> productv1.LookupStorageByIdRequestKey - 374, // 25: productv1.LookupStorageByIdResponse.result:type_name -> productv1.Storage - 30, // 26: productv1.LookupWarehouseByIdRequest.keys:type_name -> productv1.LookupWarehouseByIdRequestKey - 375, // 27: productv1.LookupWarehouseByIdResponse.result:type_name -> productv1.Warehouse - 376, // 28: productv1.QueryUsersResponse.users:type_name -> productv1.User - 376, // 29: productv1.QueryUserResponse.user:type_name -> productv1.User - 377, // 30: productv1.QueryNestedTypeResponse.nested_type:type_name -> productv1.NestedTypeA - 378, // 31: productv1.QueryRecursiveTypeResponse.recursive_type:type_name -> productv1.RecursiveType - 379, // 32: productv1.QueryTypeFilterWithArgumentsResponse.type_filter_with_arguments:type_name -> productv1.TypeWithMultipleFilterFields - 380, // 33: productv1.QueryTypeWithMultipleFilterFieldsRequest.filter:type_name -> productv1.FilterTypeInput - 379, // 34: productv1.QueryTypeWithMultipleFilterFieldsResponse.type_with_multiple_filter_fields:type_name -> productv1.TypeWithMultipleFilterFields - 381, // 35: productv1.QueryComplexFilterTypeRequest.filter:type_name -> productv1.ComplexFilterTypeInput - 382, // 36: productv1.QueryComplexFilterTypeResponse.complex_filter_type:type_name -> productv1.TypeWithComplexFilterInput - 383, // 37: productv1.QueryCalculateTotalsRequest.orders:type_name -> productv1.OrderInput - 384, // 38: productv1.QueryCalculateTotalsResponse.calculate_totals:type_name -> productv1.Order - 385, // 39: productv1.QueryCategoriesResponse.categories:type_name -> productv1.Category - 385, // 40: productv1.QueryCategoryResponse.category:type_name -> productv1.Category - 0, // 41: productv1.QueryCategoriesByKindRequest.kind:type_name -> productv1.CategoryKind - 385, // 42: productv1.QueryCategoriesByKindResponse.categories_by_kind:type_name -> productv1.Category - 0, // 43: productv1.QueryCategoriesByKindsRequest.kinds:type_name -> productv1.CategoryKind - 385, // 44: productv1.QueryCategoriesByKindsResponse.categories_by_kinds:type_name -> productv1.Category - 386, // 45: productv1.QueryFilterCategoriesRequest.filter:type_name -> productv1.CategoryFilter - 385, // 46: productv1.QueryFilterCategoriesResponse.filter_categories:type_name -> productv1.Category - 387, // 47: productv1.QueryRandomPetResponse.random_pet:type_name -> productv1.Animal - 387, // 48: productv1.QueryAllPetsResponse.all_pets:type_name -> productv1.Animal - 388, // 49: productv1.QuerySearchRequest.input:type_name -> productv1.SearchInput - 389, // 50: productv1.QuerySearchResponse.search:type_name -> productv1.SearchResult - 389, // 51: productv1.QueryRandomSearchResultResponse.random_search_result:type_name -> productv1.SearchResult - 390, // 52: productv1.QueryNullableFieldsTypeResponse.nullable_fields_type:type_name -> productv1.NullableFieldsType - 390, // 53: productv1.QueryNullableFieldsTypeByIdResponse.nullable_fields_type_by_id:type_name -> productv1.NullableFieldsType - 391, // 54: productv1.QueryNullableFieldsTypeWithFilterRequest.filter:type_name -> productv1.NullableFieldsFilter - 390, // 55: productv1.QueryNullableFieldsTypeWithFilterResponse.nullable_fields_type_with_filter:type_name -> productv1.NullableFieldsType - 390, // 56: productv1.QueryAllNullableFieldsTypesResponse.all_nullable_fields_types:type_name -> productv1.NullableFieldsType - 392, // 57: productv1.QueryBlogPostResponse.blog_post:type_name -> productv1.BlogPost - 392, // 58: productv1.QueryBlogPostByIdResponse.blog_post_by_id:type_name -> productv1.BlogPost - 393, // 59: productv1.QueryBlogPostsWithFilterRequest.filter:type_name -> productv1.BlogPostFilter - 392, // 60: productv1.QueryBlogPostsWithFilterResponse.blog_posts_with_filter:type_name -> productv1.BlogPost - 392, // 61: productv1.QueryAllBlogPostsResponse.all_blog_posts:type_name -> productv1.BlogPost - 394, // 62: productv1.QueryAuthorResponse.author:type_name -> productv1.Author - 394, // 63: productv1.QueryAuthorByIdResponse.author_by_id:type_name -> productv1.Author - 395, // 64: productv1.QueryAuthorsWithFilterRequest.filter:type_name -> productv1.AuthorFilter - 394, // 65: productv1.QueryAuthorsWithFilterResponse.authors_with_filter:type_name -> productv1.Author - 394, // 66: productv1.QueryAllAuthorsResponse.all_authors:type_name -> productv1.Author - 2, // 67: productv1.QueryBulkSearchAuthorsRequest.filters:type_name -> productv1.ListOfAuthorFilter - 394, // 68: productv1.QueryBulkSearchAuthorsResponse.bulk_search_authors:type_name -> productv1.Author - 5, // 69: productv1.QueryBulkSearchBlogPostsRequest.filters:type_name -> productv1.ListOfBlogPostFilter - 392, // 70: productv1.QueryBulkSearchBlogPostsResponse.bulk_search_blog_posts:type_name -> productv1.BlogPost - 396, // 71: productv1.QueryTestContainerResponse.test_container:type_name -> productv1.TestContainer - 396, // 72: productv1.QueryTestContainersResponse.test_containers:type_name -> productv1.TestContainer - 397, // 73: productv1.QueryConditionalSearchRequest.conditions:type_name -> productv1.ConditionsInput - 398, // 74: productv1.QueryConditionalSearchResponse.conditional_search:type_name -> productv1.ConditionalSearchResult - 399, // 75: productv1.MutationCreateUserRequest.input:type_name -> productv1.UserInput - 376, // 76: productv1.MutationCreateUserResponse.create_user:type_name -> productv1.User - 400, // 77: productv1.MutationPerformActionRequest.input:type_name -> productv1.ActionInput - 401, // 78: productv1.MutationPerformActionResponse.perform_action:type_name -> productv1.ActionResult - 402, // 79: productv1.MutationCreateNullableFieldsTypeRequest.input:type_name -> productv1.NullableFieldsInput - 390, // 80: productv1.MutationCreateNullableFieldsTypeResponse.create_nullable_fields_type:type_name -> productv1.NullableFieldsType - 402, // 81: productv1.MutationUpdateNullableFieldsTypeRequest.input:type_name -> productv1.NullableFieldsInput - 390, // 82: productv1.MutationUpdateNullableFieldsTypeResponse.update_nullable_fields_type:type_name -> productv1.NullableFieldsType - 403, // 83: productv1.MutationCreateBlogPostRequest.input:type_name -> productv1.BlogPostInput - 392, // 84: productv1.MutationCreateBlogPostResponse.create_blog_post:type_name -> productv1.BlogPost - 403, // 85: productv1.MutationUpdateBlogPostRequest.input:type_name -> productv1.BlogPostInput - 392, // 86: productv1.MutationUpdateBlogPostResponse.update_blog_post:type_name -> productv1.BlogPost - 404, // 87: productv1.MutationCreateAuthorRequest.input:type_name -> productv1.AuthorInput - 394, // 88: productv1.MutationCreateAuthorResponse.create_author:type_name -> productv1.Author - 404, // 89: productv1.MutationUpdateAuthorRequest.input:type_name -> productv1.AuthorInput - 394, // 90: productv1.MutationUpdateAuthorResponse.update_author:type_name -> productv1.Author - 3, // 91: productv1.MutationBulkCreateAuthorsRequest.authors:type_name -> productv1.ListOfAuthorInput - 394, // 92: productv1.MutationBulkCreateAuthorsResponse.bulk_create_authors:type_name -> productv1.Author - 3, // 93: productv1.MutationBulkUpdateAuthorsRequest.authors:type_name -> productv1.ListOfAuthorInput - 394, // 94: productv1.MutationBulkUpdateAuthorsResponse.bulk_update_authors:type_name -> productv1.Author - 6, // 95: productv1.MutationBulkCreateBlogPostsRequest.blog_posts:type_name -> productv1.ListOfBlogPostInput - 392, // 96: productv1.MutationBulkCreateBlogPostsResponse.bulk_create_blog_posts:type_name -> productv1.BlogPost - 6, // 97: productv1.MutationBulkUpdateBlogPostsRequest.blog_posts:type_name -> productv1.ListOfBlogPostInput - 392, // 98: productv1.MutationBulkUpdateBlogPostsResponse.bulk_update_blog_posts:type_name -> productv1.BlogPost - 442, // 99: productv1.ResolveProductShippingEstimateArgs.input:type_name -> productv1.ShippingEstimateInput - 126, // 100: productv1.ResolveProductShippingEstimateRequest.context:type_name -> productv1.ResolveProductShippingEstimateContext - 125, // 101: productv1.ResolveProductShippingEstimateRequest.field_args:type_name -> productv1.ResolveProductShippingEstimateArgs - 128, // 102: productv1.ResolveProductShippingEstimateResponse.result:type_name -> productv1.ResolveProductShippingEstimateResult - 131, // 103: productv1.ResolveProductRecommendedCategoryRequest.context:type_name -> productv1.ResolveProductRecommendedCategoryContext - 130, // 104: productv1.ResolveProductRecommendedCategoryRequest.field_args:type_name -> productv1.ResolveProductRecommendedCategoryArgs - 385, // 105: productv1.ResolveProductRecommendedCategoryResult.recommended_category:type_name -> productv1.Category - 133, // 106: productv1.ResolveProductRecommendedCategoryResponse.result:type_name -> productv1.ResolveProductRecommendedCategoryResult - 136, // 107: productv1.ResolveProductMascotRecommendationRequest.context:type_name -> productv1.ResolveProductMascotRecommendationContext - 135, // 108: productv1.ResolveProductMascotRecommendationRequest.field_args:type_name -> productv1.ResolveProductMascotRecommendationArgs - 387, // 109: productv1.ResolveProductMascotRecommendationResult.mascot_recommendation:type_name -> productv1.Animal - 138, // 110: productv1.ResolveProductMascotRecommendationResponse.result:type_name -> productv1.ResolveProductMascotRecommendationResult - 141, // 111: productv1.ResolveProductStockStatusRequest.context:type_name -> productv1.ResolveProductStockStatusContext - 140, // 112: productv1.ResolveProductStockStatusRequest.field_args:type_name -> productv1.ResolveProductStockStatusArgs - 401, // 113: productv1.ResolveProductStockStatusResult.stock_status:type_name -> productv1.ActionResult - 143, // 114: productv1.ResolveProductStockStatusResponse.result:type_name -> productv1.ResolveProductStockStatusResult - 146, // 115: productv1.ResolveProductProductDetailsRequest.context:type_name -> productv1.ResolveProductProductDetailsContext - 145, // 116: productv1.ResolveProductProductDetailsRequest.field_args:type_name -> productv1.ResolveProductProductDetailsArgs - 405, // 117: productv1.ResolveProductProductDetailsResult.product_details:type_name -> productv1.ProductDetails - 148, // 118: productv1.ResolveProductProductDetailsResponse.result:type_name -> productv1.ResolveProductProductDetailsResult - 151, // 119: productv1.ResolveStorageStorageStatusRequest.context:type_name -> productv1.ResolveStorageStorageStatusContext - 150, // 120: productv1.ResolveStorageStorageStatusRequest.field_args:type_name -> productv1.ResolveStorageStorageStatusArgs - 401, // 121: productv1.ResolveStorageStorageStatusResult.storage_status:type_name -> productv1.ActionResult - 153, // 122: productv1.ResolveStorageStorageStatusResponse.result:type_name -> productv1.ResolveStorageStorageStatusResult - 156, // 123: productv1.ResolveStorageLinkedStoragesRequest.context:type_name -> productv1.ResolveStorageLinkedStoragesContext - 155, // 124: productv1.ResolveStorageLinkedStoragesRequest.field_args:type_name -> productv1.ResolveStorageLinkedStoragesArgs - 374, // 125: productv1.ResolveStorageLinkedStoragesResult.linked_storages:type_name -> productv1.Storage - 158, // 126: productv1.ResolveStorageLinkedStoragesResponse.result:type_name -> productv1.ResolveStorageLinkedStoragesResult - 503, // 127: productv1.ResolveStorageNearbyStoragesArgs.radius:type_name -> google.protobuf.Int32Value - 161, // 128: productv1.ResolveStorageNearbyStoragesRequest.context:type_name -> productv1.ResolveStorageNearbyStoragesContext - 160, // 129: productv1.ResolveStorageNearbyStoragesRequest.field_args:type_name -> productv1.ResolveStorageNearbyStoragesArgs - 19, // 130: productv1.ResolveStorageNearbyStoragesResult.nearby_storages:type_name -> productv1.ListOfStorage - 163, // 131: productv1.ResolveStorageNearbyStoragesResponse.result:type_name -> productv1.ResolveStorageNearbyStoragesResult - 440, // 132: productv1.ResolveCategoryProductCountArgs.filters:type_name -> productv1.ProductCountFilter - 166, // 133: productv1.ResolveCategoryProductCountRequest.context:type_name -> productv1.ResolveCategoryProductCountContext - 165, // 134: productv1.ResolveCategoryProductCountRequest.field_args:type_name -> productv1.ResolveCategoryProductCountArgs - 168, // 135: productv1.ResolveCategoryProductCountResponse.result:type_name -> productv1.ResolveCategoryProductCountResult - 503, // 136: productv1.ResolveCategoryPopularityScoreArgs.threshold:type_name -> google.protobuf.Int32Value - 171, // 137: productv1.ResolveCategoryPopularityScoreRequest.context:type_name -> productv1.ResolveCategoryPopularityScoreContext - 170, // 138: productv1.ResolveCategoryPopularityScoreRequest.field_args:type_name -> productv1.ResolveCategoryPopularityScoreArgs - 503, // 139: productv1.ResolveCategoryPopularityScoreResult.popularity_score:type_name -> google.protobuf.Int32Value - 173, // 140: productv1.ResolveCategoryPopularityScoreResponse.result:type_name -> productv1.ResolveCategoryPopularityScoreResult - 176, // 141: productv1.ResolveCategoryCategoryMetricsRequest.context:type_name -> productv1.ResolveCategoryCategoryMetricsContext - 175, // 142: productv1.ResolveCategoryCategoryMetricsRequest.field_args:type_name -> productv1.ResolveCategoryCategoryMetricsArgs - 416, // 143: productv1.ResolveCategoryCategoryMetricsResult.category_metrics:type_name -> productv1.CategoryMetrics - 178, // 144: productv1.ResolveCategoryCategoryMetricsResponse.result:type_name -> productv1.ResolveCategoryCategoryMetricsResult - 0, // 145: productv1.ResolveCategoryMascotContext.kind:type_name -> productv1.CategoryKind - 181, // 146: productv1.ResolveCategoryMascotRequest.context:type_name -> productv1.ResolveCategoryMascotContext - 180, // 147: productv1.ResolveCategoryMascotRequest.field_args:type_name -> productv1.ResolveCategoryMascotArgs - 387, // 148: productv1.ResolveCategoryMascotResult.mascot:type_name -> productv1.Animal - 183, // 149: productv1.ResolveCategoryMascotResponse.result:type_name -> productv1.ResolveCategoryMascotResult - 186, // 150: productv1.ResolveCategoryCategoryStatusRequest.context:type_name -> productv1.ResolveCategoryCategoryStatusContext - 185, // 151: productv1.ResolveCategoryCategoryStatusRequest.field_args:type_name -> productv1.ResolveCategoryCategoryStatusArgs - 401, // 152: productv1.ResolveCategoryCategoryStatusResult.category_status:type_name -> productv1.ActionResult - 188, // 153: productv1.ResolveCategoryCategoryStatusResponse.result:type_name -> productv1.ResolveCategoryCategoryStatusResult - 504, // 154: productv1.ResolveCategoryChildCategoriesArgs.include:type_name -> google.protobuf.BoolValue - 191, // 155: productv1.ResolveCategoryChildCategoriesRequest.context:type_name -> productv1.ResolveCategoryChildCategoriesContext - 190, // 156: productv1.ResolveCategoryChildCategoriesRequest.field_args:type_name -> productv1.ResolveCategoryChildCategoriesArgs - 385, // 157: productv1.ResolveCategoryChildCategoriesResult.child_categories:type_name -> productv1.Category - 193, // 158: productv1.ResolveCategoryChildCategoriesResponse.result:type_name -> productv1.ResolveCategoryChildCategoriesResult - 504, // 159: productv1.ResolveCategoryOptionalCategoriesArgs.include:type_name -> google.protobuf.BoolValue - 196, // 160: productv1.ResolveCategoryOptionalCategoriesRequest.context:type_name -> productv1.ResolveCategoryOptionalCategoriesContext - 195, // 161: productv1.ResolveCategoryOptionalCategoriesRequest.field_args:type_name -> productv1.ResolveCategoryOptionalCategoriesArgs - 8, // 162: productv1.ResolveCategoryOptionalCategoriesResult.optional_categories:type_name -> productv1.ListOfCategory - 198, // 163: productv1.ResolveCategoryOptionalCategoriesResponse.result:type_name -> productv1.ResolveCategoryOptionalCategoriesResult - 200, // 164: productv1.ResolveCategoryTotalProductsRequest.context:type_name -> productv1.ResolveCategoryTotalProductsContext - 202, // 165: productv1.ResolveCategoryTotalProductsResponse.result:type_name -> productv1.ResolveCategoryTotalProductsResult - 204, // 166: productv1.ResolveCategoryTopSubcategoryRequest.context:type_name -> productv1.ResolveCategoryTopSubcategoryContext - 415, // 167: productv1.ResolveCategoryTopSubcategoryResult.top_subcategory:type_name -> productv1.Subcategory - 206, // 168: productv1.ResolveCategoryTopSubcategoryResponse.result:type_name -> productv1.ResolveCategoryTopSubcategoryResult - 208, // 169: productv1.ResolveCategoryActiveSubcategoriesRequest.context:type_name -> productv1.ResolveCategoryActiveSubcategoriesContext - 415, // 170: productv1.ResolveCategoryActiveSubcategoriesResult.active_subcategories:type_name -> productv1.Subcategory - 210, // 171: productv1.ResolveCategoryActiveSubcategoriesResponse.result:type_name -> productv1.ResolveCategoryActiveSubcategoriesResult - 441, // 172: productv1.ResolveSubcategoryItemCountArgs.filters:type_name -> productv1.SubcategoryItemFilter - 213, // 173: productv1.ResolveSubcategoryItemCountRequest.context:type_name -> productv1.ResolveSubcategoryItemCountContext - 212, // 174: productv1.ResolveSubcategoryItemCountRequest.field_args:type_name -> productv1.ResolveSubcategoryItemCountArgs - 215, // 175: productv1.ResolveSubcategoryItemCountResponse.result:type_name -> productv1.ResolveSubcategoryItemCountResult - 218, // 176: productv1.ResolveSubcategoryFeaturedCategoryRequest.context:type_name -> productv1.ResolveSubcategoryFeaturedCategoryContext - 217, // 177: productv1.ResolveSubcategoryFeaturedCategoryRequest.field_args:type_name -> productv1.ResolveSubcategoryFeaturedCategoryArgs - 385, // 178: productv1.ResolveSubcategoryFeaturedCategoryResult.featured_category:type_name -> productv1.Category - 220, // 179: productv1.ResolveSubcategoryFeaturedCategoryResponse.result:type_name -> productv1.ResolveSubcategoryFeaturedCategoryResult - 222, // 180: productv1.ResolveSubcategoryParentCategoryRequest.context:type_name -> productv1.ResolveSubcategoryParentCategoryContext - 385, // 181: productv1.ResolveSubcategoryParentCategoryResult.parent_category:type_name -> productv1.Category - 224, // 182: productv1.ResolveSubcategoryParentCategoryResponse.result:type_name -> productv1.ResolveSubcategoryParentCategoryResult - 227, // 183: productv1.ResolveCategoryMetricsNormalizedScoreRequest.context:type_name -> productv1.ResolveCategoryMetricsNormalizedScoreContext - 226, // 184: productv1.ResolveCategoryMetricsNormalizedScoreRequest.field_args:type_name -> productv1.ResolveCategoryMetricsNormalizedScoreArgs - 229, // 185: productv1.ResolveCategoryMetricsNormalizedScoreResponse.result:type_name -> productv1.ResolveCategoryMetricsNormalizedScoreResult - 504, // 186: productv1.ResolveCategoryMetricsRelatedCategoryArgs.include:type_name -> google.protobuf.BoolValue - 232, // 187: productv1.ResolveCategoryMetricsRelatedCategoryRequest.context:type_name -> productv1.ResolveCategoryMetricsRelatedCategoryContext - 231, // 188: productv1.ResolveCategoryMetricsRelatedCategoryRequest.field_args:type_name -> productv1.ResolveCategoryMetricsRelatedCategoryArgs - 385, // 189: productv1.ResolveCategoryMetricsRelatedCategoryResult.related_category:type_name -> productv1.Category - 234, // 190: productv1.ResolveCategoryMetricsRelatedCategoryResponse.result:type_name -> productv1.ResolveCategoryMetricsRelatedCategoryResult - 236, // 191: productv1.ResolveCategoryMetricsAverageScoreRequest.context:type_name -> productv1.ResolveCategoryMetricsAverageScoreContext - 238, // 192: productv1.ResolveCategoryMetricsAverageScoreResponse.result:type_name -> productv1.ResolveCategoryMetricsAverageScoreResult - 241, // 193: productv1.ResolveTestContainerDetailsRequest.context:type_name -> productv1.ResolveTestContainerDetailsContext - 240, // 194: productv1.ResolveTestContainerDetailsRequest.field_args:type_name -> productv1.ResolveTestContainerDetailsArgs - 438, // 195: productv1.ResolveTestContainerDetailsResult.details:type_name -> productv1.TestDetails - 243, // 196: productv1.ResolveTestContainerDetailsResponse.result:type_name -> productv1.ResolveTestContainerDetailsResult - 246, // 197: productv1.RequireStorageStockHealthScoreByIdRequest.context:type_name -> productv1.RequireStorageStockHealthScoreByIdContext - 27, // 198: productv1.RequireStorageStockHealthScoreByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey - 249, // 199: productv1.RequireStorageStockHealthScoreByIdContext.fields:type_name -> productv1.RequireStorageStockHealthScoreByIdFields - 248, // 200: productv1.RequireStorageStockHealthScoreByIdResponse.result:type_name -> productv1.RequireStorageStockHealthScoreByIdResult - 465, // 201: productv1.RequireStorageStockHealthScoreByIdFields.restock_data:type_name -> productv1.RequireStorageStockHealthScoreByIdFields.RestockData - 251, // 202: productv1.RequireStorageTagSummaryByIdRequest.context:type_name -> productv1.RequireStorageTagSummaryByIdContext - 27, // 203: productv1.RequireStorageTagSummaryByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey - 254, // 204: productv1.RequireStorageTagSummaryByIdContext.fields:type_name -> productv1.RequireStorageTagSummaryByIdFields - 253, // 205: productv1.RequireStorageTagSummaryByIdResponse.result:type_name -> productv1.RequireStorageTagSummaryByIdResult - 256, // 206: productv1.RequireStorageOptionalTagSummaryByIdRequest.context:type_name -> productv1.RequireStorageOptionalTagSummaryByIdContext - 27, // 207: productv1.RequireStorageOptionalTagSummaryByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey - 259, // 208: productv1.RequireStorageOptionalTagSummaryByIdContext.fields:type_name -> productv1.RequireStorageOptionalTagSummaryByIdFields - 258, // 209: productv1.RequireStorageOptionalTagSummaryByIdResponse.result:type_name -> productv1.RequireStorageOptionalTagSummaryByIdResult - 505, // 210: productv1.RequireStorageOptionalTagSummaryByIdResult.optional_tag_summary:type_name -> google.protobuf.StringValue - 20, // 211: productv1.RequireStorageOptionalTagSummaryByIdFields.optional_tags:type_name -> productv1.ListOfString - 261, // 212: productv1.RequireStorageMetadataScoreByIdRequest.context:type_name -> productv1.RequireStorageMetadataScoreByIdContext - 27, // 213: productv1.RequireStorageMetadataScoreByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey - 264, // 214: productv1.RequireStorageMetadataScoreByIdContext.fields:type_name -> productv1.RequireStorageMetadataScoreByIdFields - 263, // 215: productv1.RequireStorageMetadataScoreByIdResponse.result:type_name -> productv1.RequireStorageMetadataScoreByIdResult - 466, // 216: productv1.RequireStorageMetadataScoreByIdFields.metadata:type_name -> productv1.RequireStorageMetadataScoreByIdFields.StorageMetadata - 266, // 217: productv1.RequireStorageProcessedMetadataByIdRequest.context:type_name -> productv1.RequireStorageProcessedMetadataByIdContext - 27, // 218: productv1.RequireStorageProcessedMetadataByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey - 269, // 219: productv1.RequireStorageProcessedMetadataByIdContext.fields:type_name -> productv1.RequireStorageProcessedMetadataByIdFields - 268, // 220: productv1.RequireStorageProcessedMetadataByIdResponse.result:type_name -> productv1.RequireStorageProcessedMetadataByIdResult - 407, // 221: productv1.RequireStorageProcessedMetadataByIdResult.processed_metadata:type_name -> productv1.StorageMetadata - 467, // 222: productv1.RequireStorageProcessedMetadataByIdFields.metadata:type_name -> productv1.RequireStorageProcessedMetadataByIdFields.StorageMetadata - 271, // 223: productv1.RequireStorageOptionalProcessedMetadataByIdRequest.context:type_name -> productv1.RequireStorageOptionalProcessedMetadataByIdContext - 27, // 224: productv1.RequireStorageOptionalProcessedMetadataByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey - 274, // 225: productv1.RequireStorageOptionalProcessedMetadataByIdContext.fields:type_name -> productv1.RequireStorageOptionalProcessedMetadataByIdFields - 273, // 226: productv1.RequireStorageOptionalProcessedMetadataByIdResponse.result:type_name -> productv1.RequireStorageOptionalProcessedMetadataByIdResult - 407, // 227: productv1.RequireStorageOptionalProcessedMetadataByIdResult.optional_processed_metadata:type_name -> productv1.StorageMetadata - 468, // 228: productv1.RequireStorageOptionalProcessedMetadataByIdFields.metadata:type_name -> productv1.RequireStorageOptionalProcessedMetadataByIdFields.StorageMetadata - 276, // 229: productv1.RequireStorageProcessedTagsByIdRequest.context:type_name -> productv1.RequireStorageProcessedTagsByIdContext - 27, // 230: productv1.RequireStorageProcessedTagsByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey - 279, // 231: productv1.RequireStorageProcessedTagsByIdContext.fields:type_name -> productv1.RequireStorageProcessedTagsByIdFields - 278, // 232: productv1.RequireStorageProcessedTagsByIdResponse.result:type_name -> productv1.RequireStorageProcessedTagsByIdResult - 281, // 233: productv1.RequireStorageOptionalProcessedTagsByIdRequest.context:type_name -> productv1.RequireStorageOptionalProcessedTagsByIdContext - 27, // 234: productv1.RequireStorageOptionalProcessedTagsByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey - 284, // 235: productv1.RequireStorageOptionalProcessedTagsByIdContext.fields:type_name -> productv1.RequireStorageOptionalProcessedTagsByIdFields - 283, // 236: productv1.RequireStorageOptionalProcessedTagsByIdResponse.result:type_name -> productv1.RequireStorageOptionalProcessedTagsByIdResult - 20, // 237: productv1.RequireStorageOptionalProcessedTagsByIdResult.optional_processed_tags:type_name -> productv1.ListOfString - 20, // 238: productv1.RequireStorageOptionalProcessedTagsByIdFields.optional_tags:type_name -> productv1.ListOfString - 286, // 239: productv1.RequireStorageProcessedMetadataHistoryByIdRequest.context:type_name -> productv1.RequireStorageProcessedMetadataHistoryByIdContext - 27, // 240: productv1.RequireStorageProcessedMetadataHistoryByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey - 289, // 241: productv1.RequireStorageProcessedMetadataHistoryByIdContext.fields:type_name -> productv1.RequireStorageProcessedMetadataHistoryByIdFields - 288, // 242: productv1.RequireStorageProcessedMetadataHistoryByIdResponse.result:type_name -> productv1.RequireStorageProcessedMetadataHistoryByIdResult - 407, // 243: productv1.RequireStorageProcessedMetadataHistoryByIdResult.processed_metadata_history:type_name -> productv1.StorageMetadata - 469, // 244: productv1.RequireStorageProcessedMetadataHistoryByIdFields.metadata_history:type_name -> productv1.RequireStorageProcessedMetadataHistoryByIdFields.StorageMetadata - 291, // 245: productv1.RequireStorageKindSummaryByIdRequest.context:type_name -> productv1.RequireStorageKindSummaryByIdContext - 27, // 246: productv1.RequireStorageKindSummaryByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey - 294, // 247: productv1.RequireStorageKindSummaryByIdContext.fields:type_name -> productv1.RequireStorageKindSummaryByIdFields - 293, // 248: productv1.RequireStorageKindSummaryByIdResponse.result:type_name -> productv1.RequireStorageKindSummaryByIdResult - 0, // 249: productv1.RequireStorageKindSummaryByIdFields.storage_kind:type_name -> productv1.CategoryKind - 296, // 250: productv1.RequireStorageCategoryInfoSummaryByIdRequest.context:type_name -> productv1.RequireStorageCategoryInfoSummaryByIdContext - 27, // 251: productv1.RequireStorageCategoryInfoSummaryByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey - 299, // 252: productv1.RequireStorageCategoryInfoSummaryByIdContext.fields:type_name -> productv1.RequireStorageCategoryInfoSummaryByIdFields - 298, // 253: productv1.RequireStorageCategoryInfoSummaryByIdResponse.result:type_name -> productv1.RequireStorageCategoryInfoSummaryByIdResult - 470, // 254: productv1.RequireStorageCategoryInfoSummaryByIdFields.category_info:type_name -> productv1.RequireStorageCategoryInfoSummaryByIdFields.StorageCategoryInfo - 301, // 255: productv1.RequireStorageItemInfoByIdRequest.context:type_name -> productv1.RequireStorageItemInfoByIdContext - 27, // 256: productv1.RequireStorageItemInfoByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey - 304, // 257: productv1.RequireStorageItemInfoByIdContext.fields:type_name -> productv1.RequireStorageItemInfoByIdFields - 303, // 258: productv1.RequireStorageItemInfoByIdResponse.result:type_name -> productv1.RequireStorageItemInfoByIdResult - 473, // 259: productv1.RequireStorageItemInfoByIdFields.primary_item:type_name -> productv1.RequireStorageItemInfoByIdFields.StorageItem - 306, // 260: productv1.RequireStorageOperationReportByIdRequest.context:type_name -> productv1.RequireStorageOperationReportByIdContext - 27, // 261: productv1.RequireStorageOperationReportByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey - 309, // 262: productv1.RequireStorageOperationReportByIdContext.fields:type_name -> productv1.RequireStorageOperationReportByIdFields - 308, // 263: productv1.RequireStorageOperationReportByIdResponse.result:type_name -> productv1.RequireStorageOperationReportByIdResult - 476, // 264: productv1.RequireStorageOperationReportByIdFields.last_storage_operation:type_name -> productv1.RequireStorageOperationReportByIdFields.StorageOperationResult - 311, // 265: productv1.RequireStorageSecuritySummaryByIdRequest.context:type_name -> productv1.RequireStorageSecuritySummaryByIdContext - 27, // 266: productv1.RequireStorageSecuritySummaryByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey - 314, // 267: productv1.RequireStorageSecuritySummaryByIdContext.fields:type_name -> productv1.RequireStorageSecuritySummaryByIdFields - 313, // 268: productv1.RequireStorageSecuritySummaryByIdResponse.result:type_name -> productv1.RequireStorageSecuritySummaryByIdResult - 477, // 269: productv1.RequireStorageSecuritySummaryByIdFields.security_setup:type_name -> productv1.RequireStorageSecuritySummaryByIdFields.SecuritySetup - 316, // 270: productv1.RequireStorageItemHandlerInfoByIdRequest.context:type_name -> productv1.RequireStorageItemHandlerInfoByIdContext - 27, // 271: productv1.RequireStorageItemHandlerInfoByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey - 319, // 272: productv1.RequireStorageItemHandlerInfoByIdContext.fields:type_name -> productv1.RequireStorageItemHandlerInfoByIdFields - 318, // 273: productv1.RequireStorageItemHandlerInfoByIdResponse.result:type_name -> productv1.RequireStorageItemHandlerInfoByIdResult - 483, // 274: productv1.RequireStorageItemHandlerInfoByIdFields.primary_item:type_name -> productv1.RequireStorageItemHandlerInfoByIdFields.StorageItem - 321, // 275: productv1.RequireStorageItemSpecsInfoByIdRequest.context:type_name -> productv1.RequireStorageItemSpecsInfoByIdContext - 27, // 276: productv1.RequireStorageItemSpecsInfoByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey - 324, // 277: productv1.RequireStorageItemSpecsInfoByIdContext.fields:type_name -> productv1.RequireStorageItemSpecsInfoByIdFields - 323, // 278: productv1.RequireStorageItemSpecsInfoByIdResponse.result:type_name -> productv1.RequireStorageItemSpecsInfoByIdResult - 488, // 279: productv1.RequireStorageItemSpecsInfoByIdFields.primary_item:type_name -> productv1.RequireStorageItemSpecsInfoByIdFields.StorageItem - 326, // 280: productv1.RequireStorageDeepItemInfoByIdRequest.context:type_name -> productv1.RequireStorageDeepItemInfoByIdContext - 27, // 281: productv1.RequireStorageDeepItemInfoByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey - 329, // 282: productv1.RequireStorageDeepItemInfoByIdContext.fields:type_name -> productv1.RequireStorageDeepItemInfoByIdFields - 328, // 283: productv1.RequireStorageDeepItemInfoByIdResponse.result:type_name -> productv1.RequireStorageDeepItemInfoByIdResult - 495, // 284: productv1.RequireStorageDeepItemInfoByIdFields.primary_item:type_name -> productv1.RequireStorageDeepItemInfoByIdFields.StorageItem - 331, // 285: productv1.RequireStorageRecommendedItemByIdRequest.context:type_name -> productv1.RequireStorageRecommendedItemByIdContext - 27, // 286: productv1.RequireStorageRecommendedItemByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey - 334, // 287: productv1.RequireStorageRecommendedItemByIdContext.fields:type_name -> productv1.RequireStorageRecommendedItemByIdFields - 333, // 288: productv1.RequireStorageRecommendedItemByIdResponse.result:type_name -> productv1.RequireStorageRecommendedItemByIdResult - 425, // 289: productv1.RequireStorageRecommendedItemByIdResult.recommended_item:type_name -> productv1.StorageItem - 501, // 290: productv1.RequireStorageRecommendedItemByIdFields.metadata:type_name -> productv1.RequireStorageRecommendedItemByIdFields.StorageMetadata - 336, // 291: productv1.RequireStorageRecommendedItemsByIdRequest.context:type_name -> productv1.RequireStorageRecommendedItemsByIdContext - 27, // 292: productv1.RequireStorageRecommendedItemsByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey - 339, // 293: productv1.RequireStorageRecommendedItemsByIdContext.fields:type_name -> productv1.RequireStorageRecommendedItemsByIdFields - 338, // 294: productv1.RequireStorageRecommendedItemsByIdResponse.result:type_name -> productv1.RequireStorageRecommendedItemsByIdResult - 425, // 295: productv1.RequireStorageRecommendedItemsByIdResult.recommended_items:type_name -> productv1.StorageItem - 341, // 296: productv1.RequireStorageLatestOperationByIdRequest.context:type_name -> productv1.RequireStorageLatestOperationByIdContext - 27, // 297: productv1.RequireStorageLatestOperationByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey - 344, // 298: productv1.RequireStorageLatestOperationByIdContext.fields:type_name -> productv1.RequireStorageLatestOperationByIdFields - 343, // 299: productv1.RequireStorageLatestOperationByIdResponse.result:type_name -> productv1.RequireStorageLatestOperationByIdResult - 432, // 300: productv1.RequireStorageLatestOperationByIdResult.latest_operation:type_name -> productv1.StorageOperationResult - 0, // 301: productv1.RequireStorageLatestOperationByIdFields.storage_kind:type_name -> productv1.CategoryKind - 346, // 302: productv1.RequireStorageOptionalLatestOperationByIdRequest.context:type_name -> productv1.RequireStorageOptionalLatestOperationByIdContext - 27, // 303: productv1.RequireStorageOptionalLatestOperationByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey - 349, // 304: productv1.RequireStorageOptionalLatestOperationByIdContext.fields:type_name -> productv1.RequireStorageOptionalLatestOperationByIdFields - 348, // 305: productv1.RequireStorageOptionalLatestOperationByIdResponse.result:type_name -> productv1.RequireStorageOptionalLatestOperationByIdResult - 432, // 306: productv1.RequireStorageOptionalLatestOperationByIdResult.optional_latest_operation:type_name -> productv1.StorageOperationResult - 20, // 307: productv1.RequireStorageOptionalLatestOperationByIdFields.optional_tags:type_name -> productv1.ListOfString - 351, // 308: productv1.RequireStorageFilteredTagSummaryByIdRequest.context:type_name -> productv1.RequireStorageFilteredTagSummaryByIdContext - 352, // 309: productv1.RequireStorageFilteredTagSummaryByIdRequest.field_args:type_name -> productv1.RequireStorageFilteredTagSummaryByIdArgs - 27, // 310: productv1.RequireStorageFilteredTagSummaryByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey - 355, // 311: productv1.RequireStorageFilteredTagSummaryByIdContext.fields:type_name -> productv1.RequireStorageFilteredTagSummaryByIdFields - 354, // 312: productv1.RequireStorageFilteredTagSummaryByIdResponse.result:type_name -> productv1.RequireStorageFilteredTagSummaryByIdResult - 505, // 313: productv1.RequireStorageFilteredTagSummaryByIdResult.filtered_tag_summary:type_name -> google.protobuf.StringValue - 357, // 314: productv1.RequireStorageMultiFilteredTagSummaryByIdRequest.context:type_name -> productv1.RequireStorageMultiFilteredTagSummaryByIdContext - 358, // 315: productv1.RequireStorageMultiFilteredTagSummaryByIdRequest.field_args:type_name -> productv1.RequireStorageMultiFilteredTagSummaryByIdArgs - 27, // 316: productv1.RequireStorageMultiFilteredTagSummaryByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey - 361, // 317: productv1.RequireStorageMultiFilteredTagSummaryByIdContext.fields:type_name -> productv1.RequireStorageMultiFilteredTagSummaryByIdFields - 360, // 318: productv1.RequireStorageMultiFilteredTagSummaryByIdResponse.result:type_name -> productv1.RequireStorageMultiFilteredTagSummaryByIdResult - 505, // 319: productv1.RequireStorageMultiFilteredTagSummaryByIdResult.multi_filtered_tag_summary:type_name -> google.protobuf.StringValue - 363, // 320: productv1.RequireStorageNullableFilteredTagSummaryByIdRequest.context:type_name -> productv1.RequireStorageNullableFilteredTagSummaryByIdContext - 364, // 321: productv1.RequireStorageNullableFilteredTagSummaryByIdRequest.field_args:type_name -> productv1.RequireStorageNullableFilteredTagSummaryByIdArgs - 27, // 322: productv1.RequireStorageNullableFilteredTagSummaryByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey - 367, // 323: productv1.RequireStorageNullableFilteredTagSummaryByIdContext.fields:type_name -> productv1.RequireStorageNullableFilteredTagSummaryByIdFields - 505, // 324: productv1.RequireStorageNullableFilteredTagSummaryByIdArgs.prefix:type_name -> google.protobuf.StringValue - 366, // 325: productv1.RequireStorageNullableFilteredTagSummaryByIdResponse.result:type_name -> productv1.RequireStorageNullableFilteredTagSummaryByIdResult - 505, // 326: productv1.RequireStorageNullableFilteredTagSummaryByIdResult.nullable_filtered_tag_summary:type_name -> google.protobuf.StringValue - 369, // 327: productv1.RequireWarehouseStockHealthScoreByIdRequest.context:type_name -> productv1.RequireWarehouseStockHealthScoreByIdContext - 30, // 328: productv1.RequireWarehouseStockHealthScoreByIdContext.key:type_name -> productv1.LookupWarehouseByIdRequestKey - 372, // 329: productv1.RequireWarehouseStockHealthScoreByIdContext.fields:type_name -> productv1.RequireWarehouseStockHealthScoreByIdFields - 371, // 330: productv1.RequireWarehouseStockHealthScoreByIdResponse.result:type_name -> productv1.RequireWarehouseStockHealthScoreByIdResult - 502, // 331: productv1.RequireWarehouseStockHealthScoreByIdFields.restock_data:type_name -> productv1.RequireWarehouseStockHealthScoreByIdFields.RestockData - 409, // 332: productv1.NestedTypeA.b:type_name -> productv1.NestedTypeB - 378, // 333: productv1.RecursiveType.recursive_type:type_name -> productv1.RecursiveType - 411, // 334: productv1.ComplexFilterTypeInput.filter:type_name -> productv1.FilterType - 413, // 335: productv1.OrderInput.lines:type_name -> productv1.OrderLineInput - 17, // 336: productv1.Order.order_lines:type_name -> productv1.ListOfOrderLine - 0, // 337: productv1.Category.kind:type_name -> productv1.CategoryKind - 21, // 338: productv1.Category.subcategories:type_name -> productv1.ListOfSubcategory - 416, // 339: productv1.Category.null_metrics:type_name -> productv1.CategoryMetrics - 0, // 340: productv1.CategoryFilter.category:type_name -> productv1.CategoryKind - 412, // 341: productv1.CategoryFilter.pagination:type_name -> productv1.Pagination - 417, // 342: productv1.Animal.cat:type_name -> productv1.Cat - 418, // 343: productv1.Animal.dog:type_name -> productv1.Dog - 503, // 344: productv1.SearchInput.limit:type_name -> google.protobuf.Int32Value - 373, // 345: productv1.SearchResult.product:type_name -> productv1.Product - 376, // 346: productv1.SearchResult.user:type_name -> productv1.User - 385, // 347: productv1.SearchResult.category:type_name -> productv1.Category - 505, // 348: productv1.NullableFieldsType.optional_string:type_name -> google.protobuf.StringValue - 503, // 349: productv1.NullableFieldsType.optional_int:type_name -> google.protobuf.Int32Value - 506, // 350: productv1.NullableFieldsType.optional_float:type_name -> google.protobuf.DoubleValue - 504, // 351: productv1.NullableFieldsType.optional_boolean:type_name -> google.protobuf.BoolValue - 505, // 352: productv1.NullableFieldsFilter.name:type_name -> google.protobuf.StringValue - 505, // 353: productv1.NullableFieldsFilter.optional_string:type_name -> google.protobuf.StringValue - 504, // 354: productv1.NullableFieldsFilter.include_nulls:type_name -> google.protobuf.BoolValue - 20, // 355: productv1.BlogPost.optional_tags:type_name -> productv1.ListOfString - 20, // 356: productv1.BlogPost.keywords:type_name -> productv1.ListOfString - 11, // 357: productv1.BlogPost.ratings:type_name -> productv1.ListOfFloat - 7, // 358: productv1.BlogPost.is_published:type_name -> productv1.ListOfBoolean - 14, // 359: productv1.BlogPost.tag_groups:type_name -> productv1.ListOfListOfString - 14, // 360: productv1.BlogPost.related_topics:type_name -> productv1.ListOfListOfString - 14, // 361: productv1.BlogPost.comment_threads:type_name -> productv1.ListOfListOfString - 14, // 362: productv1.BlogPost.suggestions:type_name -> productv1.ListOfListOfString - 385, // 363: productv1.BlogPost.related_categories:type_name -> productv1.Category - 376, // 364: productv1.BlogPost.contributors:type_name -> productv1.User - 18, // 365: productv1.BlogPost.mentioned_products:type_name -> productv1.ListOfProduct - 22, // 366: productv1.BlogPost.mentioned_users:type_name -> productv1.ListOfUser - 12, // 367: productv1.BlogPost.category_groups:type_name -> productv1.ListOfListOfCategory - 15, // 368: productv1.BlogPost.contributor_teams:type_name -> productv1.ListOfListOfUser - 505, // 369: productv1.BlogPostFilter.title:type_name -> google.protobuf.StringValue - 504, // 370: productv1.BlogPostFilter.has_categories:type_name -> google.protobuf.BoolValue - 503, // 371: productv1.BlogPostFilter.min_tags:type_name -> google.protobuf.Int32Value - 505, // 372: productv1.Author.email:type_name -> google.protobuf.StringValue - 20, // 373: productv1.Author.social_links:type_name -> productv1.ListOfString - 14, // 374: productv1.Author.teams_by_project:type_name -> productv1.ListOfListOfString - 14, // 375: productv1.Author.collaborations:type_name -> productv1.ListOfListOfString - 4, // 376: productv1.Author.written_posts:type_name -> productv1.ListOfBlogPost - 385, // 377: productv1.Author.favorite_categories:type_name -> productv1.Category - 22, // 378: productv1.Author.related_authors:type_name -> productv1.ListOfUser - 18, // 379: productv1.Author.product_reviews:type_name -> productv1.ListOfProduct - 15, // 380: productv1.Author.author_groups:type_name -> productv1.ListOfListOfUser - 12, // 381: productv1.Author.category_preferences:type_name -> productv1.ListOfListOfCategory - 15, // 382: productv1.Author.project_teams:type_name -> productv1.ListOfListOfUser - 505, // 383: productv1.AuthorFilter.name:type_name -> google.protobuf.StringValue - 504, // 384: productv1.AuthorFilter.has_teams:type_name -> google.protobuf.BoolValue - 503, // 385: productv1.AuthorFilter.skill_count:type_name -> google.protobuf.Int32Value - 505, // 386: productv1.TestContainer.description:type_name -> google.protobuf.StringValue - 10, // 387: productv1.ConditionsInput.and:type_name -> productv1.ListOfConditionsInput - 10, // 388: productv1.ConditionsInput.or:type_name -> productv1.ListOfConditionsInput - 505, // 389: productv1.ConditionsInput.key:type_name -> google.protobuf.StringValue - 505, // 390: productv1.ConditionsInput.value:type_name -> google.protobuf.StringValue - 436, // 391: productv1.ActionResult.action_success:type_name -> productv1.ActionSuccess - 437, // 392: productv1.ActionResult.action_error:type_name -> productv1.ActionError - 505, // 393: productv1.NullableFieldsInput.optional_string:type_name -> google.protobuf.StringValue - 503, // 394: productv1.NullableFieldsInput.optional_int:type_name -> google.protobuf.Int32Value - 506, // 395: productv1.NullableFieldsInput.optional_float:type_name -> google.protobuf.DoubleValue - 504, // 396: productv1.NullableFieldsInput.optional_boolean:type_name -> google.protobuf.BoolValue - 20, // 397: productv1.BlogPostInput.optional_tags:type_name -> productv1.ListOfString - 20, // 398: productv1.BlogPostInput.keywords:type_name -> productv1.ListOfString - 11, // 399: productv1.BlogPostInput.ratings:type_name -> productv1.ListOfFloat - 7, // 400: productv1.BlogPostInput.is_published:type_name -> productv1.ListOfBoolean - 14, // 401: productv1.BlogPostInput.tag_groups:type_name -> productv1.ListOfListOfString - 14, // 402: productv1.BlogPostInput.related_topics:type_name -> productv1.ListOfListOfString - 14, // 403: productv1.BlogPostInput.comment_threads:type_name -> productv1.ListOfListOfString - 14, // 404: productv1.BlogPostInput.suggestions:type_name -> productv1.ListOfListOfString - 9, // 405: productv1.BlogPostInput.related_categories:type_name -> productv1.ListOfCategoryInput - 23, // 406: productv1.BlogPostInput.contributors:type_name -> productv1.ListOfUserInput - 13, // 407: productv1.BlogPostInput.category_groups:type_name -> productv1.ListOfListOfCategoryInput - 505, // 408: productv1.AuthorInput.email:type_name -> google.protobuf.StringValue - 20, // 409: productv1.AuthorInput.social_links:type_name -> productv1.ListOfString - 14, // 410: productv1.AuthorInput.teams_by_project:type_name -> productv1.ListOfListOfString - 14, // 411: productv1.AuthorInput.collaborations:type_name -> productv1.ListOfListOfString - 439, // 412: productv1.AuthorInput.favorite_categories:type_name -> productv1.CategoryInput - 16, // 413: productv1.AuthorInput.author_groups:type_name -> productv1.ListOfListOfUserInput - 16, // 414: productv1.AuthorInput.project_teams:type_name -> productv1.ListOfListOfUserInput - 401, // 415: productv1.ProductDetails.review_summary:type_name -> productv1.ActionResult - 387, // 416: productv1.ProductDetails.recommended_pet:type_name -> productv1.Animal - 0, // 417: productv1.StorageCategoryInfo.kind:type_name -> productv1.CategoryKind - 410, // 418: productv1.NestedTypeB.c:type_name -> productv1.NestedTypeC - 412, // 419: productv1.FilterType.pagination:type_name -> productv1.Pagination - 20, // 420: productv1.OrderLineInput.modifiers:type_name -> productv1.ListOfString - 20, // 421: productv1.OrderLine.modifiers:type_name -> productv1.ListOfString - 505, // 422: productv1.Subcategory.description:type_name -> google.protobuf.StringValue - 419, // 423: productv1.Cat.owner:type_name -> productv1.Owner - 422, // 424: productv1.Cat.breed:type_name -> productv1.CatBreed - 419, // 425: productv1.Dog.owner:type_name -> productv1.Owner - 423, // 426: productv1.Dog.breed:type_name -> productv1.DogBreed - 420, // 427: productv1.Owner.contact:type_name -> productv1.ContactInfo - 387, // 428: productv1.Owner.pet:type_name -> productv1.Animal - 421, // 429: productv1.ContactInfo.address:type_name -> productv1.Address - 424, // 430: productv1.CatBreed.characteristics:type_name -> productv1.BreedCharacteristics - 424, // 431: productv1.DogBreed.characteristics:type_name -> productv1.BreedCharacteristics - 426, // 432: productv1.StorageItem.pallet_item:type_name -> productv1.PalletItem - 427, // 433: productv1.StorageItem.container_item:type_name -> productv1.ContainerItem - 428, // 434: productv1.PalletItem.handler:type_name -> productv1.ItemHandler - 429, // 435: productv1.PalletItem.specs:type_name -> productv1.PalletSpecs - 428, // 436: productv1.ContainerItem.handler:type_name -> productv1.ItemHandler - 430, // 437: productv1.ContainerItem.specs:type_name -> productv1.ContainerSpecs - 425, // 438: productv1.ItemHandler.assigned_item:type_name -> productv1.StorageItem - 431, // 439: productv1.PalletSpecs.dimensions:type_name -> productv1.Dimensions - 431, // 440: productv1.ContainerSpecs.dimensions:type_name -> productv1.Dimensions - 433, // 441: productv1.StorageOperationResult.storage_success:type_name -> productv1.StorageSuccess - 434, // 442: productv1.StorageOperationResult.storage_failure:type_name -> productv1.StorageFailure - 425, // 443: productv1.SecuritySetup.primary_item:type_name -> productv1.StorageItem - 387, // 444: productv1.TestDetails.pet:type_name -> productv1.Animal - 401, // 445: productv1.TestDetails.status:type_name -> productv1.ActionResult - 0, // 446: productv1.CategoryInput.kind:type_name -> productv1.CategoryKind - 506, // 447: productv1.ProductCountFilter.min_price:type_name -> google.protobuf.DoubleValue - 506, // 448: productv1.ProductCountFilter.max_price:type_name -> google.protobuf.DoubleValue - 504, // 449: productv1.ProductCountFilter.in_stock:type_name -> google.protobuf.BoolValue - 505, // 450: productv1.ProductCountFilter.search_term:type_name -> google.protobuf.StringValue - 506, // 451: productv1.SubcategoryItemFilter.min_price:type_name -> google.protobuf.DoubleValue - 506, // 452: productv1.SubcategoryItemFilter.max_price:type_name -> google.protobuf.DoubleValue - 504, // 453: productv1.SubcategoryItemFilter.in_stock:type_name -> google.protobuf.BoolValue - 504, // 454: productv1.SubcategoryItemFilter.is_active:type_name -> google.protobuf.BoolValue - 505, // 455: productv1.SubcategoryItemFilter.search_term:type_name -> google.protobuf.StringValue - 1, // 456: productv1.ShippingEstimateInput.destination:type_name -> productv1.ShippingDestination - 504, // 457: productv1.ShippingEstimateInput.expedited:type_name -> google.protobuf.BoolValue - 395, // 458: productv1.ListOfAuthorFilter.List.items:type_name -> productv1.AuthorFilter - 404, // 459: productv1.ListOfAuthorInput.List.items:type_name -> productv1.AuthorInput - 392, // 460: productv1.ListOfBlogPost.List.items:type_name -> productv1.BlogPost - 393, // 461: productv1.ListOfBlogPostFilter.List.items:type_name -> productv1.BlogPostFilter - 403, // 462: productv1.ListOfBlogPostInput.List.items:type_name -> productv1.BlogPostInput - 385, // 463: productv1.ListOfCategory.List.items:type_name -> productv1.Category - 439, // 464: productv1.ListOfCategoryInput.List.items:type_name -> productv1.CategoryInput - 397, // 465: productv1.ListOfConditionsInput.List.items:type_name -> productv1.ConditionsInput - 8, // 466: productv1.ListOfListOfCategory.List.items:type_name -> productv1.ListOfCategory - 9, // 467: productv1.ListOfListOfCategoryInput.List.items:type_name -> productv1.ListOfCategoryInput - 20, // 468: productv1.ListOfListOfString.List.items:type_name -> productv1.ListOfString - 22, // 469: productv1.ListOfListOfUser.List.items:type_name -> productv1.ListOfUser - 23, // 470: productv1.ListOfListOfUserInput.List.items:type_name -> productv1.ListOfUserInput - 414, // 471: productv1.ListOfOrderLine.List.items:type_name -> productv1.OrderLine - 373, // 472: productv1.ListOfProduct.List.items:type_name -> productv1.Product - 374, // 473: productv1.ListOfStorage.List.items:type_name -> productv1.Storage - 415, // 474: productv1.ListOfSubcategory.List.items:type_name -> productv1.Subcategory - 376, // 475: productv1.ListOfUser.List.items:type_name -> productv1.User - 399, // 476: productv1.ListOfUserInput.List.items:type_name -> productv1.UserInput - 0, // 477: productv1.RequireStorageCategoryInfoSummaryByIdFields.StorageCategoryInfo.kind:type_name -> productv1.CategoryKind - 472, // 478: productv1.RequireStorageItemInfoByIdFields.StorageItem.container_item:type_name -> productv1.RequireStorageItemInfoByIdFields.ContainerItem - 471, // 479: productv1.RequireStorageItemInfoByIdFields.StorageItem.pallet_item:type_name -> productv1.RequireStorageItemInfoByIdFields.PalletItem - 475, // 480: productv1.RequireStorageOperationReportByIdFields.StorageOperationResult.storage_failure:type_name -> productv1.RequireStorageOperationReportByIdFields.StorageFailure - 474, // 481: productv1.RequireStorageOperationReportByIdFields.StorageOperationResult.storage_success:type_name -> productv1.RequireStorageOperationReportByIdFields.StorageSuccess - 480, // 482: productv1.RequireStorageSecuritySummaryByIdFields.SecuritySetup.primary_item:type_name -> productv1.RequireStorageSecuritySummaryByIdFields.SecuritySetup.StorageItem - 479, // 483: productv1.RequireStorageSecuritySummaryByIdFields.SecuritySetup.StorageItem.container_item:type_name -> productv1.RequireStorageSecuritySummaryByIdFields.SecuritySetup.ContainerItem - 478, // 484: productv1.RequireStorageSecuritySummaryByIdFields.SecuritySetup.StorageItem.pallet_item:type_name -> productv1.RequireStorageSecuritySummaryByIdFields.SecuritySetup.PalletItem - 484, // 485: productv1.RequireStorageItemHandlerInfoByIdFields.PalletItem.handler:type_name -> productv1.RequireStorageItemHandlerInfoByIdFields.PalletItem.ItemHandler - 485, // 486: productv1.RequireStorageItemHandlerInfoByIdFields.ContainerItem.handler:type_name -> productv1.RequireStorageItemHandlerInfoByIdFields.ContainerItem.ItemHandler - 482, // 487: productv1.RequireStorageItemHandlerInfoByIdFields.StorageItem.container_item:type_name -> productv1.RequireStorageItemHandlerInfoByIdFields.ContainerItem - 481, // 488: productv1.RequireStorageItemHandlerInfoByIdFields.StorageItem.pallet_item:type_name -> productv1.RequireStorageItemHandlerInfoByIdFields.PalletItem - 489, // 489: productv1.RequireStorageItemSpecsInfoByIdFields.PalletItem.specs:type_name -> productv1.RequireStorageItemSpecsInfoByIdFields.PalletItem.PalletSpecs - 491, // 490: productv1.RequireStorageItemSpecsInfoByIdFields.ContainerItem.specs:type_name -> productv1.RequireStorageItemSpecsInfoByIdFields.ContainerItem.ContainerSpecs - 487, // 491: productv1.RequireStorageItemSpecsInfoByIdFields.StorageItem.container_item:type_name -> productv1.RequireStorageItemSpecsInfoByIdFields.ContainerItem - 486, // 492: productv1.RequireStorageItemSpecsInfoByIdFields.StorageItem.pallet_item:type_name -> productv1.RequireStorageItemSpecsInfoByIdFields.PalletItem - 490, // 493: productv1.RequireStorageItemSpecsInfoByIdFields.PalletItem.PalletSpecs.dimensions:type_name -> productv1.RequireStorageItemSpecsInfoByIdFields.PalletItem.PalletSpecs.Dimensions - 492, // 494: productv1.RequireStorageItemSpecsInfoByIdFields.ContainerItem.ContainerSpecs.dimensions:type_name -> productv1.RequireStorageItemSpecsInfoByIdFields.ContainerItem.ContainerSpecs.Dimensions - 496, // 495: productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.handler:type_name -> productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.ItemHandler - 500, // 496: productv1.RequireStorageDeepItemInfoByIdFields.ContainerItem.handler:type_name -> productv1.RequireStorageDeepItemInfoByIdFields.ContainerItem.ItemHandler - 494, // 497: productv1.RequireStorageDeepItemInfoByIdFields.StorageItem.container_item:type_name -> productv1.RequireStorageDeepItemInfoByIdFields.ContainerItem - 493, // 498: productv1.RequireStorageDeepItemInfoByIdFields.StorageItem.pallet_item:type_name -> productv1.RequireStorageDeepItemInfoByIdFields.PalletItem - 499, // 499: productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.ItemHandler.assigned_item:type_name -> productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.ItemHandler.StorageItem - 497, // 500: productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.ItemHandler.StorageItem.container_item:type_name -> productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.ItemHandler.ContainerItem - 498, // 501: productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.ItemHandler.StorageItem.pallet_item:type_name -> productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.ItemHandler.PalletItem - 25, // 502: productv1.ProductService.LookupProductById:input_type -> productv1.LookupProductByIdRequest - 28, // 503: productv1.ProductService.LookupStorageById:input_type -> productv1.LookupStorageByIdRequest - 31, // 504: productv1.ProductService.LookupWarehouseById:input_type -> productv1.LookupWarehouseByIdRequest - 117, // 505: productv1.ProductService.MutationBulkCreateAuthors:input_type -> productv1.MutationBulkCreateAuthorsRequest - 121, // 506: productv1.ProductService.MutationBulkCreateBlogPosts:input_type -> productv1.MutationBulkCreateBlogPostsRequest - 119, // 507: productv1.ProductService.MutationBulkUpdateAuthors:input_type -> productv1.MutationBulkUpdateAuthorsRequest - 123, // 508: productv1.ProductService.MutationBulkUpdateBlogPosts:input_type -> productv1.MutationBulkUpdateBlogPostsRequest - 113, // 509: productv1.ProductService.MutationCreateAuthor:input_type -> productv1.MutationCreateAuthorRequest - 109, // 510: productv1.ProductService.MutationCreateBlogPost:input_type -> productv1.MutationCreateBlogPostRequest - 105, // 511: productv1.ProductService.MutationCreateNullableFieldsType:input_type -> productv1.MutationCreateNullableFieldsTypeRequest - 101, // 512: productv1.ProductService.MutationCreateUser:input_type -> productv1.MutationCreateUserRequest - 103, // 513: productv1.ProductService.MutationPerformAction:input_type -> productv1.MutationPerformActionRequest - 115, // 514: productv1.ProductService.MutationUpdateAuthor:input_type -> productv1.MutationUpdateAuthorRequest - 111, // 515: productv1.ProductService.MutationUpdateBlogPost:input_type -> productv1.MutationUpdateBlogPostRequest - 107, // 516: productv1.ProductService.MutationUpdateNullableFieldsType:input_type -> productv1.MutationUpdateNullableFieldsTypeRequest - 89, // 517: productv1.ProductService.QueryAllAuthors:input_type -> productv1.QueryAllAuthorsRequest - 81, // 518: productv1.ProductService.QueryAllBlogPosts:input_type -> productv1.QueryAllBlogPostsRequest - 73, // 519: productv1.ProductService.QueryAllNullableFieldsTypes:input_type -> productv1.QueryAllNullableFieldsTypesRequest - 61, // 520: productv1.ProductService.QueryAllPets:input_type -> productv1.QueryAllPetsRequest - 83, // 521: productv1.ProductService.QueryAuthor:input_type -> productv1.QueryAuthorRequest - 85, // 522: productv1.ProductService.QueryAuthorById:input_type -> productv1.QueryAuthorByIdRequest - 87, // 523: productv1.ProductService.QueryAuthorsWithFilter:input_type -> productv1.QueryAuthorsWithFilterRequest - 75, // 524: productv1.ProductService.QueryBlogPost:input_type -> productv1.QueryBlogPostRequest - 77, // 525: productv1.ProductService.QueryBlogPostById:input_type -> productv1.QueryBlogPostByIdRequest - 79, // 526: productv1.ProductService.QueryBlogPostsWithFilter:input_type -> productv1.QueryBlogPostsWithFilterRequest - 91, // 527: productv1.ProductService.QueryBulkSearchAuthors:input_type -> productv1.QueryBulkSearchAuthorsRequest - 93, // 528: productv1.ProductService.QueryBulkSearchBlogPosts:input_type -> productv1.QueryBulkSearchBlogPostsRequest - 47, // 529: productv1.ProductService.QueryCalculateTotals:input_type -> productv1.QueryCalculateTotalsRequest - 49, // 530: productv1.ProductService.QueryCategories:input_type -> productv1.QueryCategoriesRequest - 53, // 531: productv1.ProductService.QueryCategoriesByKind:input_type -> productv1.QueryCategoriesByKindRequest - 55, // 532: productv1.ProductService.QueryCategoriesByKinds:input_type -> productv1.QueryCategoriesByKindsRequest - 51, // 533: productv1.ProductService.QueryCategory:input_type -> productv1.QueryCategoryRequest - 45, // 534: productv1.ProductService.QueryComplexFilterType:input_type -> productv1.QueryComplexFilterTypeRequest - 99, // 535: productv1.ProductService.QueryConditionalSearch:input_type -> productv1.QueryConditionalSearchRequest - 57, // 536: productv1.ProductService.QueryFilterCategories:input_type -> productv1.QueryFilterCategoriesRequest - 37, // 537: productv1.ProductService.QueryNestedType:input_type -> productv1.QueryNestedTypeRequest - 67, // 538: productv1.ProductService.QueryNullableFieldsType:input_type -> productv1.QueryNullableFieldsTypeRequest - 69, // 539: productv1.ProductService.QueryNullableFieldsTypeById:input_type -> productv1.QueryNullableFieldsTypeByIdRequest - 71, // 540: productv1.ProductService.QueryNullableFieldsTypeWithFilter:input_type -> productv1.QueryNullableFieldsTypeWithFilterRequest - 59, // 541: productv1.ProductService.QueryRandomPet:input_type -> productv1.QueryRandomPetRequest - 65, // 542: productv1.ProductService.QueryRandomSearchResult:input_type -> productv1.QueryRandomSearchResultRequest - 39, // 543: productv1.ProductService.QueryRecursiveType:input_type -> productv1.QueryRecursiveTypeRequest - 63, // 544: productv1.ProductService.QuerySearch:input_type -> productv1.QuerySearchRequest - 95, // 545: productv1.ProductService.QueryTestContainer:input_type -> productv1.QueryTestContainerRequest - 97, // 546: productv1.ProductService.QueryTestContainers:input_type -> productv1.QueryTestContainersRequest - 41, // 547: productv1.ProductService.QueryTypeFilterWithArguments:input_type -> productv1.QueryTypeFilterWithArgumentsRequest - 43, // 548: productv1.ProductService.QueryTypeWithMultipleFilterFields:input_type -> productv1.QueryTypeWithMultipleFilterFieldsRequest - 35, // 549: productv1.ProductService.QueryUser:input_type -> productv1.QueryUserRequest - 33, // 550: productv1.ProductService.QueryUsers:input_type -> productv1.QueryUsersRequest - 295, // 551: productv1.ProductService.RequireStorageCategoryInfoSummaryById:input_type -> productv1.RequireStorageCategoryInfoSummaryByIdRequest - 325, // 552: productv1.ProductService.RequireStorageDeepItemInfoById:input_type -> productv1.RequireStorageDeepItemInfoByIdRequest - 350, // 553: productv1.ProductService.RequireStorageFilteredTagSummaryById:input_type -> productv1.RequireStorageFilteredTagSummaryByIdRequest - 315, // 554: productv1.ProductService.RequireStorageItemHandlerInfoById:input_type -> productv1.RequireStorageItemHandlerInfoByIdRequest - 300, // 555: productv1.ProductService.RequireStorageItemInfoById:input_type -> productv1.RequireStorageItemInfoByIdRequest - 320, // 556: productv1.ProductService.RequireStorageItemSpecsInfoById:input_type -> productv1.RequireStorageItemSpecsInfoByIdRequest - 290, // 557: productv1.ProductService.RequireStorageKindSummaryById:input_type -> productv1.RequireStorageKindSummaryByIdRequest - 340, // 558: productv1.ProductService.RequireStorageLatestOperationById:input_type -> productv1.RequireStorageLatestOperationByIdRequest - 260, // 559: productv1.ProductService.RequireStorageMetadataScoreById:input_type -> productv1.RequireStorageMetadataScoreByIdRequest - 356, // 560: productv1.ProductService.RequireStorageMultiFilteredTagSummaryById:input_type -> productv1.RequireStorageMultiFilteredTagSummaryByIdRequest - 362, // 561: productv1.ProductService.RequireStorageNullableFilteredTagSummaryById:input_type -> productv1.RequireStorageNullableFilteredTagSummaryByIdRequest - 305, // 562: productv1.ProductService.RequireStorageOperationReportById:input_type -> productv1.RequireStorageOperationReportByIdRequest - 345, // 563: productv1.ProductService.RequireStorageOptionalLatestOperationById:input_type -> productv1.RequireStorageOptionalLatestOperationByIdRequest - 270, // 564: productv1.ProductService.RequireStorageOptionalProcessedMetadataById:input_type -> productv1.RequireStorageOptionalProcessedMetadataByIdRequest - 280, // 565: productv1.ProductService.RequireStorageOptionalProcessedTagsById:input_type -> productv1.RequireStorageOptionalProcessedTagsByIdRequest - 255, // 566: productv1.ProductService.RequireStorageOptionalTagSummaryById:input_type -> productv1.RequireStorageOptionalTagSummaryByIdRequest - 265, // 567: productv1.ProductService.RequireStorageProcessedMetadataById:input_type -> productv1.RequireStorageProcessedMetadataByIdRequest - 285, // 568: productv1.ProductService.RequireStorageProcessedMetadataHistoryById:input_type -> productv1.RequireStorageProcessedMetadataHistoryByIdRequest - 275, // 569: productv1.ProductService.RequireStorageProcessedTagsById:input_type -> productv1.RequireStorageProcessedTagsByIdRequest - 330, // 570: productv1.ProductService.RequireStorageRecommendedItemById:input_type -> productv1.RequireStorageRecommendedItemByIdRequest - 335, // 571: productv1.ProductService.RequireStorageRecommendedItemsById:input_type -> productv1.RequireStorageRecommendedItemsByIdRequest - 310, // 572: productv1.ProductService.RequireStorageSecuritySummaryById:input_type -> productv1.RequireStorageSecuritySummaryByIdRequest - 245, // 573: productv1.ProductService.RequireStorageStockHealthScoreById:input_type -> productv1.RequireStorageStockHealthScoreByIdRequest - 250, // 574: productv1.ProductService.RequireStorageTagSummaryById:input_type -> productv1.RequireStorageTagSummaryByIdRequest - 368, // 575: productv1.ProductService.RequireWarehouseStockHealthScoreById:input_type -> productv1.RequireWarehouseStockHealthScoreByIdRequest - 209, // 576: productv1.ProductService.ResolveCategoryActiveSubcategories:input_type -> productv1.ResolveCategoryActiveSubcategoriesRequest - 177, // 577: productv1.ProductService.ResolveCategoryCategoryMetrics:input_type -> productv1.ResolveCategoryCategoryMetricsRequest - 187, // 578: productv1.ProductService.ResolveCategoryCategoryStatus:input_type -> productv1.ResolveCategoryCategoryStatusRequest - 192, // 579: productv1.ProductService.ResolveCategoryChildCategories:input_type -> productv1.ResolveCategoryChildCategoriesRequest - 182, // 580: productv1.ProductService.ResolveCategoryMascot:input_type -> productv1.ResolveCategoryMascotRequest - 237, // 581: productv1.ProductService.ResolveCategoryMetricsAverageScore:input_type -> productv1.ResolveCategoryMetricsAverageScoreRequest - 228, // 582: productv1.ProductService.ResolveCategoryMetricsNormalizedScore:input_type -> productv1.ResolveCategoryMetricsNormalizedScoreRequest - 233, // 583: productv1.ProductService.ResolveCategoryMetricsRelatedCategory:input_type -> productv1.ResolveCategoryMetricsRelatedCategoryRequest - 197, // 584: productv1.ProductService.ResolveCategoryOptionalCategories:input_type -> productv1.ResolveCategoryOptionalCategoriesRequest - 172, // 585: productv1.ProductService.ResolveCategoryPopularityScore:input_type -> productv1.ResolveCategoryPopularityScoreRequest - 167, // 586: productv1.ProductService.ResolveCategoryProductCount:input_type -> productv1.ResolveCategoryProductCountRequest - 205, // 587: productv1.ProductService.ResolveCategoryTopSubcategory:input_type -> productv1.ResolveCategoryTopSubcategoryRequest - 201, // 588: productv1.ProductService.ResolveCategoryTotalProducts:input_type -> productv1.ResolveCategoryTotalProductsRequest - 137, // 589: productv1.ProductService.ResolveProductMascotRecommendation:input_type -> productv1.ResolveProductMascotRecommendationRequest - 147, // 590: productv1.ProductService.ResolveProductProductDetails:input_type -> productv1.ResolveProductProductDetailsRequest - 132, // 591: productv1.ProductService.ResolveProductRecommendedCategory:input_type -> productv1.ResolveProductRecommendedCategoryRequest - 127, // 592: productv1.ProductService.ResolveProductShippingEstimate:input_type -> productv1.ResolveProductShippingEstimateRequest - 142, // 593: productv1.ProductService.ResolveProductStockStatus:input_type -> productv1.ResolveProductStockStatusRequest - 157, // 594: productv1.ProductService.ResolveStorageLinkedStorages:input_type -> productv1.ResolveStorageLinkedStoragesRequest - 162, // 595: productv1.ProductService.ResolveStorageNearbyStorages:input_type -> productv1.ResolveStorageNearbyStoragesRequest - 152, // 596: productv1.ProductService.ResolveStorageStorageStatus:input_type -> productv1.ResolveStorageStorageStatusRequest - 219, // 597: productv1.ProductService.ResolveSubcategoryFeaturedCategory:input_type -> productv1.ResolveSubcategoryFeaturedCategoryRequest - 214, // 598: productv1.ProductService.ResolveSubcategoryItemCount:input_type -> productv1.ResolveSubcategoryItemCountRequest - 223, // 599: productv1.ProductService.ResolveSubcategoryParentCategory:input_type -> productv1.ResolveSubcategoryParentCategoryRequest - 242, // 600: productv1.ProductService.ResolveTestContainerDetails:input_type -> productv1.ResolveTestContainerDetailsRequest - 26, // 601: productv1.ProductService.LookupProductById:output_type -> productv1.LookupProductByIdResponse - 29, // 602: productv1.ProductService.LookupStorageById:output_type -> productv1.LookupStorageByIdResponse - 32, // 603: productv1.ProductService.LookupWarehouseById:output_type -> productv1.LookupWarehouseByIdResponse - 118, // 604: productv1.ProductService.MutationBulkCreateAuthors:output_type -> productv1.MutationBulkCreateAuthorsResponse - 122, // 605: productv1.ProductService.MutationBulkCreateBlogPosts:output_type -> productv1.MutationBulkCreateBlogPostsResponse - 120, // 606: productv1.ProductService.MutationBulkUpdateAuthors:output_type -> productv1.MutationBulkUpdateAuthorsResponse - 124, // 607: productv1.ProductService.MutationBulkUpdateBlogPosts:output_type -> productv1.MutationBulkUpdateBlogPostsResponse - 114, // 608: productv1.ProductService.MutationCreateAuthor:output_type -> productv1.MutationCreateAuthorResponse - 110, // 609: productv1.ProductService.MutationCreateBlogPost:output_type -> productv1.MutationCreateBlogPostResponse - 106, // 610: productv1.ProductService.MutationCreateNullableFieldsType:output_type -> productv1.MutationCreateNullableFieldsTypeResponse - 102, // 611: productv1.ProductService.MutationCreateUser:output_type -> productv1.MutationCreateUserResponse - 104, // 612: productv1.ProductService.MutationPerformAction:output_type -> productv1.MutationPerformActionResponse - 116, // 613: productv1.ProductService.MutationUpdateAuthor:output_type -> productv1.MutationUpdateAuthorResponse - 112, // 614: productv1.ProductService.MutationUpdateBlogPost:output_type -> productv1.MutationUpdateBlogPostResponse - 108, // 615: productv1.ProductService.MutationUpdateNullableFieldsType:output_type -> productv1.MutationUpdateNullableFieldsTypeResponse - 90, // 616: productv1.ProductService.QueryAllAuthors:output_type -> productv1.QueryAllAuthorsResponse - 82, // 617: productv1.ProductService.QueryAllBlogPosts:output_type -> productv1.QueryAllBlogPostsResponse - 74, // 618: productv1.ProductService.QueryAllNullableFieldsTypes:output_type -> productv1.QueryAllNullableFieldsTypesResponse - 62, // 619: productv1.ProductService.QueryAllPets:output_type -> productv1.QueryAllPetsResponse - 84, // 620: productv1.ProductService.QueryAuthor:output_type -> productv1.QueryAuthorResponse - 86, // 621: productv1.ProductService.QueryAuthorById:output_type -> productv1.QueryAuthorByIdResponse - 88, // 622: productv1.ProductService.QueryAuthorsWithFilter:output_type -> productv1.QueryAuthorsWithFilterResponse - 76, // 623: productv1.ProductService.QueryBlogPost:output_type -> productv1.QueryBlogPostResponse - 78, // 624: productv1.ProductService.QueryBlogPostById:output_type -> productv1.QueryBlogPostByIdResponse - 80, // 625: productv1.ProductService.QueryBlogPostsWithFilter:output_type -> productv1.QueryBlogPostsWithFilterResponse - 92, // 626: productv1.ProductService.QueryBulkSearchAuthors:output_type -> productv1.QueryBulkSearchAuthorsResponse - 94, // 627: productv1.ProductService.QueryBulkSearchBlogPosts:output_type -> productv1.QueryBulkSearchBlogPostsResponse - 48, // 628: productv1.ProductService.QueryCalculateTotals:output_type -> productv1.QueryCalculateTotalsResponse - 50, // 629: productv1.ProductService.QueryCategories:output_type -> productv1.QueryCategoriesResponse - 54, // 630: productv1.ProductService.QueryCategoriesByKind:output_type -> productv1.QueryCategoriesByKindResponse - 56, // 631: productv1.ProductService.QueryCategoriesByKinds:output_type -> productv1.QueryCategoriesByKindsResponse - 52, // 632: productv1.ProductService.QueryCategory:output_type -> productv1.QueryCategoryResponse - 46, // 633: productv1.ProductService.QueryComplexFilterType:output_type -> productv1.QueryComplexFilterTypeResponse - 100, // 634: productv1.ProductService.QueryConditionalSearch:output_type -> productv1.QueryConditionalSearchResponse - 58, // 635: productv1.ProductService.QueryFilterCategories:output_type -> productv1.QueryFilterCategoriesResponse - 38, // 636: productv1.ProductService.QueryNestedType:output_type -> productv1.QueryNestedTypeResponse - 68, // 637: productv1.ProductService.QueryNullableFieldsType:output_type -> productv1.QueryNullableFieldsTypeResponse - 70, // 638: productv1.ProductService.QueryNullableFieldsTypeById:output_type -> productv1.QueryNullableFieldsTypeByIdResponse - 72, // 639: productv1.ProductService.QueryNullableFieldsTypeWithFilter:output_type -> productv1.QueryNullableFieldsTypeWithFilterResponse - 60, // 640: productv1.ProductService.QueryRandomPet:output_type -> productv1.QueryRandomPetResponse - 66, // 641: productv1.ProductService.QueryRandomSearchResult:output_type -> productv1.QueryRandomSearchResultResponse - 40, // 642: productv1.ProductService.QueryRecursiveType:output_type -> productv1.QueryRecursiveTypeResponse - 64, // 643: productv1.ProductService.QuerySearch:output_type -> productv1.QuerySearchResponse - 96, // 644: productv1.ProductService.QueryTestContainer:output_type -> productv1.QueryTestContainerResponse - 98, // 645: productv1.ProductService.QueryTestContainers:output_type -> productv1.QueryTestContainersResponse - 42, // 646: productv1.ProductService.QueryTypeFilterWithArguments:output_type -> productv1.QueryTypeFilterWithArgumentsResponse - 44, // 647: productv1.ProductService.QueryTypeWithMultipleFilterFields:output_type -> productv1.QueryTypeWithMultipleFilterFieldsResponse - 36, // 648: productv1.ProductService.QueryUser:output_type -> productv1.QueryUserResponse - 34, // 649: productv1.ProductService.QueryUsers:output_type -> productv1.QueryUsersResponse - 297, // 650: productv1.ProductService.RequireStorageCategoryInfoSummaryById:output_type -> productv1.RequireStorageCategoryInfoSummaryByIdResponse - 327, // 651: productv1.ProductService.RequireStorageDeepItemInfoById:output_type -> productv1.RequireStorageDeepItemInfoByIdResponse - 353, // 652: productv1.ProductService.RequireStorageFilteredTagSummaryById:output_type -> productv1.RequireStorageFilteredTagSummaryByIdResponse - 317, // 653: productv1.ProductService.RequireStorageItemHandlerInfoById:output_type -> productv1.RequireStorageItemHandlerInfoByIdResponse - 302, // 654: productv1.ProductService.RequireStorageItemInfoById:output_type -> productv1.RequireStorageItemInfoByIdResponse - 322, // 655: productv1.ProductService.RequireStorageItemSpecsInfoById:output_type -> productv1.RequireStorageItemSpecsInfoByIdResponse - 292, // 656: productv1.ProductService.RequireStorageKindSummaryById:output_type -> productv1.RequireStorageKindSummaryByIdResponse - 342, // 657: productv1.ProductService.RequireStorageLatestOperationById:output_type -> productv1.RequireStorageLatestOperationByIdResponse - 262, // 658: productv1.ProductService.RequireStorageMetadataScoreById:output_type -> productv1.RequireStorageMetadataScoreByIdResponse - 359, // 659: productv1.ProductService.RequireStorageMultiFilteredTagSummaryById:output_type -> productv1.RequireStorageMultiFilteredTagSummaryByIdResponse - 365, // 660: productv1.ProductService.RequireStorageNullableFilteredTagSummaryById:output_type -> productv1.RequireStorageNullableFilteredTagSummaryByIdResponse - 307, // 661: productv1.ProductService.RequireStorageOperationReportById:output_type -> productv1.RequireStorageOperationReportByIdResponse - 347, // 662: productv1.ProductService.RequireStorageOptionalLatestOperationById:output_type -> productv1.RequireStorageOptionalLatestOperationByIdResponse - 272, // 663: productv1.ProductService.RequireStorageOptionalProcessedMetadataById:output_type -> productv1.RequireStorageOptionalProcessedMetadataByIdResponse - 282, // 664: productv1.ProductService.RequireStorageOptionalProcessedTagsById:output_type -> productv1.RequireStorageOptionalProcessedTagsByIdResponse - 257, // 665: productv1.ProductService.RequireStorageOptionalTagSummaryById:output_type -> productv1.RequireStorageOptionalTagSummaryByIdResponse - 267, // 666: productv1.ProductService.RequireStorageProcessedMetadataById:output_type -> productv1.RequireStorageProcessedMetadataByIdResponse - 287, // 667: productv1.ProductService.RequireStorageProcessedMetadataHistoryById:output_type -> productv1.RequireStorageProcessedMetadataHistoryByIdResponse - 277, // 668: productv1.ProductService.RequireStorageProcessedTagsById:output_type -> productv1.RequireStorageProcessedTagsByIdResponse - 332, // 669: productv1.ProductService.RequireStorageRecommendedItemById:output_type -> productv1.RequireStorageRecommendedItemByIdResponse - 337, // 670: productv1.ProductService.RequireStorageRecommendedItemsById:output_type -> productv1.RequireStorageRecommendedItemsByIdResponse - 312, // 671: productv1.ProductService.RequireStorageSecuritySummaryById:output_type -> productv1.RequireStorageSecuritySummaryByIdResponse - 247, // 672: productv1.ProductService.RequireStorageStockHealthScoreById:output_type -> productv1.RequireStorageStockHealthScoreByIdResponse - 252, // 673: productv1.ProductService.RequireStorageTagSummaryById:output_type -> productv1.RequireStorageTagSummaryByIdResponse - 370, // 674: productv1.ProductService.RequireWarehouseStockHealthScoreById:output_type -> productv1.RequireWarehouseStockHealthScoreByIdResponse - 211, // 675: productv1.ProductService.ResolveCategoryActiveSubcategories:output_type -> productv1.ResolveCategoryActiveSubcategoriesResponse - 179, // 676: productv1.ProductService.ResolveCategoryCategoryMetrics:output_type -> productv1.ResolveCategoryCategoryMetricsResponse - 189, // 677: productv1.ProductService.ResolveCategoryCategoryStatus:output_type -> productv1.ResolveCategoryCategoryStatusResponse - 194, // 678: productv1.ProductService.ResolveCategoryChildCategories:output_type -> productv1.ResolveCategoryChildCategoriesResponse - 184, // 679: productv1.ProductService.ResolveCategoryMascot:output_type -> productv1.ResolveCategoryMascotResponse - 239, // 680: productv1.ProductService.ResolveCategoryMetricsAverageScore:output_type -> productv1.ResolveCategoryMetricsAverageScoreResponse - 230, // 681: productv1.ProductService.ResolveCategoryMetricsNormalizedScore:output_type -> productv1.ResolveCategoryMetricsNormalizedScoreResponse - 235, // 682: productv1.ProductService.ResolveCategoryMetricsRelatedCategory:output_type -> productv1.ResolveCategoryMetricsRelatedCategoryResponse - 199, // 683: productv1.ProductService.ResolveCategoryOptionalCategories:output_type -> productv1.ResolveCategoryOptionalCategoriesResponse - 174, // 684: productv1.ProductService.ResolveCategoryPopularityScore:output_type -> productv1.ResolveCategoryPopularityScoreResponse - 169, // 685: productv1.ProductService.ResolveCategoryProductCount:output_type -> productv1.ResolveCategoryProductCountResponse - 207, // 686: productv1.ProductService.ResolveCategoryTopSubcategory:output_type -> productv1.ResolveCategoryTopSubcategoryResponse - 203, // 687: productv1.ProductService.ResolveCategoryTotalProducts:output_type -> productv1.ResolveCategoryTotalProductsResponse - 139, // 688: productv1.ProductService.ResolveProductMascotRecommendation:output_type -> productv1.ResolveProductMascotRecommendationResponse - 149, // 689: productv1.ProductService.ResolveProductProductDetails:output_type -> productv1.ResolveProductProductDetailsResponse - 134, // 690: productv1.ProductService.ResolveProductRecommendedCategory:output_type -> productv1.ResolveProductRecommendedCategoryResponse - 129, // 691: productv1.ProductService.ResolveProductShippingEstimate:output_type -> productv1.ResolveProductShippingEstimateResponse - 144, // 692: productv1.ProductService.ResolveProductStockStatus:output_type -> productv1.ResolveProductStockStatusResponse - 159, // 693: productv1.ProductService.ResolveStorageLinkedStorages:output_type -> productv1.ResolveStorageLinkedStoragesResponse - 164, // 694: productv1.ProductService.ResolveStorageNearbyStorages:output_type -> productv1.ResolveStorageNearbyStoragesResponse - 154, // 695: productv1.ProductService.ResolveStorageStorageStatus:output_type -> productv1.ResolveStorageStorageStatusResponse - 221, // 696: productv1.ProductService.ResolveSubcategoryFeaturedCategory:output_type -> productv1.ResolveSubcategoryFeaturedCategoryResponse - 216, // 697: productv1.ProductService.ResolveSubcategoryItemCount:output_type -> productv1.ResolveSubcategoryItemCountResponse - 225, // 698: productv1.ProductService.ResolveSubcategoryParentCategory:output_type -> productv1.ResolveSubcategoryParentCategoryResponse - 244, // 699: productv1.ProductService.ResolveTestContainerDetails:output_type -> productv1.ResolveTestContainerDetailsResponse - 601, // [601:700] is the sub-list for method output_type - 502, // [502:601] is the sub-list for method input_type - 502, // [502:502] is the sub-list for extension type_name - 502, // [502:502] is the sub-list for extension extendee - 0, // [0:502] is the sub-list for field type_name + 468, // 0: productv1.ListOfAuthorFilter.list:type_name -> productv1.ListOfAuthorFilter.List + 469, // 1: productv1.ListOfAuthorInput.list:type_name -> productv1.ListOfAuthorInput.List + 470, // 2: productv1.ListOfBlogPost.list:type_name -> productv1.ListOfBlogPost.List + 471, // 3: productv1.ListOfBlogPostFilter.list:type_name -> productv1.ListOfBlogPostFilter.List + 472, // 4: productv1.ListOfBlogPostInput.list:type_name -> productv1.ListOfBlogPostInput.List + 473, // 5: productv1.ListOfBoolean.list:type_name -> productv1.ListOfBoolean.List + 474, // 6: productv1.ListOfCategory.list:type_name -> productv1.ListOfCategory.List + 475, // 7: productv1.ListOfCategoryInput.list:type_name -> productv1.ListOfCategoryInput.List + 476, // 8: productv1.ListOfConditionsInput.list:type_name -> productv1.ListOfConditionsInput.List + 477, // 9: productv1.ListOfFloat.list:type_name -> productv1.ListOfFloat.List + 478, // 10: productv1.ListOfInt.list:type_name -> productv1.ListOfInt.List + 479, // 11: productv1.ListOfListOfCategory.list:type_name -> productv1.ListOfListOfCategory.List + 480, // 12: productv1.ListOfListOfCategoryInput.list:type_name -> productv1.ListOfListOfCategoryInput.List + 481, // 13: productv1.ListOfListOfString.list:type_name -> productv1.ListOfListOfString.List + 482, // 14: productv1.ListOfListOfUser.list:type_name -> productv1.ListOfListOfUser.List + 483, // 15: productv1.ListOfListOfUserInput.list:type_name -> productv1.ListOfListOfUserInput.List + 484, // 16: productv1.ListOfOrderLine.list:type_name -> productv1.ListOfOrderLine.List + 485, // 17: productv1.ListOfProduct.list:type_name -> productv1.ListOfProduct.List + 486, // 18: productv1.ListOfStorage.list:type_name -> productv1.ListOfStorage.List + 487, // 19: productv1.ListOfStorageItem.list:type_name -> productv1.ListOfStorageItem.List + 488, // 20: productv1.ListOfStorageMetadata.list:type_name -> productv1.ListOfStorageMetadata.List + 489, // 21: productv1.ListOfStorageOperationResult.list:type_name -> productv1.ListOfStorageOperationResult.List + 490, // 22: productv1.ListOfString.list:type_name -> productv1.ListOfString.List + 491, // 23: productv1.ListOfSubcategory.list:type_name -> productv1.ListOfSubcategory.List + 492, // 24: productv1.ListOfUser.list:type_name -> productv1.ListOfUser.List + 493, // 25: productv1.ListOfUserInput.list:type_name -> productv1.ListOfUserInput.List + 28, // 26: productv1.LookupProductByIdRequest.keys:type_name -> productv1.LookupProductByIdRequestKey + 398, // 27: productv1.LookupProductByIdResponse.result:type_name -> productv1.Product + 31, // 28: productv1.LookupStorageByIdRequest.keys:type_name -> productv1.LookupStorageByIdRequestKey + 399, // 29: productv1.LookupStorageByIdResponse.result:type_name -> productv1.Storage + 34, // 30: productv1.LookupWarehouseByIdRequest.keys:type_name -> productv1.LookupWarehouseByIdRequestKey + 400, // 31: productv1.LookupWarehouseByIdResponse.result:type_name -> productv1.Warehouse + 401, // 32: productv1.QueryUsersResponse.users:type_name -> productv1.User + 401, // 33: productv1.QueryUserResponse.user:type_name -> productv1.User + 402, // 34: productv1.QueryNestedTypeResponse.nested_type:type_name -> productv1.NestedTypeA + 403, // 35: productv1.QueryRecursiveTypeResponse.recursive_type:type_name -> productv1.RecursiveType + 404, // 36: productv1.QueryTypeFilterWithArgumentsResponse.type_filter_with_arguments:type_name -> productv1.TypeWithMultipleFilterFields + 405, // 37: productv1.QueryTypeWithMultipleFilterFieldsRequest.filter:type_name -> productv1.FilterTypeInput + 404, // 38: productv1.QueryTypeWithMultipleFilterFieldsResponse.type_with_multiple_filter_fields:type_name -> productv1.TypeWithMultipleFilterFields + 406, // 39: productv1.QueryComplexFilterTypeRequest.filter:type_name -> productv1.ComplexFilterTypeInput + 407, // 40: productv1.QueryComplexFilterTypeResponse.complex_filter_type:type_name -> productv1.TypeWithComplexFilterInput + 408, // 41: productv1.QueryCalculateTotalsRequest.orders:type_name -> productv1.OrderInput + 409, // 42: productv1.QueryCalculateTotalsResponse.calculate_totals:type_name -> productv1.Order + 410, // 43: productv1.QueryCategoriesResponse.categories:type_name -> productv1.Category + 410, // 44: productv1.QueryCategoryResponse.category:type_name -> productv1.Category + 0, // 45: productv1.QueryCategoriesByKindRequest.kind:type_name -> productv1.CategoryKind + 410, // 46: productv1.QueryCategoriesByKindResponse.categories_by_kind:type_name -> productv1.Category + 0, // 47: productv1.QueryCategoriesByKindsRequest.kinds:type_name -> productv1.CategoryKind + 410, // 48: productv1.QueryCategoriesByKindsResponse.categories_by_kinds:type_name -> productv1.Category + 411, // 49: productv1.QueryFilterCategoriesRequest.filter:type_name -> productv1.CategoryFilter + 410, // 50: productv1.QueryFilterCategoriesResponse.filter_categories:type_name -> productv1.Category + 412, // 51: productv1.QueryRandomPetResponse.random_pet:type_name -> productv1.Animal + 412, // 52: productv1.QueryAllPetsResponse.all_pets:type_name -> productv1.Animal + 413, // 53: productv1.QuerySearchRequest.input:type_name -> productv1.SearchInput + 414, // 54: productv1.QuerySearchResponse.search:type_name -> productv1.SearchResult + 414, // 55: productv1.QueryRandomSearchResultResponse.random_search_result:type_name -> productv1.SearchResult + 415, // 56: productv1.QueryNullableFieldsTypeResponse.nullable_fields_type:type_name -> productv1.NullableFieldsType + 415, // 57: productv1.QueryNullableFieldsTypeByIdResponse.nullable_fields_type_by_id:type_name -> productv1.NullableFieldsType + 416, // 58: productv1.QueryNullableFieldsTypeWithFilterRequest.filter:type_name -> productv1.NullableFieldsFilter + 415, // 59: productv1.QueryNullableFieldsTypeWithFilterResponse.nullable_fields_type_with_filter:type_name -> productv1.NullableFieldsType + 415, // 60: productv1.QueryAllNullableFieldsTypesResponse.all_nullable_fields_types:type_name -> productv1.NullableFieldsType + 417, // 61: productv1.QueryBlogPostResponse.blog_post:type_name -> productv1.BlogPost + 417, // 62: productv1.QueryBlogPostByIdResponse.blog_post_by_id:type_name -> productv1.BlogPost + 418, // 63: productv1.QueryBlogPostsWithFilterRequest.filter:type_name -> productv1.BlogPostFilter + 417, // 64: productv1.QueryBlogPostsWithFilterResponse.blog_posts_with_filter:type_name -> productv1.BlogPost + 417, // 65: productv1.QueryAllBlogPostsResponse.all_blog_posts:type_name -> productv1.BlogPost + 419, // 66: productv1.QueryAuthorResponse.author:type_name -> productv1.Author + 419, // 67: productv1.QueryAuthorByIdResponse.author_by_id:type_name -> productv1.Author + 420, // 68: productv1.QueryAuthorsWithFilterRequest.filter:type_name -> productv1.AuthorFilter + 419, // 69: productv1.QueryAuthorsWithFilterResponse.authors_with_filter:type_name -> productv1.Author + 419, // 70: productv1.QueryAllAuthorsResponse.all_authors:type_name -> productv1.Author + 2, // 71: productv1.QueryBulkSearchAuthorsRequest.filters:type_name -> productv1.ListOfAuthorFilter + 419, // 72: productv1.QueryBulkSearchAuthorsResponse.bulk_search_authors:type_name -> productv1.Author + 5, // 73: productv1.QueryBulkSearchBlogPostsRequest.filters:type_name -> productv1.ListOfBlogPostFilter + 417, // 74: productv1.QueryBulkSearchBlogPostsResponse.bulk_search_blog_posts:type_name -> productv1.BlogPost + 421, // 75: productv1.QueryTestContainerResponse.test_container:type_name -> productv1.TestContainer + 421, // 76: productv1.QueryTestContainersResponse.test_containers:type_name -> productv1.TestContainer + 422, // 77: productv1.QueryConditionalSearchRequest.conditions:type_name -> productv1.ConditionsInput + 423, // 78: productv1.QueryConditionalSearchResponse.conditional_search:type_name -> productv1.ConditionalSearchResult + 424, // 79: productv1.MutationCreateUserRequest.input:type_name -> productv1.UserInput + 401, // 80: productv1.MutationCreateUserResponse.create_user:type_name -> productv1.User + 425, // 81: productv1.MutationPerformActionRequest.input:type_name -> productv1.ActionInput + 426, // 82: productv1.MutationPerformActionResponse.perform_action:type_name -> productv1.ActionResult + 427, // 83: productv1.MutationCreateNullableFieldsTypeRequest.input:type_name -> productv1.NullableFieldsInput + 415, // 84: productv1.MutationCreateNullableFieldsTypeResponse.create_nullable_fields_type:type_name -> productv1.NullableFieldsType + 427, // 85: productv1.MutationUpdateNullableFieldsTypeRequest.input:type_name -> productv1.NullableFieldsInput + 415, // 86: productv1.MutationUpdateNullableFieldsTypeResponse.update_nullable_fields_type:type_name -> productv1.NullableFieldsType + 428, // 87: productv1.MutationCreateBlogPostRequest.input:type_name -> productv1.BlogPostInput + 417, // 88: productv1.MutationCreateBlogPostResponse.create_blog_post:type_name -> productv1.BlogPost + 428, // 89: productv1.MutationUpdateBlogPostRequest.input:type_name -> productv1.BlogPostInput + 417, // 90: productv1.MutationUpdateBlogPostResponse.update_blog_post:type_name -> productv1.BlogPost + 429, // 91: productv1.MutationCreateAuthorRequest.input:type_name -> productv1.AuthorInput + 419, // 92: productv1.MutationCreateAuthorResponse.create_author:type_name -> productv1.Author + 429, // 93: productv1.MutationUpdateAuthorRequest.input:type_name -> productv1.AuthorInput + 419, // 94: productv1.MutationUpdateAuthorResponse.update_author:type_name -> productv1.Author + 3, // 95: productv1.MutationBulkCreateAuthorsRequest.authors:type_name -> productv1.ListOfAuthorInput + 419, // 96: productv1.MutationBulkCreateAuthorsResponse.bulk_create_authors:type_name -> productv1.Author + 3, // 97: productv1.MutationBulkUpdateAuthorsRequest.authors:type_name -> productv1.ListOfAuthorInput + 419, // 98: productv1.MutationBulkUpdateAuthorsResponse.bulk_update_authors:type_name -> productv1.Author + 6, // 99: productv1.MutationBulkCreateBlogPostsRequest.blog_posts:type_name -> productv1.ListOfBlogPostInput + 417, // 100: productv1.MutationBulkCreateBlogPostsResponse.bulk_create_blog_posts:type_name -> productv1.BlogPost + 6, // 101: productv1.MutationBulkUpdateBlogPostsRequest.blog_posts:type_name -> productv1.ListOfBlogPostInput + 417, // 102: productv1.MutationBulkUpdateBlogPostsResponse.bulk_update_blog_posts:type_name -> productv1.BlogPost + 467, // 103: productv1.ResolveProductShippingEstimateArgs.input:type_name -> productv1.ShippingEstimateInput + 130, // 104: productv1.ResolveProductShippingEstimateRequest.context:type_name -> productv1.ResolveProductShippingEstimateContext + 129, // 105: productv1.ResolveProductShippingEstimateRequest.field_args:type_name -> productv1.ResolveProductShippingEstimateArgs + 132, // 106: productv1.ResolveProductShippingEstimateResponse.result:type_name -> productv1.ResolveProductShippingEstimateResult + 135, // 107: productv1.ResolveProductRecommendedCategoryRequest.context:type_name -> productv1.ResolveProductRecommendedCategoryContext + 134, // 108: productv1.ResolveProductRecommendedCategoryRequest.field_args:type_name -> productv1.ResolveProductRecommendedCategoryArgs + 410, // 109: productv1.ResolveProductRecommendedCategoryResult.recommended_category:type_name -> productv1.Category + 137, // 110: productv1.ResolveProductRecommendedCategoryResponse.result:type_name -> productv1.ResolveProductRecommendedCategoryResult + 140, // 111: productv1.ResolveProductMascotRecommendationRequest.context:type_name -> productv1.ResolveProductMascotRecommendationContext + 139, // 112: productv1.ResolveProductMascotRecommendationRequest.field_args:type_name -> productv1.ResolveProductMascotRecommendationArgs + 412, // 113: productv1.ResolveProductMascotRecommendationResult.mascot_recommendation:type_name -> productv1.Animal + 142, // 114: productv1.ResolveProductMascotRecommendationResponse.result:type_name -> productv1.ResolveProductMascotRecommendationResult + 145, // 115: productv1.ResolveProductStockStatusRequest.context:type_name -> productv1.ResolveProductStockStatusContext + 144, // 116: productv1.ResolveProductStockStatusRequest.field_args:type_name -> productv1.ResolveProductStockStatusArgs + 426, // 117: productv1.ResolveProductStockStatusResult.stock_status:type_name -> productv1.ActionResult + 147, // 118: productv1.ResolveProductStockStatusResponse.result:type_name -> productv1.ResolveProductStockStatusResult + 150, // 119: productv1.ResolveProductProductDetailsRequest.context:type_name -> productv1.ResolveProductProductDetailsContext + 149, // 120: productv1.ResolveProductProductDetailsRequest.field_args:type_name -> productv1.ResolveProductProductDetailsArgs + 430, // 121: productv1.ResolveProductProductDetailsResult.product_details:type_name -> productv1.ProductDetails + 152, // 122: productv1.ResolveProductProductDetailsResponse.result:type_name -> productv1.ResolveProductProductDetailsResult + 155, // 123: productv1.ResolveStorageStorageStatusRequest.context:type_name -> productv1.ResolveStorageStorageStatusContext + 154, // 124: productv1.ResolveStorageStorageStatusRequest.field_args:type_name -> productv1.ResolveStorageStorageStatusArgs + 426, // 125: productv1.ResolveStorageStorageStatusResult.storage_status:type_name -> productv1.ActionResult + 157, // 126: productv1.ResolveStorageStorageStatusResponse.result:type_name -> productv1.ResolveStorageStorageStatusResult + 160, // 127: productv1.ResolveStorageLinkedStoragesRequest.context:type_name -> productv1.ResolveStorageLinkedStoragesContext + 159, // 128: productv1.ResolveStorageLinkedStoragesRequest.field_args:type_name -> productv1.ResolveStorageLinkedStoragesArgs + 399, // 129: productv1.ResolveStorageLinkedStoragesResult.linked_storages:type_name -> productv1.Storage + 162, // 130: productv1.ResolveStorageLinkedStoragesResponse.result:type_name -> productv1.ResolveStorageLinkedStoragesResult + 533, // 131: productv1.ResolveStorageNearbyStoragesArgs.radius:type_name -> google.protobuf.Int32Value + 165, // 132: productv1.ResolveStorageNearbyStoragesRequest.context:type_name -> productv1.ResolveStorageNearbyStoragesContext + 164, // 133: productv1.ResolveStorageNearbyStoragesRequest.field_args:type_name -> productv1.ResolveStorageNearbyStoragesArgs + 20, // 134: productv1.ResolveStorageNearbyStoragesResult.nearby_storages:type_name -> productv1.ListOfStorage + 167, // 135: productv1.ResolveStorageNearbyStoragesResponse.result:type_name -> productv1.ResolveStorageNearbyStoragesResult + 465, // 136: productv1.ResolveCategoryProductCountArgs.filters:type_name -> productv1.ProductCountFilter + 170, // 137: productv1.ResolveCategoryProductCountRequest.context:type_name -> productv1.ResolveCategoryProductCountContext + 169, // 138: productv1.ResolveCategoryProductCountRequest.field_args:type_name -> productv1.ResolveCategoryProductCountArgs + 172, // 139: productv1.ResolveCategoryProductCountResponse.result:type_name -> productv1.ResolveCategoryProductCountResult + 533, // 140: productv1.ResolveCategoryPopularityScoreArgs.threshold:type_name -> google.protobuf.Int32Value + 175, // 141: productv1.ResolveCategoryPopularityScoreRequest.context:type_name -> productv1.ResolveCategoryPopularityScoreContext + 174, // 142: productv1.ResolveCategoryPopularityScoreRequest.field_args:type_name -> productv1.ResolveCategoryPopularityScoreArgs + 533, // 143: productv1.ResolveCategoryPopularityScoreResult.popularity_score:type_name -> google.protobuf.Int32Value + 177, // 144: productv1.ResolveCategoryPopularityScoreResponse.result:type_name -> productv1.ResolveCategoryPopularityScoreResult + 180, // 145: productv1.ResolveCategoryCategoryMetricsRequest.context:type_name -> productv1.ResolveCategoryCategoryMetricsContext + 179, // 146: productv1.ResolveCategoryCategoryMetricsRequest.field_args:type_name -> productv1.ResolveCategoryCategoryMetricsArgs + 441, // 147: productv1.ResolveCategoryCategoryMetricsResult.category_metrics:type_name -> productv1.CategoryMetrics + 182, // 148: productv1.ResolveCategoryCategoryMetricsResponse.result:type_name -> productv1.ResolveCategoryCategoryMetricsResult + 0, // 149: productv1.ResolveCategoryMascotContext.kind:type_name -> productv1.CategoryKind + 185, // 150: productv1.ResolveCategoryMascotRequest.context:type_name -> productv1.ResolveCategoryMascotContext + 184, // 151: productv1.ResolveCategoryMascotRequest.field_args:type_name -> productv1.ResolveCategoryMascotArgs + 412, // 152: productv1.ResolveCategoryMascotResult.mascot:type_name -> productv1.Animal + 187, // 153: productv1.ResolveCategoryMascotResponse.result:type_name -> productv1.ResolveCategoryMascotResult + 190, // 154: productv1.ResolveCategoryCategoryStatusRequest.context:type_name -> productv1.ResolveCategoryCategoryStatusContext + 189, // 155: productv1.ResolveCategoryCategoryStatusRequest.field_args:type_name -> productv1.ResolveCategoryCategoryStatusArgs + 426, // 156: productv1.ResolveCategoryCategoryStatusResult.category_status:type_name -> productv1.ActionResult + 192, // 157: productv1.ResolveCategoryCategoryStatusResponse.result:type_name -> productv1.ResolveCategoryCategoryStatusResult + 534, // 158: productv1.ResolveCategoryChildCategoriesArgs.include:type_name -> google.protobuf.BoolValue + 195, // 159: productv1.ResolveCategoryChildCategoriesRequest.context:type_name -> productv1.ResolveCategoryChildCategoriesContext + 194, // 160: productv1.ResolveCategoryChildCategoriesRequest.field_args:type_name -> productv1.ResolveCategoryChildCategoriesArgs + 410, // 161: productv1.ResolveCategoryChildCategoriesResult.child_categories:type_name -> productv1.Category + 197, // 162: productv1.ResolveCategoryChildCategoriesResponse.result:type_name -> productv1.ResolveCategoryChildCategoriesResult + 534, // 163: productv1.ResolveCategoryOptionalCategoriesArgs.include:type_name -> google.protobuf.BoolValue + 200, // 164: productv1.ResolveCategoryOptionalCategoriesRequest.context:type_name -> productv1.ResolveCategoryOptionalCategoriesContext + 199, // 165: productv1.ResolveCategoryOptionalCategoriesRequest.field_args:type_name -> productv1.ResolveCategoryOptionalCategoriesArgs + 8, // 166: productv1.ResolveCategoryOptionalCategoriesResult.optional_categories:type_name -> productv1.ListOfCategory + 202, // 167: productv1.ResolveCategoryOptionalCategoriesResponse.result:type_name -> productv1.ResolveCategoryOptionalCategoriesResult + 204, // 168: productv1.ResolveCategoryTotalProductsRequest.context:type_name -> productv1.ResolveCategoryTotalProductsContext + 206, // 169: productv1.ResolveCategoryTotalProductsResponse.result:type_name -> productv1.ResolveCategoryTotalProductsResult + 208, // 170: productv1.ResolveCategoryTopSubcategoryRequest.context:type_name -> productv1.ResolveCategoryTopSubcategoryContext + 440, // 171: productv1.ResolveCategoryTopSubcategoryResult.top_subcategory:type_name -> productv1.Subcategory + 210, // 172: productv1.ResolveCategoryTopSubcategoryResponse.result:type_name -> productv1.ResolveCategoryTopSubcategoryResult + 212, // 173: productv1.ResolveCategoryActiveSubcategoriesRequest.context:type_name -> productv1.ResolveCategoryActiveSubcategoriesContext + 440, // 174: productv1.ResolveCategoryActiveSubcategoriesResult.active_subcategories:type_name -> productv1.Subcategory + 214, // 175: productv1.ResolveCategoryActiveSubcategoriesResponse.result:type_name -> productv1.ResolveCategoryActiveSubcategoriesResult + 466, // 176: productv1.ResolveSubcategoryItemCountArgs.filters:type_name -> productv1.SubcategoryItemFilter + 217, // 177: productv1.ResolveSubcategoryItemCountRequest.context:type_name -> productv1.ResolveSubcategoryItemCountContext + 216, // 178: productv1.ResolveSubcategoryItemCountRequest.field_args:type_name -> productv1.ResolveSubcategoryItemCountArgs + 219, // 179: productv1.ResolveSubcategoryItemCountResponse.result:type_name -> productv1.ResolveSubcategoryItemCountResult + 222, // 180: productv1.ResolveSubcategoryFeaturedCategoryRequest.context:type_name -> productv1.ResolveSubcategoryFeaturedCategoryContext + 221, // 181: productv1.ResolveSubcategoryFeaturedCategoryRequest.field_args:type_name -> productv1.ResolveSubcategoryFeaturedCategoryArgs + 410, // 182: productv1.ResolveSubcategoryFeaturedCategoryResult.featured_category:type_name -> productv1.Category + 224, // 183: productv1.ResolveSubcategoryFeaturedCategoryResponse.result:type_name -> productv1.ResolveSubcategoryFeaturedCategoryResult + 226, // 184: productv1.ResolveSubcategoryParentCategoryRequest.context:type_name -> productv1.ResolveSubcategoryParentCategoryContext + 410, // 185: productv1.ResolveSubcategoryParentCategoryResult.parent_category:type_name -> productv1.Category + 228, // 186: productv1.ResolveSubcategoryParentCategoryResponse.result:type_name -> productv1.ResolveSubcategoryParentCategoryResult + 231, // 187: productv1.ResolveCategoryMetricsNormalizedScoreRequest.context:type_name -> productv1.ResolveCategoryMetricsNormalizedScoreContext + 230, // 188: productv1.ResolveCategoryMetricsNormalizedScoreRequest.field_args:type_name -> productv1.ResolveCategoryMetricsNormalizedScoreArgs + 233, // 189: productv1.ResolveCategoryMetricsNormalizedScoreResponse.result:type_name -> productv1.ResolveCategoryMetricsNormalizedScoreResult + 534, // 190: productv1.ResolveCategoryMetricsRelatedCategoryArgs.include:type_name -> google.protobuf.BoolValue + 236, // 191: productv1.ResolveCategoryMetricsRelatedCategoryRequest.context:type_name -> productv1.ResolveCategoryMetricsRelatedCategoryContext + 235, // 192: productv1.ResolveCategoryMetricsRelatedCategoryRequest.field_args:type_name -> productv1.ResolveCategoryMetricsRelatedCategoryArgs + 410, // 193: productv1.ResolveCategoryMetricsRelatedCategoryResult.related_category:type_name -> productv1.Category + 238, // 194: productv1.ResolveCategoryMetricsRelatedCategoryResponse.result:type_name -> productv1.ResolveCategoryMetricsRelatedCategoryResult + 240, // 195: productv1.ResolveCategoryMetricsAverageScoreRequest.context:type_name -> productv1.ResolveCategoryMetricsAverageScoreContext + 242, // 196: productv1.ResolveCategoryMetricsAverageScoreResponse.result:type_name -> productv1.ResolveCategoryMetricsAverageScoreResult + 245, // 197: productv1.ResolveTestContainerDetailsRequest.context:type_name -> productv1.ResolveTestContainerDetailsContext + 244, // 198: productv1.ResolveTestContainerDetailsRequest.field_args:type_name -> productv1.ResolveTestContainerDetailsArgs + 463, // 199: productv1.ResolveTestContainerDetailsResult.details:type_name -> productv1.TestDetails + 247, // 200: productv1.ResolveTestContainerDetailsResponse.result:type_name -> productv1.ResolveTestContainerDetailsResult + 250, // 201: productv1.RequireStorageStockHealthScoreByIdRequest.context:type_name -> productv1.RequireStorageStockHealthScoreByIdContext + 31, // 202: productv1.RequireStorageStockHealthScoreByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey + 253, // 203: productv1.RequireStorageStockHealthScoreByIdContext.fields:type_name -> productv1.RequireStorageStockHealthScoreByIdFields + 252, // 204: productv1.RequireStorageStockHealthScoreByIdResponse.result:type_name -> productv1.RequireStorageStockHealthScoreByIdResult + 494, // 205: productv1.RequireStorageStockHealthScoreByIdFields.restock_data:type_name -> productv1.RequireStorageStockHealthScoreByIdFields.RestockData + 255, // 206: productv1.RequireStorageTagSummaryByIdRequest.context:type_name -> productv1.RequireStorageTagSummaryByIdContext + 31, // 207: productv1.RequireStorageTagSummaryByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey + 258, // 208: productv1.RequireStorageTagSummaryByIdContext.fields:type_name -> productv1.RequireStorageTagSummaryByIdFields + 257, // 209: productv1.RequireStorageTagSummaryByIdResponse.result:type_name -> productv1.RequireStorageTagSummaryByIdResult + 260, // 210: productv1.RequireStorageOptionalTagSummaryByIdRequest.context:type_name -> productv1.RequireStorageOptionalTagSummaryByIdContext + 31, // 211: productv1.RequireStorageOptionalTagSummaryByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey + 263, // 212: productv1.RequireStorageOptionalTagSummaryByIdContext.fields:type_name -> productv1.RequireStorageOptionalTagSummaryByIdFields + 262, // 213: productv1.RequireStorageOptionalTagSummaryByIdResponse.result:type_name -> productv1.RequireStorageOptionalTagSummaryByIdResult + 535, // 214: productv1.RequireStorageOptionalTagSummaryByIdResult.optional_tag_summary:type_name -> google.protobuf.StringValue + 24, // 215: productv1.RequireStorageOptionalTagSummaryByIdFields.optional_tags:type_name -> productv1.ListOfString + 265, // 216: productv1.RequireStorageMetadataScoreByIdRequest.context:type_name -> productv1.RequireStorageMetadataScoreByIdContext + 31, // 217: productv1.RequireStorageMetadataScoreByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey + 268, // 218: productv1.RequireStorageMetadataScoreByIdContext.fields:type_name -> productv1.RequireStorageMetadataScoreByIdFields + 267, // 219: productv1.RequireStorageMetadataScoreByIdResponse.result:type_name -> productv1.RequireStorageMetadataScoreByIdResult + 495, // 220: productv1.RequireStorageMetadataScoreByIdFields.metadata:type_name -> productv1.RequireStorageMetadataScoreByIdFields.StorageMetadata + 270, // 221: productv1.RequireStorageProcessedMetadataByIdRequest.context:type_name -> productv1.RequireStorageProcessedMetadataByIdContext + 31, // 222: productv1.RequireStorageProcessedMetadataByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey + 273, // 223: productv1.RequireStorageProcessedMetadataByIdContext.fields:type_name -> productv1.RequireStorageProcessedMetadataByIdFields + 272, // 224: productv1.RequireStorageProcessedMetadataByIdResponse.result:type_name -> productv1.RequireStorageProcessedMetadataByIdResult + 432, // 225: productv1.RequireStorageProcessedMetadataByIdResult.processed_metadata:type_name -> productv1.StorageMetadata + 496, // 226: productv1.RequireStorageProcessedMetadataByIdFields.metadata:type_name -> productv1.RequireStorageProcessedMetadataByIdFields.StorageMetadata + 275, // 227: productv1.RequireStorageOptionalProcessedMetadataByIdRequest.context:type_name -> productv1.RequireStorageOptionalProcessedMetadataByIdContext + 31, // 228: productv1.RequireStorageOptionalProcessedMetadataByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey + 278, // 229: productv1.RequireStorageOptionalProcessedMetadataByIdContext.fields:type_name -> productv1.RequireStorageOptionalProcessedMetadataByIdFields + 277, // 230: productv1.RequireStorageOptionalProcessedMetadataByIdResponse.result:type_name -> productv1.RequireStorageOptionalProcessedMetadataByIdResult + 432, // 231: productv1.RequireStorageOptionalProcessedMetadataByIdResult.optional_processed_metadata:type_name -> productv1.StorageMetadata + 497, // 232: productv1.RequireStorageOptionalProcessedMetadataByIdFields.metadata:type_name -> productv1.RequireStorageOptionalProcessedMetadataByIdFields.StorageMetadata + 280, // 233: productv1.RequireStorageProcessedTagsByIdRequest.context:type_name -> productv1.RequireStorageProcessedTagsByIdContext + 31, // 234: productv1.RequireStorageProcessedTagsByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey + 283, // 235: productv1.RequireStorageProcessedTagsByIdContext.fields:type_name -> productv1.RequireStorageProcessedTagsByIdFields + 282, // 236: productv1.RequireStorageProcessedTagsByIdResponse.result:type_name -> productv1.RequireStorageProcessedTagsByIdResult + 285, // 237: productv1.RequireStorageOptionalProcessedTagsByIdRequest.context:type_name -> productv1.RequireStorageOptionalProcessedTagsByIdContext + 31, // 238: productv1.RequireStorageOptionalProcessedTagsByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey + 288, // 239: productv1.RequireStorageOptionalProcessedTagsByIdContext.fields:type_name -> productv1.RequireStorageOptionalProcessedTagsByIdFields + 287, // 240: productv1.RequireStorageOptionalProcessedTagsByIdResponse.result:type_name -> productv1.RequireStorageOptionalProcessedTagsByIdResult + 24, // 241: productv1.RequireStorageOptionalProcessedTagsByIdResult.optional_processed_tags:type_name -> productv1.ListOfString + 24, // 242: productv1.RequireStorageOptionalProcessedTagsByIdFields.optional_tags:type_name -> productv1.ListOfString + 290, // 243: productv1.RequireStorageProcessedMetadataHistoryByIdRequest.context:type_name -> productv1.RequireStorageProcessedMetadataHistoryByIdContext + 31, // 244: productv1.RequireStorageProcessedMetadataHistoryByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey + 293, // 245: productv1.RequireStorageProcessedMetadataHistoryByIdContext.fields:type_name -> productv1.RequireStorageProcessedMetadataHistoryByIdFields + 292, // 246: productv1.RequireStorageProcessedMetadataHistoryByIdResponse.result:type_name -> productv1.RequireStorageProcessedMetadataHistoryByIdResult + 432, // 247: productv1.RequireStorageProcessedMetadataHistoryByIdResult.processed_metadata_history:type_name -> productv1.StorageMetadata + 498, // 248: productv1.RequireStorageProcessedMetadataHistoryByIdFields.metadata_history:type_name -> productv1.RequireStorageProcessedMetadataHistoryByIdFields.StorageMetadata + 295, // 249: productv1.RequireStorageOptionalProcessedMetadataHistoryByIdRequest.context:type_name -> productv1.RequireStorageOptionalProcessedMetadataHistoryByIdContext + 31, // 250: productv1.RequireStorageOptionalProcessedMetadataHistoryByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey + 298, // 251: productv1.RequireStorageOptionalProcessedMetadataHistoryByIdContext.fields:type_name -> productv1.RequireStorageOptionalProcessedMetadataHistoryByIdFields + 297, // 252: productv1.RequireStorageOptionalProcessedMetadataHistoryByIdResponse.result:type_name -> productv1.RequireStorageOptionalProcessedMetadataHistoryByIdResult + 22, // 253: productv1.RequireStorageOptionalProcessedMetadataHistoryByIdResult.optional_processed_metadata_history:type_name -> productv1.ListOfStorageMetadata + 499, // 254: productv1.RequireStorageOptionalProcessedMetadataHistoryByIdFields.metadata_history:type_name -> productv1.RequireStorageOptionalProcessedMetadataHistoryByIdFields.StorageMetadata + 300, // 255: productv1.RequireStorageTagsByLengthsByIdRequest.context:type_name -> productv1.RequireStorageTagsByLengthsByIdContext + 301, // 256: productv1.RequireStorageTagsByLengthsByIdRequest.field_args:type_name -> productv1.RequireStorageTagsByLengthsByIdArgs + 31, // 257: productv1.RequireStorageTagsByLengthsByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey + 304, // 258: productv1.RequireStorageTagsByLengthsByIdContext.fields:type_name -> productv1.RequireStorageTagsByLengthsByIdFields + 12, // 259: productv1.RequireStorageTagsByLengthsByIdArgs.lengths:type_name -> productv1.ListOfInt + 303, // 260: productv1.RequireStorageTagsByLengthsByIdResponse.result:type_name -> productv1.RequireStorageTagsByLengthsByIdResult + 24, // 261: productv1.RequireStorageTagsByLengthsByIdResult.tags_by_lengths:type_name -> productv1.ListOfString + 306, // 262: productv1.RequireStorageKindSummaryByIdRequest.context:type_name -> productv1.RequireStorageKindSummaryByIdContext + 31, // 263: productv1.RequireStorageKindSummaryByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey + 309, // 264: productv1.RequireStorageKindSummaryByIdContext.fields:type_name -> productv1.RequireStorageKindSummaryByIdFields + 308, // 265: productv1.RequireStorageKindSummaryByIdResponse.result:type_name -> productv1.RequireStorageKindSummaryByIdResult + 0, // 266: productv1.RequireStorageKindSummaryByIdFields.storage_kind:type_name -> productv1.CategoryKind + 311, // 267: productv1.RequireStorageCategoryInfoSummaryByIdRequest.context:type_name -> productv1.RequireStorageCategoryInfoSummaryByIdContext + 31, // 268: productv1.RequireStorageCategoryInfoSummaryByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey + 314, // 269: productv1.RequireStorageCategoryInfoSummaryByIdContext.fields:type_name -> productv1.RequireStorageCategoryInfoSummaryByIdFields + 313, // 270: productv1.RequireStorageCategoryInfoSummaryByIdResponse.result:type_name -> productv1.RequireStorageCategoryInfoSummaryByIdResult + 500, // 271: productv1.RequireStorageCategoryInfoSummaryByIdFields.category_info:type_name -> productv1.RequireStorageCategoryInfoSummaryByIdFields.StorageCategoryInfo + 316, // 272: productv1.RequireStorageItemInfoByIdRequest.context:type_name -> productv1.RequireStorageItemInfoByIdContext + 31, // 273: productv1.RequireStorageItemInfoByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey + 319, // 274: productv1.RequireStorageItemInfoByIdContext.fields:type_name -> productv1.RequireStorageItemInfoByIdFields + 318, // 275: productv1.RequireStorageItemInfoByIdResponse.result:type_name -> productv1.RequireStorageItemInfoByIdResult + 503, // 276: productv1.RequireStorageItemInfoByIdFields.primary_item:type_name -> productv1.RequireStorageItemInfoByIdFields.StorageItem + 321, // 277: productv1.RequireStorageOperationReportByIdRequest.context:type_name -> productv1.RequireStorageOperationReportByIdContext + 31, // 278: productv1.RequireStorageOperationReportByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey + 324, // 279: productv1.RequireStorageOperationReportByIdContext.fields:type_name -> productv1.RequireStorageOperationReportByIdFields + 323, // 280: productv1.RequireStorageOperationReportByIdResponse.result:type_name -> productv1.RequireStorageOperationReportByIdResult + 506, // 281: productv1.RequireStorageOperationReportByIdFields.last_storage_operation:type_name -> productv1.RequireStorageOperationReportByIdFields.StorageOperationResult + 326, // 282: productv1.RequireStorageSecuritySummaryByIdRequest.context:type_name -> productv1.RequireStorageSecuritySummaryByIdContext + 31, // 283: productv1.RequireStorageSecuritySummaryByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey + 329, // 284: productv1.RequireStorageSecuritySummaryByIdContext.fields:type_name -> productv1.RequireStorageSecuritySummaryByIdFields + 328, // 285: productv1.RequireStorageSecuritySummaryByIdResponse.result:type_name -> productv1.RequireStorageSecuritySummaryByIdResult + 507, // 286: productv1.RequireStorageSecuritySummaryByIdFields.security_setup:type_name -> productv1.RequireStorageSecuritySummaryByIdFields.SecuritySetup + 331, // 287: productv1.RequireStorageItemHandlerInfoByIdRequest.context:type_name -> productv1.RequireStorageItemHandlerInfoByIdContext + 31, // 288: productv1.RequireStorageItemHandlerInfoByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey + 334, // 289: productv1.RequireStorageItemHandlerInfoByIdContext.fields:type_name -> productv1.RequireStorageItemHandlerInfoByIdFields + 333, // 290: productv1.RequireStorageItemHandlerInfoByIdResponse.result:type_name -> productv1.RequireStorageItemHandlerInfoByIdResult + 513, // 291: productv1.RequireStorageItemHandlerInfoByIdFields.primary_item:type_name -> productv1.RequireStorageItemHandlerInfoByIdFields.StorageItem + 336, // 292: productv1.RequireStorageItemSpecsInfoByIdRequest.context:type_name -> productv1.RequireStorageItemSpecsInfoByIdContext + 31, // 293: productv1.RequireStorageItemSpecsInfoByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey + 339, // 294: productv1.RequireStorageItemSpecsInfoByIdContext.fields:type_name -> productv1.RequireStorageItemSpecsInfoByIdFields + 338, // 295: productv1.RequireStorageItemSpecsInfoByIdResponse.result:type_name -> productv1.RequireStorageItemSpecsInfoByIdResult + 518, // 296: productv1.RequireStorageItemSpecsInfoByIdFields.primary_item:type_name -> productv1.RequireStorageItemSpecsInfoByIdFields.StorageItem + 341, // 297: productv1.RequireStorageDeepItemInfoByIdRequest.context:type_name -> productv1.RequireStorageDeepItemInfoByIdContext + 31, // 298: productv1.RequireStorageDeepItemInfoByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey + 344, // 299: productv1.RequireStorageDeepItemInfoByIdContext.fields:type_name -> productv1.RequireStorageDeepItemInfoByIdFields + 343, // 300: productv1.RequireStorageDeepItemInfoByIdResponse.result:type_name -> productv1.RequireStorageDeepItemInfoByIdResult + 525, // 301: productv1.RequireStorageDeepItemInfoByIdFields.primary_item:type_name -> productv1.RequireStorageDeepItemInfoByIdFields.StorageItem + 346, // 302: productv1.RequireStorageRecommendedItemByIdRequest.context:type_name -> productv1.RequireStorageRecommendedItemByIdContext + 31, // 303: productv1.RequireStorageRecommendedItemByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey + 349, // 304: productv1.RequireStorageRecommendedItemByIdContext.fields:type_name -> productv1.RequireStorageRecommendedItemByIdFields + 348, // 305: productv1.RequireStorageRecommendedItemByIdResponse.result:type_name -> productv1.RequireStorageRecommendedItemByIdResult + 450, // 306: productv1.RequireStorageRecommendedItemByIdResult.recommended_item:type_name -> productv1.StorageItem + 531, // 307: productv1.RequireStorageRecommendedItemByIdFields.metadata:type_name -> productv1.RequireStorageRecommendedItemByIdFields.StorageMetadata + 351, // 308: productv1.RequireStorageRecommendedItemsByIdRequest.context:type_name -> productv1.RequireStorageRecommendedItemsByIdContext + 31, // 309: productv1.RequireStorageRecommendedItemsByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey + 354, // 310: productv1.RequireStorageRecommendedItemsByIdContext.fields:type_name -> productv1.RequireStorageRecommendedItemsByIdFields + 353, // 311: productv1.RequireStorageRecommendedItemsByIdResponse.result:type_name -> productv1.RequireStorageRecommendedItemsByIdResult + 450, // 312: productv1.RequireStorageRecommendedItemsByIdResult.recommended_items:type_name -> productv1.StorageItem + 356, // 313: productv1.RequireStorageLatestOperationByIdRequest.context:type_name -> productv1.RequireStorageLatestOperationByIdContext + 31, // 314: productv1.RequireStorageLatestOperationByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey + 359, // 315: productv1.RequireStorageLatestOperationByIdContext.fields:type_name -> productv1.RequireStorageLatestOperationByIdFields + 358, // 316: productv1.RequireStorageLatestOperationByIdResponse.result:type_name -> productv1.RequireStorageLatestOperationByIdResult + 457, // 317: productv1.RequireStorageLatestOperationByIdResult.latest_operation:type_name -> productv1.StorageOperationResult + 0, // 318: productv1.RequireStorageLatestOperationByIdFields.storage_kind:type_name -> productv1.CategoryKind + 361, // 319: productv1.RequireStorageOptionalLatestOperationByIdRequest.context:type_name -> productv1.RequireStorageOptionalLatestOperationByIdContext + 31, // 320: productv1.RequireStorageOptionalLatestOperationByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey + 364, // 321: productv1.RequireStorageOptionalLatestOperationByIdContext.fields:type_name -> productv1.RequireStorageOptionalLatestOperationByIdFields + 363, // 322: productv1.RequireStorageOptionalLatestOperationByIdResponse.result:type_name -> productv1.RequireStorageOptionalLatestOperationByIdResult + 457, // 323: productv1.RequireStorageOptionalLatestOperationByIdResult.optional_latest_operation:type_name -> productv1.StorageOperationResult + 24, // 324: productv1.RequireStorageOptionalLatestOperationByIdFields.optional_tags:type_name -> productv1.ListOfString + 366, // 325: productv1.RequireStorageOptionalRecommendedItemsByIdRequest.context:type_name -> productv1.RequireStorageOptionalRecommendedItemsByIdContext + 31, // 326: productv1.RequireStorageOptionalRecommendedItemsByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey + 369, // 327: productv1.RequireStorageOptionalRecommendedItemsByIdContext.fields:type_name -> productv1.RequireStorageOptionalRecommendedItemsByIdFields + 368, // 328: productv1.RequireStorageOptionalRecommendedItemsByIdResponse.result:type_name -> productv1.RequireStorageOptionalRecommendedItemsByIdResult + 21, // 329: productv1.RequireStorageOptionalRecommendedItemsByIdResult.optional_recommended_items:type_name -> productv1.ListOfStorageItem + 371, // 330: productv1.RequireStorageOptionalOperationHistoryByIdRequest.context:type_name -> productv1.RequireStorageOptionalOperationHistoryByIdContext + 31, // 331: productv1.RequireStorageOptionalOperationHistoryByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey + 374, // 332: productv1.RequireStorageOptionalOperationHistoryByIdContext.fields:type_name -> productv1.RequireStorageOptionalOperationHistoryByIdFields + 373, // 333: productv1.RequireStorageOptionalOperationHistoryByIdResponse.result:type_name -> productv1.RequireStorageOptionalOperationHistoryByIdResult + 23, // 334: productv1.RequireStorageOptionalOperationHistoryByIdResult.optional_operation_history:type_name -> productv1.ListOfStorageOperationResult + 0, // 335: productv1.RequireStorageOptionalOperationHistoryByIdFields.storage_kind:type_name -> productv1.CategoryKind + 376, // 336: productv1.RequireStorageFilteredTagSummaryByIdRequest.context:type_name -> productv1.RequireStorageFilteredTagSummaryByIdContext + 377, // 337: productv1.RequireStorageFilteredTagSummaryByIdRequest.field_args:type_name -> productv1.RequireStorageFilteredTagSummaryByIdArgs + 31, // 338: productv1.RequireStorageFilteredTagSummaryByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey + 380, // 339: productv1.RequireStorageFilteredTagSummaryByIdContext.fields:type_name -> productv1.RequireStorageFilteredTagSummaryByIdFields + 379, // 340: productv1.RequireStorageFilteredTagSummaryByIdResponse.result:type_name -> productv1.RequireStorageFilteredTagSummaryByIdResult + 535, // 341: productv1.RequireStorageFilteredTagSummaryByIdResult.filtered_tag_summary:type_name -> google.protobuf.StringValue + 382, // 342: productv1.RequireStorageMultiFilteredTagSummaryByIdRequest.context:type_name -> productv1.RequireStorageMultiFilteredTagSummaryByIdContext + 383, // 343: productv1.RequireStorageMultiFilteredTagSummaryByIdRequest.field_args:type_name -> productv1.RequireStorageMultiFilteredTagSummaryByIdArgs + 31, // 344: productv1.RequireStorageMultiFilteredTagSummaryByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey + 386, // 345: productv1.RequireStorageMultiFilteredTagSummaryByIdContext.fields:type_name -> productv1.RequireStorageMultiFilteredTagSummaryByIdFields + 385, // 346: productv1.RequireStorageMultiFilteredTagSummaryByIdResponse.result:type_name -> productv1.RequireStorageMultiFilteredTagSummaryByIdResult + 535, // 347: productv1.RequireStorageMultiFilteredTagSummaryByIdResult.multi_filtered_tag_summary:type_name -> google.protobuf.StringValue + 388, // 348: productv1.RequireStorageNullableFilteredTagSummaryByIdRequest.context:type_name -> productv1.RequireStorageNullableFilteredTagSummaryByIdContext + 389, // 349: productv1.RequireStorageNullableFilteredTagSummaryByIdRequest.field_args:type_name -> productv1.RequireStorageNullableFilteredTagSummaryByIdArgs + 31, // 350: productv1.RequireStorageNullableFilteredTagSummaryByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey + 392, // 351: productv1.RequireStorageNullableFilteredTagSummaryByIdContext.fields:type_name -> productv1.RequireStorageNullableFilteredTagSummaryByIdFields + 535, // 352: productv1.RequireStorageNullableFilteredTagSummaryByIdArgs.prefix:type_name -> google.protobuf.StringValue + 391, // 353: productv1.RequireStorageNullableFilteredTagSummaryByIdResponse.result:type_name -> productv1.RequireStorageNullableFilteredTagSummaryByIdResult + 535, // 354: productv1.RequireStorageNullableFilteredTagSummaryByIdResult.nullable_filtered_tag_summary:type_name -> google.protobuf.StringValue + 394, // 355: productv1.RequireWarehouseStockHealthScoreByIdRequest.context:type_name -> productv1.RequireWarehouseStockHealthScoreByIdContext + 34, // 356: productv1.RequireWarehouseStockHealthScoreByIdContext.key:type_name -> productv1.LookupWarehouseByIdRequestKey + 397, // 357: productv1.RequireWarehouseStockHealthScoreByIdContext.fields:type_name -> productv1.RequireWarehouseStockHealthScoreByIdFields + 396, // 358: productv1.RequireWarehouseStockHealthScoreByIdResponse.result:type_name -> productv1.RequireWarehouseStockHealthScoreByIdResult + 532, // 359: productv1.RequireWarehouseStockHealthScoreByIdFields.restock_data:type_name -> productv1.RequireWarehouseStockHealthScoreByIdFields.RestockData + 434, // 360: productv1.NestedTypeA.b:type_name -> productv1.NestedTypeB + 403, // 361: productv1.RecursiveType.recursive_type:type_name -> productv1.RecursiveType + 436, // 362: productv1.ComplexFilterTypeInput.filter:type_name -> productv1.FilterType + 438, // 363: productv1.OrderInput.lines:type_name -> productv1.OrderLineInput + 18, // 364: productv1.Order.order_lines:type_name -> productv1.ListOfOrderLine + 0, // 365: productv1.Category.kind:type_name -> productv1.CategoryKind + 25, // 366: productv1.Category.subcategories:type_name -> productv1.ListOfSubcategory + 441, // 367: productv1.Category.null_metrics:type_name -> productv1.CategoryMetrics + 0, // 368: productv1.CategoryFilter.category:type_name -> productv1.CategoryKind + 437, // 369: productv1.CategoryFilter.pagination:type_name -> productv1.Pagination + 442, // 370: productv1.Animal.cat:type_name -> productv1.Cat + 443, // 371: productv1.Animal.dog:type_name -> productv1.Dog + 533, // 372: productv1.SearchInput.limit:type_name -> google.protobuf.Int32Value + 398, // 373: productv1.SearchResult.product:type_name -> productv1.Product + 401, // 374: productv1.SearchResult.user:type_name -> productv1.User + 410, // 375: productv1.SearchResult.category:type_name -> productv1.Category + 535, // 376: productv1.NullableFieldsType.optional_string:type_name -> google.protobuf.StringValue + 533, // 377: productv1.NullableFieldsType.optional_int:type_name -> google.protobuf.Int32Value + 536, // 378: productv1.NullableFieldsType.optional_float:type_name -> google.protobuf.DoubleValue + 534, // 379: productv1.NullableFieldsType.optional_boolean:type_name -> google.protobuf.BoolValue + 535, // 380: productv1.NullableFieldsFilter.name:type_name -> google.protobuf.StringValue + 535, // 381: productv1.NullableFieldsFilter.optional_string:type_name -> google.protobuf.StringValue + 534, // 382: productv1.NullableFieldsFilter.include_nulls:type_name -> google.protobuf.BoolValue + 24, // 383: productv1.BlogPost.optional_tags:type_name -> productv1.ListOfString + 24, // 384: productv1.BlogPost.keywords:type_name -> productv1.ListOfString + 11, // 385: productv1.BlogPost.ratings:type_name -> productv1.ListOfFloat + 7, // 386: productv1.BlogPost.is_published:type_name -> productv1.ListOfBoolean + 15, // 387: productv1.BlogPost.tag_groups:type_name -> productv1.ListOfListOfString + 15, // 388: productv1.BlogPost.related_topics:type_name -> productv1.ListOfListOfString + 15, // 389: productv1.BlogPost.comment_threads:type_name -> productv1.ListOfListOfString + 15, // 390: productv1.BlogPost.suggestions:type_name -> productv1.ListOfListOfString + 410, // 391: productv1.BlogPost.related_categories:type_name -> productv1.Category + 401, // 392: productv1.BlogPost.contributors:type_name -> productv1.User + 19, // 393: productv1.BlogPost.mentioned_products:type_name -> productv1.ListOfProduct + 26, // 394: productv1.BlogPost.mentioned_users:type_name -> productv1.ListOfUser + 13, // 395: productv1.BlogPost.category_groups:type_name -> productv1.ListOfListOfCategory + 16, // 396: productv1.BlogPost.contributor_teams:type_name -> productv1.ListOfListOfUser + 535, // 397: productv1.BlogPostFilter.title:type_name -> google.protobuf.StringValue + 534, // 398: productv1.BlogPostFilter.has_categories:type_name -> google.protobuf.BoolValue + 533, // 399: productv1.BlogPostFilter.min_tags:type_name -> google.protobuf.Int32Value + 535, // 400: productv1.Author.email:type_name -> google.protobuf.StringValue + 24, // 401: productv1.Author.social_links:type_name -> productv1.ListOfString + 15, // 402: productv1.Author.teams_by_project:type_name -> productv1.ListOfListOfString + 15, // 403: productv1.Author.collaborations:type_name -> productv1.ListOfListOfString + 4, // 404: productv1.Author.written_posts:type_name -> productv1.ListOfBlogPost + 410, // 405: productv1.Author.favorite_categories:type_name -> productv1.Category + 26, // 406: productv1.Author.related_authors:type_name -> productv1.ListOfUser + 19, // 407: productv1.Author.product_reviews:type_name -> productv1.ListOfProduct + 16, // 408: productv1.Author.author_groups:type_name -> productv1.ListOfListOfUser + 13, // 409: productv1.Author.category_preferences:type_name -> productv1.ListOfListOfCategory + 16, // 410: productv1.Author.project_teams:type_name -> productv1.ListOfListOfUser + 535, // 411: productv1.AuthorFilter.name:type_name -> google.protobuf.StringValue + 534, // 412: productv1.AuthorFilter.has_teams:type_name -> google.protobuf.BoolValue + 533, // 413: productv1.AuthorFilter.skill_count:type_name -> google.protobuf.Int32Value + 535, // 414: productv1.TestContainer.description:type_name -> google.protobuf.StringValue + 10, // 415: productv1.ConditionsInput.and:type_name -> productv1.ListOfConditionsInput + 10, // 416: productv1.ConditionsInput.or:type_name -> productv1.ListOfConditionsInput + 535, // 417: productv1.ConditionsInput.key:type_name -> google.protobuf.StringValue + 535, // 418: productv1.ConditionsInput.value:type_name -> google.protobuf.StringValue + 461, // 419: productv1.ActionResult.action_success:type_name -> productv1.ActionSuccess + 462, // 420: productv1.ActionResult.action_error:type_name -> productv1.ActionError + 535, // 421: productv1.NullableFieldsInput.optional_string:type_name -> google.protobuf.StringValue + 533, // 422: productv1.NullableFieldsInput.optional_int:type_name -> google.protobuf.Int32Value + 536, // 423: productv1.NullableFieldsInput.optional_float:type_name -> google.protobuf.DoubleValue + 534, // 424: productv1.NullableFieldsInput.optional_boolean:type_name -> google.protobuf.BoolValue + 24, // 425: productv1.BlogPostInput.optional_tags:type_name -> productv1.ListOfString + 24, // 426: productv1.BlogPostInput.keywords:type_name -> productv1.ListOfString + 11, // 427: productv1.BlogPostInput.ratings:type_name -> productv1.ListOfFloat + 7, // 428: productv1.BlogPostInput.is_published:type_name -> productv1.ListOfBoolean + 15, // 429: productv1.BlogPostInput.tag_groups:type_name -> productv1.ListOfListOfString + 15, // 430: productv1.BlogPostInput.related_topics:type_name -> productv1.ListOfListOfString + 15, // 431: productv1.BlogPostInput.comment_threads:type_name -> productv1.ListOfListOfString + 15, // 432: productv1.BlogPostInput.suggestions:type_name -> productv1.ListOfListOfString + 9, // 433: productv1.BlogPostInput.related_categories:type_name -> productv1.ListOfCategoryInput + 27, // 434: productv1.BlogPostInput.contributors:type_name -> productv1.ListOfUserInput + 14, // 435: productv1.BlogPostInput.category_groups:type_name -> productv1.ListOfListOfCategoryInput + 535, // 436: productv1.AuthorInput.email:type_name -> google.protobuf.StringValue + 24, // 437: productv1.AuthorInput.social_links:type_name -> productv1.ListOfString + 15, // 438: productv1.AuthorInput.teams_by_project:type_name -> productv1.ListOfListOfString + 15, // 439: productv1.AuthorInput.collaborations:type_name -> productv1.ListOfListOfString + 464, // 440: productv1.AuthorInput.favorite_categories:type_name -> productv1.CategoryInput + 17, // 441: productv1.AuthorInput.author_groups:type_name -> productv1.ListOfListOfUserInput + 17, // 442: productv1.AuthorInput.project_teams:type_name -> productv1.ListOfListOfUserInput + 426, // 443: productv1.ProductDetails.review_summary:type_name -> productv1.ActionResult + 412, // 444: productv1.ProductDetails.recommended_pet:type_name -> productv1.Animal + 0, // 445: productv1.StorageCategoryInfo.kind:type_name -> productv1.CategoryKind + 435, // 446: productv1.NestedTypeB.c:type_name -> productv1.NestedTypeC + 437, // 447: productv1.FilterType.pagination:type_name -> productv1.Pagination + 24, // 448: productv1.OrderLineInput.modifiers:type_name -> productv1.ListOfString + 24, // 449: productv1.OrderLine.modifiers:type_name -> productv1.ListOfString + 535, // 450: productv1.Subcategory.description:type_name -> google.protobuf.StringValue + 444, // 451: productv1.Cat.owner:type_name -> productv1.Owner + 447, // 452: productv1.Cat.breed:type_name -> productv1.CatBreed + 444, // 453: productv1.Dog.owner:type_name -> productv1.Owner + 448, // 454: productv1.Dog.breed:type_name -> productv1.DogBreed + 445, // 455: productv1.Owner.contact:type_name -> productv1.ContactInfo + 412, // 456: productv1.Owner.pet:type_name -> productv1.Animal + 446, // 457: productv1.ContactInfo.address:type_name -> productv1.Address + 449, // 458: productv1.CatBreed.characteristics:type_name -> productv1.BreedCharacteristics + 449, // 459: productv1.DogBreed.characteristics:type_name -> productv1.BreedCharacteristics + 451, // 460: productv1.StorageItem.pallet_item:type_name -> productv1.PalletItem + 452, // 461: productv1.StorageItem.container_item:type_name -> productv1.ContainerItem + 453, // 462: productv1.PalletItem.handler:type_name -> productv1.ItemHandler + 454, // 463: productv1.PalletItem.specs:type_name -> productv1.PalletSpecs + 453, // 464: productv1.ContainerItem.handler:type_name -> productv1.ItemHandler + 455, // 465: productv1.ContainerItem.specs:type_name -> productv1.ContainerSpecs + 450, // 466: productv1.ItemHandler.assigned_item:type_name -> productv1.StorageItem + 456, // 467: productv1.PalletSpecs.dimensions:type_name -> productv1.Dimensions + 456, // 468: productv1.ContainerSpecs.dimensions:type_name -> productv1.Dimensions + 458, // 469: productv1.StorageOperationResult.storage_success:type_name -> productv1.StorageSuccess + 459, // 470: productv1.StorageOperationResult.storage_failure:type_name -> productv1.StorageFailure + 450, // 471: productv1.SecuritySetup.primary_item:type_name -> productv1.StorageItem + 412, // 472: productv1.TestDetails.pet:type_name -> productv1.Animal + 426, // 473: productv1.TestDetails.status:type_name -> productv1.ActionResult + 0, // 474: productv1.CategoryInput.kind:type_name -> productv1.CategoryKind + 536, // 475: productv1.ProductCountFilter.min_price:type_name -> google.protobuf.DoubleValue + 536, // 476: productv1.ProductCountFilter.max_price:type_name -> google.protobuf.DoubleValue + 534, // 477: productv1.ProductCountFilter.in_stock:type_name -> google.protobuf.BoolValue + 535, // 478: productv1.ProductCountFilter.search_term:type_name -> google.protobuf.StringValue + 536, // 479: productv1.SubcategoryItemFilter.min_price:type_name -> google.protobuf.DoubleValue + 536, // 480: productv1.SubcategoryItemFilter.max_price:type_name -> google.protobuf.DoubleValue + 534, // 481: productv1.SubcategoryItemFilter.in_stock:type_name -> google.protobuf.BoolValue + 534, // 482: productv1.SubcategoryItemFilter.is_active:type_name -> google.protobuf.BoolValue + 535, // 483: productv1.SubcategoryItemFilter.search_term:type_name -> google.protobuf.StringValue + 1, // 484: productv1.ShippingEstimateInput.destination:type_name -> productv1.ShippingDestination + 534, // 485: productv1.ShippingEstimateInput.expedited:type_name -> google.protobuf.BoolValue + 420, // 486: productv1.ListOfAuthorFilter.List.items:type_name -> productv1.AuthorFilter + 429, // 487: productv1.ListOfAuthorInput.List.items:type_name -> productv1.AuthorInput + 417, // 488: productv1.ListOfBlogPost.List.items:type_name -> productv1.BlogPost + 418, // 489: productv1.ListOfBlogPostFilter.List.items:type_name -> productv1.BlogPostFilter + 428, // 490: productv1.ListOfBlogPostInput.List.items:type_name -> productv1.BlogPostInput + 410, // 491: productv1.ListOfCategory.List.items:type_name -> productv1.Category + 464, // 492: productv1.ListOfCategoryInput.List.items:type_name -> productv1.CategoryInput + 422, // 493: productv1.ListOfConditionsInput.List.items:type_name -> productv1.ConditionsInput + 8, // 494: productv1.ListOfListOfCategory.List.items:type_name -> productv1.ListOfCategory + 9, // 495: productv1.ListOfListOfCategoryInput.List.items:type_name -> productv1.ListOfCategoryInput + 24, // 496: productv1.ListOfListOfString.List.items:type_name -> productv1.ListOfString + 26, // 497: productv1.ListOfListOfUser.List.items:type_name -> productv1.ListOfUser + 27, // 498: productv1.ListOfListOfUserInput.List.items:type_name -> productv1.ListOfUserInput + 439, // 499: productv1.ListOfOrderLine.List.items:type_name -> productv1.OrderLine + 398, // 500: productv1.ListOfProduct.List.items:type_name -> productv1.Product + 399, // 501: productv1.ListOfStorage.List.items:type_name -> productv1.Storage + 450, // 502: productv1.ListOfStorageItem.List.items:type_name -> productv1.StorageItem + 432, // 503: productv1.ListOfStorageMetadata.List.items:type_name -> productv1.StorageMetadata + 457, // 504: productv1.ListOfStorageOperationResult.List.items:type_name -> productv1.StorageOperationResult + 440, // 505: productv1.ListOfSubcategory.List.items:type_name -> productv1.Subcategory + 401, // 506: productv1.ListOfUser.List.items:type_name -> productv1.User + 424, // 507: productv1.ListOfUserInput.List.items:type_name -> productv1.UserInput + 0, // 508: productv1.RequireStorageCategoryInfoSummaryByIdFields.StorageCategoryInfo.kind:type_name -> productv1.CategoryKind + 502, // 509: productv1.RequireStorageItemInfoByIdFields.StorageItem.container_item:type_name -> productv1.RequireStorageItemInfoByIdFields.ContainerItem + 501, // 510: productv1.RequireStorageItemInfoByIdFields.StorageItem.pallet_item:type_name -> productv1.RequireStorageItemInfoByIdFields.PalletItem + 505, // 511: productv1.RequireStorageOperationReportByIdFields.StorageOperationResult.storage_failure:type_name -> productv1.RequireStorageOperationReportByIdFields.StorageFailure + 504, // 512: productv1.RequireStorageOperationReportByIdFields.StorageOperationResult.storage_success:type_name -> productv1.RequireStorageOperationReportByIdFields.StorageSuccess + 510, // 513: productv1.RequireStorageSecuritySummaryByIdFields.SecuritySetup.primary_item:type_name -> productv1.RequireStorageSecuritySummaryByIdFields.SecuritySetup.StorageItem + 509, // 514: productv1.RequireStorageSecuritySummaryByIdFields.SecuritySetup.StorageItem.container_item:type_name -> productv1.RequireStorageSecuritySummaryByIdFields.SecuritySetup.ContainerItem + 508, // 515: productv1.RequireStorageSecuritySummaryByIdFields.SecuritySetup.StorageItem.pallet_item:type_name -> productv1.RequireStorageSecuritySummaryByIdFields.SecuritySetup.PalletItem + 514, // 516: productv1.RequireStorageItemHandlerInfoByIdFields.PalletItem.handler:type_name -> productv1.RequireStorageItemHandlerInfoByIdFields.PalletItem.ItemHandler + 515, // 517: productv1.RequireStorageItemHandlerInfoByIdFields.ContainerItem.handler:type_name -> productv1.RequireStorageItemHandlerInfoByIdFields.ContainerItem.ItemHandler + 512, // 518: productv1.RequireStorageItemHandlerInfoByIdFields.StorageItem.container_item:type_name -> productv1.RequireStorageItemHandlerInfoByIdFields.ContainerItem + 511, // 519: productv1.RequireStorageItemHandlerInfoByIdFields.StorageItem.pallet_item:type_name -> productv1.RequireStorageItemHandlerInfoByIdFields.PalletItem + 519, // 520: productv1.RequireStorageItemSpecsInfoByIdFields.PalletItem.specs:type_name -> productv1.RequireStorageItemSpecsInfoByIdFields.PalletItem.PalletSpecs + 521, // 521: productv1.RequireStorageItemSpecsInfoByIdFields.ContainerItem.specs:type_name -> productv1.RequireStorageItemSpecsInfoByIdFields.ContainerItem.ContainerSpecs + 517, // 522: productv1.RequireStorageItemSpecsInfoByIdFields.StorageItem.container_item:type_name -> productv1.RequireStorageItemSpecsInfoByIdFields.ContainerItem + 516, // 523: productv1.RequireStorageItemSpecsInfoByIdFields.StorageItem.pallet_item:type_name -> productv1.RequireStorageItemSpecsInfoByIdFields.PalletItem + 520, // 524: productv1.RequireStorageItemSpecsInfoByIdFields.PalletItem.PalletSpecs.dimensions:type_name -> productv1.RequireStorageItemSpecsInfoByIdFields.PalletItem.PalletSpecs.Dimensions + 522, // 525: productv1.RequireStorageItemSpecsInfoByIdFields.ContainerItem.ContainerSpecs.dimensions:type_name -> productv1.RequireStorageItemSpecsInfoByIdFields.ContainerItem.ContainerSpecs.Dimensions + 526, // 526: productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.handler:type_name -> productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.ItemHandler + 530, // 527: productv1.RequireStorageDeepItemInfoByIdFields.ContainerItem.handler:type_name -> productv1.RequireStorageDeepItemInfoByIdFields.ContainerItem.ItemHandler + 524, // 528: productv1.RequireStorageDeepItemInfoByIdFields.StorageItem.container_item:type_name -> productv1.RequireStorageDeepItemInfoByIdFields.ContainerItem + 523, // 529: productv1.RequireStorageDeepItemInfoByIdFields.StorageItem.pallet_item:type_name -> productv1.RequireStorageDeepItemInfoByIdFields.PalletItem + 529, // 530: productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.ItemHandler.assigned_item:type_name -> productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.ItemHandler.StorageItem + 527, // 531: productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.ItemHandler.StorageItem.container_item:type_name -> productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.ItemHandler.ContainerItem + 528, // 532: productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.ItemHandler.StorageItem.pallet_item:type_name -> productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.ItemHandler.PalletItem + 29, // 533: productv1.ProductService.LookupProductById:input_type -> productv1.LookupProductByIdRequest + 32, // 534: productv1.ProductService.LookupStorageById:input_type -> productv1.LookupStorageByIdRequest + 35, // 535: productv1.ProductService.LookupWarehouseById:input_type -> productv1.LookupWarehouseByIdRequest + 121, // 536: productv1.ProductService.MutationBulkCreateAuthors:input_type -> productv1.MutationBulkCreateAuthorsRequest + 125, // 537: productv1.ProductService.MutationBulkCreateBlogPosts:input_type -> productv1.MutationBulkCreateBlogPostsRequest + 123, // 538: productv1.ProductService.MutationBulkUpdateAuthors:input_type -> productv1.MutationBulkUpdateAuthorsRequest + 127, // 539: productv1.ProductService.MutationBulkUpdateBlogPosts:input_type -> productv1.MutationBulkUpdateBlogPostsRequest + 117, // 540: productv1.ProductService.MutationCreateAuthor:input_type -> productv1.MutationCreateAuthorRequest + 113, // 541: productv1.ProductService.MutationCreateBlogPost:input_type -> productv1.MutationCreateBlogPostRequest + 109, // 542: productv1.ProductService.MutationCreateNullableFieldsType:input_type -> productv1.MutationCreateNullableFieldsTypeRequest + 105, // 543: productv1.ProductService.MutationCreateUser:input_type -> productv1.MutationCreateUserRequest + 107, // 544: productv1.ProductService.MutationPerformAction:input_type -> productv1.MutationPerformActionRequest + 119, // 545: productv1.ProductService.MutationUpdateAuthor:input_type -> productv1.MutationUpdateAuthorRequest + 115, // 546: productv1.ProductService.MutationUpdateBlogPost:input_type -> productv1.MutationUpdateBlogPostRequest + 111, // 547: productv1.ProductService.MutationUpdateNullableFieldsType:input_type -> productv1.MutationUpdateNullableFieldsTypeRequest + 93, // 548: productv1.ProductService.QueryAllAuthors:input_type -> productv1.QueryAllAuthorsRequest + 85, // 549: productv1.ProductService.QueryAllBlogPosts:input_type -> productv1.QueryAllBlogPostsRequest + 77, // 550: productv1.ProductService.QueryAllNullableFieldsTypes:input_type -> productv1.QueryAllNullableFieldsTypesRequest + 65, // 551: productv1.ProductService.QueryAllPets:input_type -> productv1.QueryAllPetsRequest + 87, // 552: productv1.ProductService.QueryAuthor:input_type -> productv1.QueryAuthorRequest + 89, // 553: productv1.ProductService.QueryAuthorById:input_type -> productv1.QueryAuthorByIdRequest + 91, // 554: productv1.ProductService.QueryAuthorsWithFilter:input_type -> productv1.QueryAuthorsWithFilterRequest + 79, // 555: productv1.ProductService.QueryBlogPost:input_type -> productv1.QueryBlogPostRequest + 81, // 556: productv1.ProductService.QueryBlogPostById:input_type -> productv1.QueryBlogPostByIdRequest + 83, // 557: productv1.ProductService.QueryBlogPostsWithFilter:input_type -> productv1.QueryBlogPostsWithFilterRequest + 95, // 558: productv1.ProductService.QueryBulkSearchAuthors:input_type -> productv1.QueryBulkSearchAuthorsRequest + 97, // 559: productv1.ProductService.QueryBulkSearchBlogPosts:input_type -> productv1.QueryBulkSearchBlogPostsRequest + 51, // 560: productv1.ProductService.QueryCalculateTotals:input_type -> productv1.QueryCalculateTotalsRequest + 53, // 561: productv1.ProductService.QueryCategories:input_type -> productv1.QueryCategoriesRequest + 57, // 562: productv1.ProductService.QueryCategoriesByKind:input_type -> productv1.QueryCategoriesByKindRequest + 59, // 563: productv1.ProductService.QueryCategoriesByKinds:input_type -> productv1.QueryCategoriesByKindsRequest + 55, // 564: productv1.ProductService.QueryCategory:input_type -> productv1.QueryCategoryRequest + 49, // 565: productv1.ProductService.QueryComplexFilterType:input_type -> productv1.QueryComplexFilterTypeRequest + 103, // 566: productv1.ProductService.QueryConditionalSearch:input_type -> productv1.QueryConditionalSearchRequest + 61, // 567: productv1.ProductService.QueryFilterCategories:input_type -> productv1.QueryFilterCategoriesRequest + 41, // 568: productv1.ProductService.QueryNestedType:input_type -> productv1.QueryNestedTypeRequest + 71, // 569: productv1.ProductService.QueryNullableFieldsType:input_type -> productv1.QueryNullableFieldsTypeRequest + 73, // 570: productv1.ProductService.QueryNullableFieldsTypeById:input_type -> productv1.QueryNullableFieldsTypeByIdRequest + 75, // 571: productv1.ProductService.QueryNullableFieldsTypeWithFilter:input_type -> productv1.QueryNullableFieldsTypeWithFilterRequest + 63, // 572: productv1.ProductService.QueryRandomPet:input_type -> productv1.QueryRandomPetRequest + 69, // 573: productv1.ProductService.QueryRandomSearchResult:input_type -> productv1.QueryRandomSearchResultRequest + 43, // 574: productv1.ProductService.QueryRecursiveType:input_type -> productv1.QueryRecursiveTypeRequest + 67, // 575: productv1.ProductService.QuerySearch:input_type -> productv1.QuerySearchRequest + 99, // 576: productv1.ProductService.QueryTestContainer:input_type -> productv1.QueryTestContainerRequest + 101, // 577: productv1.ProductService.QueryTestContainers:input_type -> productv1.QueryTestContainersRequest + 45, // 578: productv1.ProductService.QueryTypeFilterWithArguments:input_type -> productv1.QueryTypeFilterWithArgumentsRequest + 47, // 579: productv1.ProductService.QueryTypeWithMultipleFilterFields:input_type -> productv1.QueryTypeWithMultipleFilterFieldsRequest + 39, // 580: productv1.ProductService.QueryUser:input_type -> productv1.QueryUserRequest + 37, // 581: productv1.ProductService.QueryUsers:input_type -> productv1.QueryUsersRequest + 310, // 582: productv1.ProductService.RequireStorageCategoryInfoSummaryById:input_type -> productv1.RequireStorageCategoryInfoSummaryByIdRequest + 340, // 583: productv1.ProductService.RequireStorageDeepItemInfoById:input_type -> productv1.RequireStorageDeepItemInfoByIdRequest + 375, // 584: productv1.ProductService.RequireStorageFilteredTagSummaryById:input_type -> productv1.RequireStorageFilteredTagSummaryByIdRequest + 330, // 585: productv1.ProductService.RequireStorageItemHandlerInfoById:input_type -> productv1.RequireStorageItemHandlerInfoByIdRequest + 315, // 586: productv1.ProductService.RequireStorageItemInfoById:input_type -> productv1.RequireStorageItemInfoByIdRequest + 335, // 587: productv1.ProductService.RequireStorageItemSpecsInfoById:input_type -> productv1.RequireStorageItemSpecsInfoByIdRequest + 305, // 588: productv1.ProductService.RequireStorageKindSummaryById:input_type -> productv1.RequireStorageKindSummaryByIdRequest + 355, // 589: productv1.ProductService.RequireStorageLatestOperationById:input_type -> productv1.RequireStorageLatestOperationByIdRequest + 264, // 590: productv1.ProductService.RequireStorageMetadataScoreById:input_type -> productv1.RequireStorageMetadataScoreByIdRequest + 381, // 591: productv1.ProductService.RequireStorageMultiFilteredTagSummaryById:input_type -> productv1.RequireStorageMultiFilteredTagSummaryByIdRequest + 387, // 592: productv1.ProductService.RequireStorageNullableFilteredTagSummaryById:input_type -> productv1.RequireStorageNullableFilteredTagSummaryByIdRequest + 320, // 593: productv1.ProductService.RequireStorageOperationReportById:input_type -> productv1.RequireStorageOperationReportByIdRequest + 360, // 594: productv1.ProductService.RequireStorageOptionalLatestOperationById:input_type -> productv1.RequireStorageOptionalLatestOperationByIdRequest + 370, // 595: productv1.ProductService.RequireStorageOptionalOperationHistoryById:input_type -> productv1.RequireStorageOptionalOperationHistoryByIdRequest + 274, // 596: productv1.ProductService.RequireStorageOptionalProcessedMetadataById:input_type -> productv1.RequireStorageOptionalProcessedMetadataByIdRequest + 294, // 597: productv1.ProductService.RequireStorageOptionalProcessedMetadataHistoryById:input_type -> productv1.RequireStorageOptionalProcessedMetadataHistoryByIdRequest + 284, // 598: productv1.ProductService.RequireStorageOptionalProcessedTagsById:input_type -> productv1.RequireStorageOptionalProcessedTagsByIdRequest + 365, // 599: productv1.ProductService.RequireStorageOptionalRecommendedItemsById:input_type -> productv1.RequireStorageOptionalRecommendedItemsByIdRequest + 259, // 600: productv1.ProductService.RequireStorageOptionalTagSummaryById:input_type -> productv1.RequireStorageOptionalTagSummaryByIdRequest + 269, // 601: productv1.ProductService.RequireStorageProcessedMetadataById:input_type -> productv1.RequireStorageProcessedMetadataByIdRequest + 289, // 602: productv1.ProductService.RequireStorageProcessedMetadataHistoryById:input_type -> productv1.RequireStorageProcessedMetadataHistoryByIdRequest + 279, // 603: productv1.ProductService.RequireStorageProcessedTagsById:input_type -> productv1.RequireStorageProcessedTagsByIdRequest + 345, // 604: productv1.ProductService.RequireStorageRecommendedItemById:input_type -> productv1.RequireStorageRecommendedItemByIdRequest + 350, // 605: productv1.ProductService.RequireStorageRecommendedItemsById:input_type -> productv1.RequireStorageRecommendedItemsByIdRequest + 325, // 606: productv1.ProductService.RequireStorageSecuritySummaryById:input_type -> productv1.RequireStorageSecuritySummaryByIdRequest + 249, // 607: productv1.ProductService.RequireStorageStockHealthScoreById:input_type -> productv1.RequireStorageStockHealthScoreByIdRequest + 254, // 608: productv1.ProductService.RequireStorageTagSummaryById:input_type -> productv1.RequireStorageTagSummaryByIdRequest + 299, // 609: productv1.ProductService.RequireStorageTagsByLengthsById:input_type -> productv1.RequireStorageTagsByLengthsByIdRequest + 393, // 610: productv1.ProductService.RequireWarehouseStockHealthScoreById:input_type -> productv1.RequireWarehouseStockHealthScoreByIdRequest + 213, // 611: productv1.ProductService.ResolveCategoryActiveSubcategories:input_type -> productv1.ResolveCategoryActiveSubcategoriesRequest + 181, // 612: productv1.ProductService.ResolveCategoryCategoryMetrics:input_type -> productv1.ResolveCategoryCategoryMetricsRequest + 191, // 613: productv1.ProductService.ResolveCategoryCategoryStatus:input_type -> productv1.ResolveCategoryCategoryStatusRequest + 196, // 614: productv1.ProductService.ResolveCategoryChildCategories:input_type -> productv1.ResolveCategoryChildCategoriesRequest + 186, // 615: productv1.ProductService.ResolveCategoryMascot:input_type -> productv1.ResolveCategoryMascotRequest + 241, // 616: productv1.ProductService.ResolveCategoryMetricsAverageScore:input_type -> productv1.ResolveCategoryMetricsAverageScoreRequest + 232, // 617: productv1.ProductService.ResolveCategoryMetricsNormalizedScore:input_type -> productv1.ResolveCategoryMetricsNormalizedScoreRequest + 237, // 618: productv1.ProductService.ResolveCategoryMetricsRelatedCategory:input_type -> productv1.ResolveCategoryMetricsRelatedCategoryRequest + 201, // 619: productv1.ProductService.ResolveCategoryOptionalCategories:input_type -> productv1.ResolveCategoryOptionalCategoriesRequest + 176, // 620: productv1.ProductService.ResolveCategoryPopularityScore:input_type -> productv1.ResolveCategoryPopularityScoreRequest + 171, // 621: productv1.ProductService.ResolveCategoryProductCount:input_type -> productv1.ResolveCategoryProductCountRequest + 209, // 622: productv1.ProductService.ResolveCategoryTopSubcategory:input_type -> productv1.ResolveCategoryTopSubcategoryRequest + 205, // 623: productv1.ProductService.ResolveCategoryTotalProducts:input_type -> productv1.ResolveCategoryTotalProductsRequest + 141, // 624: productv1.ProductService.ResolveProductMascotRecommendation:input_type -> productv1.ResolveProductMascotRecommendationRequest + 151, // 625: productv1.ProductService.ResolveProductProductDetails:input_type -> productv1.ResolveProductProductDetailsRequest + 136, // 626: productv1.ProductService.ResolveProductRecommendedCategory:input_type -> productv1.ResolveProductRecommendedCategoryRequest + 131, // 627: productv1.ProductService.ResolveProductShippingEstimate:input_type -> productv1.ResolveProductShippingEstimateRequest + 146, // 628: productv1.ProductService.ResolveProductStockStatus:input_type -> productv1.ResolveProductStockStatusRequest + 161, // 629: productv1.ProductService.ResolveStorageLinkedStorages:input_type -> productv1.ResolveStorageLinkedStoragesRequest + 166, // 630: productv1.ProductService.ResolveStorageNearbyStorages:input_type -> productv1.ResolveStorageNearbyStoragesRequest + 156, // 631: productv1.ProductService.ResolveStorageStorageStatus:input_type -> productv1.ResolveStorageStorageStatusRequest + 223, // 632: productv1.ProductService.ResolveSubcategoryFeaturedCategory:input_type -> productv1.ResolveSubcategoryFeaturedCategoryRequest + 218, // 633: productv1.ProductService.ResolveSubcategoryItemCount:input_type -> productv1.ResolveSubcategoryItemCountRequest + 227, // 634: productv1.ProductService.ResolveSubcategoryParentCategory:input_type -> productv1.ResolveSubcategoryParentCategoryRequest + 246, // 635: productv1.ProductService.ResolveTestContainerDetails:input_type -> productv1.ResolveTestContainerDetailsRequest + 30, // 636: productv1.ProductService.LookupProductById:output_type -> productv1.LookupProductByIdResponse + 33, // 637: productv1.ProductService.LookupStorageById:output_type -> productv1.LookupStorageByIdResponse + 36, // 638: productv1.ProductService.LookupWarehouseById:output_type -> productv1.LookupWarehouseByIdResponse + 122, // 639: productv1.ProductService.MutationBulkCreateAuthors:output_type -> productv1.MutationBulkCreateAuthorsResponse + 126, // 640: productv1.ProductService.MutationBulkCreateBlogPosts:output_type -> productv1.MutationBulkCreateBlogPostsResponse + 124, // 641: productv1.ProductService.MutationBulkUpdateAuthors:output_type -> productv1.MutationBulkUpdateAuthorsResponse + 128, // 642: productv1.ProductService.MutationBulkUpdateBlogPosts:output_type -> productv1.MutationBulkUpdateBlogPostsResponse + 118, // 643: productv1.ProductService.MutationCreateAuthor:output_type -> productv1.MutationCreateAuthorResponse + 114, // 644: productv1.ProductService.MutationCreateBlogPost:output_type -> productv1.MutationCreateBlogPostResponse + 110, // 645: productv1.ProductService.MutationCreateNullableFieldsType:output_type -> productv1.MutationCreateNullableFieldsTypeResponse + 106, // 646: productv1.ProductService.MutationCreateUser:output_type -> productv1.MutationCreateUserResponse + 108, // 647: productv1.ProductService.MutationPerformAction:output_type -> productv1.MutationPerformActionResponse + 120, // 648: productv1.ProductService.MutationUpdateAuthor:output_type -> productv1.MutationUpdateAuthorResponse + 116, // 649: productv1.ProductService.MutationUpdateBlogPost:output_type -> productv1.MutationUpdateBlogPostResponse + 112, // 650: productv1.ProductService.MutationUpdateNullableFieldsType:output_type -> productv1.MutationUpdateNullableFieldsTypeResponse + 94, // 651: productv1.ProductService.QueryAllAuthors:output_type -> productv1.QueryAllAuthorsResponse + 86, // 652: productv1.ProductService.QueryAllBlogPosts:output_type -> productv1.QueryAllBlogPostsResponse + 78, // 653: productv1.ProductService.QueryAllNullableFieldsTypes:output_type -> productv1.QueryAllNullableFieldsTypesResponse + 66, // 654: productv1.ProductService.QueryAllPets:output_type -> productv1.QueryAllPetsResponse + 88, // 655: productv1.ProductService.QueryAuthor:output_type -> productv1.QueryAuthorResponse + 90, // 656: productv1.ProductService.QueryAuthorById:output_type -> productv1.QueryAuthorByIdResponse + 92, // 657: productv1.ProductService.QueryAuthorsWithFilter:output_type -> productv1.QueryAuthorsWithFilterResponse + 80, // 658: productv1.ProductService.QueryBlogPost:output_type -> productv1.QueryBlogPostResponse + 82, // 659: productv1.ProductService.QueryBlogPostById:output_type -> productv1.QueryBlogPostByIdResponse + 84, // 660: productv1.ProductService.QueryBlogPostsWithFilter:output_type -> productv1.QueryBlogPostsWithFilterResponse + 96, // 661: productv1.ProductService.QueryBulkSearchAuthors:output_type -> productv1.QueryBulkSearchAuthorsResponse + 98, // 662: productv1.ProductService.QueryBulkSearchBlogPosts:output_type -> productv1.QueryBulkSearchBlogPostsResponse + 52, // 663: productv1.ProductService.QueryCalculateTotals:output_type -> productv1.QueryCalculateTotalsResponse + 54, // 664: productv1.ProductService.QueryCategories:output_type -> productv1.QueryCategoriesResponse + 58, // 665: productv1.ProductService.QueryCategoriesByKind:output_type -> productv1.QueryCategoriesByKindResponse + 60, // 666: productv1.ProductService.QueryCategoriesByKinds:output_type -> productv1.QueryCategoriesByKindsResponse + 56, // 667: productv1.ProductService.QueryCategory:output_type -> productv1.QueryCategoryResponse + 50, // 668: productv1.ProductService.QueryComplexFilterType:output_type -> productv1.QueryComplexFilterTypeResponse + 104, // 669: productv1.ProductService.QueryConditionalSearch:output_type -> productv1.QueryConditionalSearchResponse + 62, // 670: productv1.ProductService.QueryFilterCategories:output_type -> productv1.QueryFilterCategoriesResponse + 42, // 671: productv1.ProductService.QueryNestedType:output_type -> productv1.QueryNestedTypeResponse + 72, // 672: productv1.ProductService.QueryNullableFieldsType:output_type -> productv1.QueryNullableFieldsTypeResponse + 74, // 673: productv1.ProductService.QueryNullableFieldsTypeById:output_type -> productv1.QueryNullableFieldsTypeByIdResponse + 76, // 674: productv1.ProductService.QueryNullableFieldsTypeWithFilter:output_type -> productv1.QueryNullableFieldsTypeWithFilterResponse + 64, // 675: productv1.ProductService.QueryRandomPet:output_type -> productv1.QueryRandomPetResponse + 70, // 676: productv1.ProductService.QueryRandomSearchResult:output_type -> productv1.QueryRandomSearchResultResponse + 44, // 677: productv1.ProductService.QueryRecursiveType:output_type -> productv1.QueryRecursiveTypeResponse + 68, // 678: productv1.ProductService.QuerySearch:output_type -> productv1.QuerySearchResponse + 100, // 679: productv1.ProductService.QueryTestContainer:output_type -> productv1.QueryTestContainerResponse + 102, // 680: productv1.ProductService.QueryTestContainers:output_type -> productv1.QueryTestContainersResponse + 46, // 681: productv1.ProductService.QueryTypeFilterWithArguments:output_type -> productv1.QueryTypeFilterWithArgumentsResponse + 48, // 682: productv1.ProductService.QueryTypeWithMultipleFilterFields:output_type -> productv1.QueryTypeWithMultipleFilterFieldsResponse + 40, // 683: productv1.ProductService.QueryUser:output_type -> productv1.QueryUserResponse + 38, // 684: productv1.ProductService.QueryUsers:output_type -> productv1.QueryUsersResponse + 312, // 685: productv1.ProductService.RequireStorageCategoryInfoSummaryById:output_type -> productv1.RequireStorageCategoryInfoSummaryByIdResponse + 342, // 686: productv1.ProductService.RequireStorageDeepItemInfoById:output_type -> productv1.RequireStorageDeepItemInfoByIdResponse + 378, // 687: productv1.ProductService.RequireStorageFilteredTagSummaryById:output_type -> productv1.RequireStorageFilteredTagSummaryByIdResponse + 332, // 688: productv1.ProductService.RequireStorageItemHandlerInfoById:output_type -> productv1.RequireStorageItemHandlerInfoByIdResponse + 317, // 689: productv1.ProductService.RequireStorageItemInfoById:output_type -> productv1.RequireStorageItemInfoByIdResponse + 337, // 690: productv1.ProductService.RequireStorageItemSpecsInfoById:output_type -> productv1.RequireStorageItemSpecsInfoByIdResponse + 307, // 691: productv1.ProductService.RequireStorageKindSummaryById:output_type -> productv1.RequireStorageKindSummaryByIdResponse + 357, // 692: productv1.ProductService.RequireStorageLatestOperationById:output_type -> productv1.RequireStorageLatestOperationByIdResponse + 266, // 693: productv1.ProductService.RequireStorageMetadataScoreById:output_type -> productv1.RequireStorageMetadataScoreByIdResponse + 384, // 694: productv1.ProductService.RequireStorageMultiFilteredTagSummaryById:output_type -> productv1.RequireStorageMultiFilteredTagSummaryByIdResponse + 390, // 695: productv1.ProductService.RequireStorageNullableFilteredTagSummaryById:output_type -> productv1.RequireStorageNullableFilteredTagSummaryByIdResponse + 322, // 696: productv1.ProductService.RequireStorageOperationReportById:output_type -> productv1.RequireStorageOperationReportByIdResponse + 362, // 697: productv1.ProductService.RequireStorageOptionalLatestOperationById:output_type -> productv1.RequireStorageOptionalLatestOperationByIdResponse + 372, // 698: productv1.ProductService.RequireStorageOptionalOperationHistoryById:output_type -> productv1.RequireStorageOptionalOperationHistoryByIdResponse + 276, // 699: productv1.ProductService.RequireStorageOptionalProcessedMetadataById:output_type -> productv1.RequireStorageOptionalProcessedMetadataByIdResponse + 296, // 700: productv1.ProductService.RequireStorageOptionalProcessedMetadataHistoryById:output_type -> productv1.RequireStorageOptionalProcessedMetadataHistoryByIdResponse + 286, // 701: productv1.ProductService.RequireStorageOptionalProcessedTagsById:output_type -> productv1.RequireStorageOptionalProcessedTagsByIdResponse + 367, // 702: productv1.ProductService.RequireStorageOptionalRecommendedItemsById:output_type -> productv1.RequireStorageOptionalRecommendedItemsByIdResponse + 261, // 703: productv1.ProductService.RequireStorageOptionalTagSummaryById:output_type -> productv1.RequireStorageOptionalTagSummaryByIdResponse + 271, // 704: productv1.ProductService.RequireStorageProcessedMetadataById:output_type -> productv1.RequireStorageProcessedMetadataByIdResponse + 291, // 705: productv1.ProductService.RequireStorageProcessedMetadataHistoryById:output_type -> productv1.RequireStorageProcessedMetadataHistoryByIdResponse + 281, // 706: productv1.ProductService.RequireStorageProcessedTagsById:output_type -> productv1.RequireStorageProcessedTagsByIdResponse + 347, // 707: productv1.ProductService.RequireStorageRecommendedItemById:output_type -> productv1.RequireStorageRecommendedItemByIdResponse + 352, // 708: productv1.ProductService.RequireStorageRecommendedItemsById:output_type -> productv1.RequireStorageRecommendedItemsByIdResponse + 327, // 709: productv1.ProductService.RequireStorageSecuritySummaryById:output_type -> productv1.RequireStorageSecuritySummaryByIdResponse + 251, // 710: productv1.ProductService.RequireStorageStockHealthScoreById:output_type -> productv1.RequireStorageStockHealthScoreByIdResponse + 256, // 711: productv1.ProductService.RequireStorageTagSummaryById:output_type -> productv1.RequireStorageTagSummaryByIdResponse + 302, // 712: productv1.ProductService.RequireStorageTagsByLengthsById:output_type -> productv1.RequireStorageTagsByLengthsByIdResponse + 395, // 713: productv1.ProductService.RequireWarehouseStockHealthScoreById:output_type -> productv1.RequireWarehouseStockHealthScoreByIdResponse + 215, // 714: productv1.ProductService.ResolveCategoryActiveSubcategories:output_type -> productv1.ResolveCategoryActiveSubcategoriesResponse + 183, // 715: productv1.ProductService.ResolveCategoryCategoryMetrics:output_type -> productv1.ResolveCategoryCategoryMetricsResponse + 193, // 716: productv1.ProductService.ResolveCategoryCategoryStatus:output_type -> productv1.ResolveCategoryCategoryStatusResponse + 198, // 717: productv1.ProductService.ResolveCategoryChildCategories:output_type -> productv1.ResolveCategoryChildCategoriesResponse + 188, // 718: productv1.ProductService.ResolveCategoryMascot:output_type -> productv1.ResolveCategoryMascotResponse + 243, // 719: productv1.ProductService.ResolveCategoryMetricsAverageScore:output_type -> productv1.ResolveCategoryMetricsAverageScoreResponse + 234, // 720: productv1.ProductService.ResolveCategoryMetricsNormalizedScore:output_type -> productv1.ResolveCategoryMetricsNormalizedScoreResponse + 239, // 721: productv1.ProductService.ResolveCategoryMetricsRelatedCategory:output_type -> productv1.ResolveCategoryMetricsRelatedCategoryResponse + 203, // 722: productv1.ProductService.ResolveCategoryOptionalCategories:output_type -> productv1.ResolveCategoryOptionalCategoriesResponse + 178, // 723: productv1.ProductService.ResolveCategoryPopularityScore:output_type -> productv1.ResolveCategoryPopularityScoreResponse + 173, // 724: productv1.ProductService.ResolveCategoryProductCount:output_type -> productv1.ResolveCategoryProductCountResponse + 211, // 725: productv1.ProductService.ResolveCategoryTopSubcategory:output_type -> productv1.ResolveCategoryTopSubcategoryResponse + 207, // 726: productv1.ProductService.ResolveCategoryTotalProducts:output_type -> productv1.ResolveCategoryTotalProductsResponse + 143, // 727: productv1.ProductService.ResolveProductMascotRecommendation:output_type -> productv1.ResolveProductMascotRecommendationResponse + 153, // 728: productv1.ProductService.ResolveProductProductDetails:output_type -> productv1.ResolveProductProductDetailsResponse + 138, // 729: productv1.ProductService.ResolveProductRecommendedCategory:output_type -> productv1.ResolveProductRecommendedCategoryResponse + 133, // 730: productv1.ProductService.ResolveProductShippingEstimate:output_type -> productv1.ResolveProductShippingEstimateResponse + 148, // 731: productv1.ProductService.ResolveProductStockStatus:output_type -> productv1.ResolveProductStockStatusResponse + 163, // 732: productv1.ProductService.ResolveStorageLinkedStorages:output_type -> productv1.ResolveStorageLinkedStoragesResponse + 168, // 733: productv1.ProductService.ResolveStorageNearbyStorages:output_type -> productv1.ResolveStorageNearbyStoragesResponse + 158, // 734: productv1.ProductService.ResolveStorageStorageStatus:output_type -> productv1.ResolveStorageStorageStatusResponse + 225, // 735: productv1.ProductService.ResolveSubcategoryFeaturedCategory:output_type -> productv1.ResolveSubcategoryFeaturedCategoryResponse + 220, // 736: productv1.ProductService.ResolveSubcategoryItemCount:output_type -> productv1.ResolveSubcategoryItemCountResponse + 229, // 737: productv1.ProductService.ResolveSubcategoryParentCategory:output_type -> productv1.ResolveSubcategoryParentCategoryResponse + 248, // 738: productv1.ProductService.ResolveTestContainerDetails:output_type -> productv1.ResolveTestContainerDetailsResponse + 636, // [636:739] is the sub-list for method output_type + 533, // [533:636] is the sub-list for method input_type + 533, // [533:533] is the sub-list for extension type_name + 533, // [533:533] is the sub-list for extension extendee + 0, // [0:533] is the sub-list for field type_name } func init() { file_product_proto_init() } @@ -27948,52 +29464,52 @@ func file_product_proto_init() { if File_product_proto != nil { return } - file_product_proto_msgTypes[385].OneofWrappers = []any{ + file_product_proto_msgTypes[410].OneofWrappers = []any{ (*Animal_Cat)(nil), (*Animal_Dog)(nil), } - file_product_proto_msgTypes[387].OneofWrappers = []any{ + file_product_proto_msgTypes[412].OneofWrappers = []any{ (*SearchResult_Product)(nil), (*SearchResult_User)(nil), (*SearchResult_Category)(nil), } - file_product_proto_msgTypes[399].OneofWrappers = []any{ + file_product_proto_msgTypes[424].OneofWrappers = []any{ (*ActionResult_ActionSuccess)(nil), (*ActionResult_ActionError)(nil), } - file_product_proto_msgTypes[423].OneofWrappers = []any{ + file_product_proto_msgTypes[448].OneofWrappers = []any{ (*StorageItem_PalletItem)(nil), (*StorageItem_ContainerItem)(nil), } - file_product_proto_msgTypes[430].OneofWrappers = []any{ + file_product_proto_msgTypes[455].OneofWrappers = []any{ (*StorageOperationResult_StorageSuccess)(nil), (*StorageOperationResult_StorageFailure)(nil), } - file_product_proto_msgTypes[471].OneofWrappers = []any{ + file_product_proto_msgTypes[501].OneofWrappers = []any{ (*RequireStorageItemInfoByIdFields_StorageItem_ContainerItem)(nil), (*RequireStorageItemInfoByIdFields_StorageItem_PalletItem)(nil), } - file_product_proto_msgTypes[474].OneofWrappers = []any{ + file_product_proto_msgTypes[504].OneofWrappers = []any{ (*RequireStorageOperationReportByIdFields_StorageOperationResult_StorageFailure)(nil), (*RequireStorageOperationReportByIdFields_StorageOperationResult_StorageSuccess)(nil), } - file_product_proto_msgTypes[478].OneofWrappers = []any{ + file_product_proto_msgTypes[508].OneofWrappers = []any{ (*RequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem_ContainerItem)(nil), (*RequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem_PalletItem)(nil), } - file_product_proto_msgTypes[481].OneofWrappers = []any{ + file_product_proto_msgTypes[511].OneofWrappers = []any{ (*RequireStorageItemHandlerInfoByIdFields_StorageItem_ContainerItem)(nil), (*RequireStorageItemHandlerInfoByIdFields_StorageItem_PalletItem)(nil), } - file_product_proto_msgTypes[486].OneofWrappers = []any{ + file_product_proto_msgTypes[516].OneofWrappers = []any{ (*RequireStorageItemSpecsInfoByIdFields_StorageItem_ContainerItem)(nil), (*RequireStorageItemSpecsInfoByIdFields_StorageItem_PalletItem)(nil), } - file_product_proto_msgTypes[493].OneofWrappers = []any{ + file_product_proto_msgTypes[523].OneofWrappers = []any{ (*RequireStorageDeepItemInfoByIdFields_StorageItem_ContainerItem)(nil), (*RequireStorageDeepItemInfoByIdFields_StorageItem_PalletItem)(nil), } - file_product_proto_msgTypes[497].OneofWrappers = []any{ + file_product_proto_msgTypes[527].OneofWrappers = []any{ (*RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem_ContainerItem)(nil), (*RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem_PalletItem)(nil), } @@ -28003,7 +29519,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: 501, + NumMessages: 531, 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 54928947db..5b9a48b9e9 100644 --- a/v2/pkg/grpctest/productv1/product_grpc.pb.go +++ b/v2/pkg/grpctest/productv1/product_grpc.pb.go @@ -19,105 +19,109 @@ import ( const _ = grpc.SupportPackageIsVersion9 const ( - ProductService_LookupProductById_FullMethodName = "/productv1.ProductService/LookupProductById" - ProductService_LookupStorageById_FullMethodName = "/productv1.ProductService/LookupStorageById" - ProductService_LookupWarehouseById_FullMethodName = "/productv1.ProductService/LookupWarehouseById" - ProductService_MutationBulkCreateAuthors_FullMethodName = "/productv1.ProductService/MutationBulkCreateAuthors" - ProductService_MutationBulkCreateBlogPosts_FullMethodName = "/productv1.ProductService/MutationBulkCreateBlogPosts" - ProductService_MutationBulkUpdateAuthors_FullMethodName = "/productv1.ProductService/MutationBulkUpdateAuthors" - ProductService_MutationBulkUpdateBlogPosts_FullMethodName = "/productv1.ProductService/MutationBulkUpdateBlogPosts" - ProductService_MutationCreateAuthor_FullMethodName = "/productv1.ProductService/MutationCreateAuthor" - ProductService_MutationCreateBlogPost_FullMethodName = "/productv1.ProductService/MutationCreateBlogPost" - ProductService_MutationCreateNullableFieldsType_FullMethodName = "/productv1.ProductService/MutationCreateNullableFieldsType" - ProductService_MutationCreateUser_FullMethodName = "/productv1.ProductService/MutationCreateUser" - ProductService_MutationPerformAction_FullMethodName = "/productv1.ProductService/MutationPerformAction" - ProductService_MutationUpdateAuthor_FullMethodName = "/productv1.ProductService/MutationUpdateAuthor" - ProductService_MutationUpdateBlogPost_FullMethodName = "/productv1.ProductService/MutationUpdateBlogPost" - ProductService_MutationUpdateNullableFieldsType_FullMethodName = "/productv1.ProductService/MutationUpdateNullableFieldsType" - ProductService_QueryAllAuthors_FullMethodName = "/productv1.ProductService/QueryAllAuthors" - ProductService_QueryAllBlogPosts_FullMethodName = "/productv1.ProductService/QueryAllBlogPosts" - ProductService_QueryAllNullableFieldsTypes_FullMethodName = "/productv1.ProductService/QueryAllNullableFieldsTypes" - ProductService_QueryAllPets_FullMethodName = "/productv1.ProductService/QueryAllPets" - ProductService_QueryAuthor_FullMethodName = "/productv1.ProductService/QueryAuthor" - ProductService_QueryAuthorById_FullMethodName = "/productv1.ProductService/QueryAuthorById" - ProductService_QueryAuthorsWithFilter_FullMethodName = "/productv1.ProductService/QueryAuthorsWithFilter" - ProductService_QueryBlogPost_FullMethodName = "/productv1.ProductService/QueryBlogPost" - ProductService_QueryBlogPostById_FullMethodName = "/productv1.ProductService/QueryBlogPostById" - ProductService_QueryBlogPostsWithFilter_FullMethodName = "/productv1.ProductService/QueryBlogPostsWithFilter" - ProductService_QueryBulkSearchAuthors_FullMethodName = "/productv1.ProductService/QueryBulkSearchAuthors" - ProductService_QueryBulkSearchBlogPosts_FullMethodName = "/productv1.ProductService/QueryBulkSearchBlogPosts" - ProductService_QueryCalculateTotals_FullMethodName = "/productv1.ProductService/QueryCalculateTotals" - ProductService_QueryCategories_FullMethodName = "/productv1.ProductService/QueryCategories" - ProductService_QueryCategoriesByKind_FullMethodName = "/productv1.ProductService/QueryCategoriesByKind" - ProductService_QueryCategoriesByKinds_FullMethodName = "/productv1.ProductService/QueryCategoriesByKinds" - ProductService_QueryCategory_FullMethodName = "/productv1.ProductService/QueryCategory" - ProductService_QueryComplexFilterType_FullMethodName = "/productv1.ProductService/QueryComplexFilterType" - ProductService_QueryConditionalSearch_FullMethodName = "/productv1.ProductService/QueryConditionalSearch" - ProductService_QueryFilterCategories_FullMethodName = "/productv1.ProductService/QueryFilterCategories" - ProductService_QueryNestedType_FullMethodName = "/productv1.ProductService/QueryNestedType" - ProductService_QueryNullableFieldsType_FullMethodName = "/productv1.ProductService/QueryNullableFieldsType" - ProductService_QueryNullableFieldsTypeById_FullMethodName = "/productv1.ProductService/QueryNullableFieldsTypeById" - ProductService_QueryNullableFieldsTypeWithFilter_FullMethodName = "/productv1.ProductService/QueryNullableFieldsTypeWithFilter" - ProductService_QueryRandomPet_FullMethodName = "/productv1.ProductService/QueryRandomPet" - ProductService_QueryRandomSearchResult_FullMethodName = "/productv1.ProductService/QueryRandomSearchResult" - ProductService_QueryRecursiveType_FullMethodName = "/productv1.ProductService/QueryRecursiveType" - ProductService_QuerySearch_FullMethodName = "/productv1.ProductService/QuerySearch" - ProductService_QueryTestContainer_FullMethodName = "/productv1.ProductService/QueryTestContainer" - ProductService_QueryTestContainers_FullMethodName = "/productv1.ProductService/QueryTestContainers" - ProductService_QueryTypeFilterWithArguments_FullMethodName = "/productv1.ProductService/QueryTypeFilterWithArguments" - ProductService_QueryTypeWithMultipleFilterFields_FullMethodName = "/productv1.ProductService/QueryTypeWithMultipleFilterFields" - ProductService_QueryUser_FullMethodName = "/productv1.ProductService/QueryUser" - ProductService_QueryUsers_FullMethodName = "/productv1.ProductService/QueryUsers" - ProductService_RequireStorageCategoryInfoSummaryById_FullMethodName = "/productv1.ProductService/RequireStorageCategoryInfoSummaryById" - ProductService_RequireStorageDeepItemInfoById_FullMethodName = "/productv1.ProductService/RequireStorageDeepItemInfoById" - ProductService_RequireStorageFilteredTagSummaryById_FullMethodName = "/productv1.ProductService/RequireStorageFilteredTagSummaryById" - ProductService_RequireStorageItemHandlerInfoById_FullMethodName = "/productv1.ProductService/RequireStorageItemHandlerInfoById" - ProductService_RequireStorageItemInfoById_FullMethodName = "/productv1.ProductService/RequireStorageItemInfoById" - ProductService_RequireStorageItemSpecsInfoById_FullMethodName = "/productv1.ProductService/RequireStorageItemSpecsInfoById" - ProductService_RequireStorageKindSummaryById_FullMethodName = "/productv1.ProductService/RequireStorageKindSummaryById" - ProductService_RequireStorageLatestOperationById_FullMethodName = "/productv1.ProductService/RequireStorageLatestOperationById" - ProductService_RequireStorageMetadataScoreById_FullMethodName = "/productv1.ProductService/RequireStorageMetadataScoreById" - ProductService_RequireStorageMultiFilteredTagSummaryById_FullMethodName = "/productv1.ProductService/RequireStorageMultiFilteredTagSummaryById" - ProductService_RequireStorageNullableFilteredTagSummaryById_FullMethodName = "/productv1.ProductService/RequireStorageNullableFilteredTagSummaryById" - ProductService_RequireStorageOperationReportById_FullMethodName = "/productv1.ProductService/RequireStorageOperationReportById" - ProductService_RequireStorageOptionalLatestOperationById_FullMethodName = "/productv1.ProductService/RequireStorageOptionalLatestOperationById" - ProductService_RequireStorageOptionalProcessedMetadataById_FullMethodName = "/productv1.ProductService/RequireStorageOptionalProcessedMetadataById" - ProductService_RequireStorageOptionalProcessedTagsById_FullMethodName = "/productv1.ProductService/RequireStorageOptionalProcessedTagsById" - ProductService_RequireStorageOptionalTagSummaryById_FullMethodName = "/productv1.ProductService/RequireStorageOptionalTagSummaryById" - ProductService_RequireStorageProcessedMetadataById_FullMethodName = "/productv1.ProductService/RequireStorageProcessedMetadataById" - ProductService_RequireStorageProcessedMetadataHistoryById_FullMethodName = "/productv1.ProductService/RequireStorageProcessedMetadataHistoryById" - ProductService_RequireStorageProcessedTagsById_FullMethodName = "/productv1.ProductService/RequireStorageProcessedTagsById" - ProductService_RequireStorageRecommendedItemById_FullMethodName = "/productv1.ProductService/RequireStorageRecommendedItemById" - ProductService_RequireStorageRecommendedItemsById_FullMethodName = "/productv1.ProductService/RequireStorageRecommendedItemsById" - ProductService_RequireStorageSecuritySummaryById_FullMethodName = "/productv1.ProductService/RequireStorageSecuritySummaryById" - 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" - ProductService_ResolveProductShippingEstimate_FullMethodName = "/productv1.ProductService/ResolveProductShippingEstimate" - ProductService_ResolveProductStockStatus_FullMethodName = "/productv1.ProductService/ResolveProductStockStatus" - ProductService_ResolveStorageLinkedStorages_FullMethodName = "/productv1.ProductService/ResolveStorageLinkedStorages" - ProductService_ResolveStorageNearbyStorages_FullMethodName = "/productv1.ProductService/ResolveStorageNearbyStorages" - ProductService_ResolveStorageStorageStatus_FullMethodName = "/productv1.ProductService/ResolveStorageStorageStatus" - ProductService_ResolveSubcategoryFeaturedCategory_FullMethodName = "/productv1.ProductService/ResolveSubcategoryFeaturedCategory" - ProductService_ResolveSubcategoryItemCount_FullMethodName = "/productv1.ProductService/ResolveSubcategoryItemCount" - ProductService_ResolveSubcategoryParentCategory_FullMethodName = "/productv1.ProductService/ResolveSubcategoryParentCategory" - ProductService_ResolveTestContainerDetails_FullMethodName = "/productv1.ProductService/ResolveTestContainerDetails" + ProductService_LookupProductById_FullMethodName = "/productv1.ProductService/LookupProductById" + ProductService_LookupStorageById_FullMethodName = "/productv1.ProductService/LookupStorageById" + ProductService_LookupWarehouseById_FullMethodName = "/productv1.ProductService/LookupWarehouseById" + ProductService_MutationBulkCreateAuthors_FullMethodName = "/productv1.ProductService/MutationBulkCreateAuthors" + ProductService_MutationBulkCreateBlogPosts_FullMethodName = "/productv1.ProductService/MutationBulkCreateBlogPosts" + ProductService_MutationBulkUpdateAuthors_FullMethodName = "/productv1.ProductService/MutationBulkUpdateAuthors" + ProductService_MutationBulkUpdateBlogPosts_FullMethodName = "/productv1.ProductService/MutationBulkUpdateBlogPosts" + ProductService_MutationCreateAuthor_FullMethodName = "/productv1.ProductService/MutationCreateAuthor" + ProductService_MutationCreateBlogPost_FullMethodName = "/productv1.ProductService/MutationCreateBlogPost" + ProductService_MutationCreateNullableFieldsType_FullMethodName = "/productv1.ProductService/MutationCreateNullableFieldsType" + ProductService_MutationCreateUser_FullMethodName = "/productv1.ProductService/MutationCreateUser" + ProductService_MutationPerformAction_FullMethodName = "/productv1.ProductService/MutationPerformAction" + ProductService_MutationUpdateAuthor_FullMethodName = "/productv1.ProductService/MutationUpdateAuthor" + ProductService_MutationUpdateBlogPost_FullMethodName = "/productv1.ProductService/MutationUpdateBlogPost" + ProductService_MutationUpdateNullableFieldsType_FullMethodName = "/productv1.ProductService/MutationUpdateNullableFieldsType" + ProductService_QueryAllAuthors_FullMethodName = "/productv1.ProductService/QueryAllAuthors" + ProductService_QueryAllBlogPosts_FullMethodName = "/productv1.ProductService/QueryAllBlogPosts" + ProductService_QueryAllNullableFieldsTypes_FullMethodName = "/productv1.ProductService/QueryAllNullableFieldsTypes" + ProductService_QueryAllPets_FullMethodName = "/productv1.ProductService/QueryAllPets" + ProductService_QueryAuthor_FullMethodName = "/productv1.ProductService/QueryAuthor" + ProductService_QueryAuthorById_FullMethodName = "/productv1.ProductService/QueryAuthorById" + ProductService_QueryAuthorsWithFilter_FullMethodName = "/productv1.ProductService/QueryAuthorsWithFilter" + ProductService_QueryBlogPost_FullMethodName = "/productv1.ProductService/QueryBlogPost" + ProductService_QueryBlogPostById_FullMethodName = "/productv1.ProductService/QueryBlogPostById" + ProductService_QueryBlogPostsWithFilter_FullMethodName = "/productv1.ProductService/QueryBlogPostsWithFilter" + ProductService_QueryBulkSearchAuthors_FullMethodName = "/productv1.ProductService/QueryBulkSearchAuthors" + ProductService_QueryBulkSearchBlogPosts_FullMethodName = "/productv1.ProductService/QueryBulkSearchBlogPosts" + ProductService_QueryCalculateTotals_FullMethodName = "/productv1.ProductService/QueryCalculateTotals" + ProductService_QueryCategories_FullMethodName = "/productv1.ProductService/QueryCategories" + ProductService_QueryCategoriesByKind_FullMethodName = "/productv1.ProductService/QueryCategoriesByKind" + ProductService_QueryCategoriesByKinds_FullMethodName = "/productv1.ProductService/QueryCategoriesByKinds" + ProductService_QueryCategory_FullMethodName = "/productv1.ProductService/QueryCategory" + ProductService_QueryComplexFilterType_FullMethodName = "/productv1.ProductService/QueryComplexFilterType" + ProductService_QueryConditionalSearch_FullMethodName = "/productv1.ProductService/QueryConditionalSearch" + ProductService_QueryFilterCategories_FullMethodName = "/productv1.ProductService/QueryFilterCategories" + ProductService_QueryNestedType_FullMethodName = "/productv1.ProductService/QueryNestedType" + ProductService_QueryNullableFieldsType_FullMethodName = "/productv1.ProductService/QueryNullableFieldsType" + ProductService_QueryNullableFieldsTypeById_FullMethodName = "/productv1.ProductService/QueryNullableFieldsTypeById" + ProductService_QueryNullableFieldsTypeWithFilter_FullMethodName = "/productv1.ProductService/QueryNullableFieldsTypeWithFilter" + ProductService_QueryRandomPet_FullMethodName = "/productv1.ProductService/QueryRandomPet" + ProductService_QueryRandomSearchResult_FullMethodName = "/productv1.ProductService/QueryRandomSearchResult" + ProductService_QueryRecursiveType_FullMethodName = "/productv1.ProductService/QueryRecursiveType" + ProductService_QuerySearch_FullMethodName = "/productv1.ProductService/QuerySearch" + ProductService_QueryTestContainer_FullMethodName = "/productv1.ProductService/QueryTestContainer" + ProductService_QueryTestContainers_FullMethodName = "/productv1.ProductService/QueryTestContainers" + ProductService_QueryTypeFilterWithArguments_FullMethodName = "/productv1.ProductService/QueryTypeFilterWithArguments" + ProductService_QueryTypeWithMultipleFilterFields_FullMethodName = "/productv1.ProductService/QueryTypeWithMultipleFilterFields" + ProductService_QueryUser_FullMethodName = "/productv1.ProductService/QueryUser" + ProductService_QueryUsers_FullMethodName = "/productv1.ProductService/QueryUsers" + ProductService_RequireStorageCategoryInfoSummaryById_FullMethodName = "/productv1.ProductService/RequireStorageCategoryInfoSummaryById" + ProductService_RequireStorageDeepItemInfoById_FullMethodName = "/productv1.ProductService/RequireStorageDeepItemInfoById" + ProductService_RequireStorageFilteredTagSummaryById_FullMethodName = "/productv1.ProductService/RequireStorageFilteredTagSummaryById" + ProductService_RequireStorageItemHandlerInfoById_FullMethodName = "/productv1.ProductService/RequireStorageItemHandlerInfoById" + ProductService_RequireStorageItemInfoById_FullMethodName = "/productv1.ProductService/RequireStorageItemInfoById" + ProductService_RequireStorageItemSpecsInfoById_FullMethodName = "/productv1.ProductService/RequireStorageItemSpecsInfoById" + ProductService_RequireStorageKindSummaryById_FullMethodName = "/productv1.ProductService/RequireStorageKindSummaryById" + ProductService_RequireStorageLatestOperationById_FullMethodName = "/productv1.ProductService/RequireStorageLatestOperationById" + ProductService_RequireStorageMetadataScoreById_FullMethodName = "/productv1.ProductService/RequireStorageMetadataScoreById" + ProductService_RequireStorageMultiFilteredTagSummaryById_FullMethodName = "/productv1.ProductService/RequireStorageMultiFilteredTagSummaryById" + ProductService_RequireStorageNullableFilteredTagSummaryById_FullMethodName = "/productv1.ProductService/RequireStorageNullableFilteredTagSummaryById" + ProductService_RequireStorageOperationReportById_FullMethodName = "/productv1.ProductService/RequireStorageOperationReportById" + ProductService_RequireStorageOptionalLatestOperationById_FullMethodName = "/productv1.ProductService/RequireStorageOptionalLatestOperationById" + ProductService_RequireStorageOptionalOperationHistoryById_FullMethodName = "/productv1.ProductService/RequireStorageOptionalOperationHistoryById" + ProductService_RequireStorageOptionalProcessedMetadataById_FullMethodName = "/productv1.ProductService/RequireStorageOptionalProcessedMetadataById" + ProductService_RequireStorageOptionalProcessedMetadataHistoryById_FullMethodName = "/productv1.ProductService/RequireStorageOptionalProcessedMetadataHistoryById" + ProductService_RequireStorageOptionalProcessedTagsById_FullMethodName = "/productv1.ProductService/RequireStorageOptionalProcessedTagsById" + ProductService_RequireStorageOptionalRecommendedItemsById_FullMethodName = "/productv1.ProductService/RequireStorageOptionalRecommendedItemsById" + ProductService_RequireStorageOptionalTagSummaryById_FullMethodName = "/productv1.ProductService/RequireStorageOptionalTagSummaryById" + ProductService_RequireStorageProcessedMetadataById_FullMethodName = "/productv1.ProductService/RequireStorageProcessedMetadataById" + ProductService_RequireStorageProcessedMetadataHistoryById_FullMethodName = "/productv1.ProductService/RequireStorageProcessedMetadataHistoryById" + ProductService_RequireStorageProcessedTagsById_FullMethodName = "/productv1.ProductService/RequireStorageProcessedTagsById" + ProductService_RequireStorageRecommendedItemById_FullMethodName = "/productv1.ProductService/RequireStorageRecommendedItemById" + ProductService_RequireStorageRecommendedItemsById_FullMethodName = "/productv1.ProductService/RequireStorageRecommendedItemsById" + ProductService_RequireStorageSecuritySummaryById_FullMethodName = "/productv1.ProductService/RequireStorageSecuritySummaryById" + ProductService_RequireStorageStockHealthScoreById_FullMethodName = "/productv1.ProductService/RequireStorageStockHealthScoreById" + ProductService_RequireStorageTagSummaryById_FullMethodName = "/productv1.ProductService/RequireStorageTagSummaryById" + ProductService_RequireStorageTagsByLengthsById_FullMethodName = "/productv1.ProductService/RequireStorageTagsByLengthsById" + 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" + ProductService_ResolveProductShippingEstimate_FullMethodName = "/productv1.ProductService/ResolveProductShippingEstimate" + ProductService_ResolveProductStockStatus_FullMethodName = "/productv1.ProductService/ResolveProductStockStatus" + ProductService_ResolveStorageLinkedStorages_FullMethodName = "/productv1.ProductService/ResolveStorageLinkedStorages" + ProductService_ResolveStorageNearbyStorages_FullMethodName = "/productv1.ProductService/ResolveStorageNearbyStorages" + ProductService_ResolveStorageStorageStatus_FullMethodName = "/productv1.ProductService/ResolveStorageStorageStatus" + ProductService_ResolveSubcategoryFeaturedCategory_FullMethodName = "/productv1.ProductService/ResolveSubcategoryFeaturedCategory" + ProductService_ResolveSubcategoryItemCount_FullMethodName = "/productv1.ProductService/ResolveSubcategoryItemCount" + ProductService_ResolveSubcategoryParentCategory_FullMethodName = "/productv1.ProductService/ResolveSubcategoryParentCategory" + ProductService_ResolveTestContainerDetails_FullMethodName = "/productv1.ProductService/ResolveTestContainerDetails" ) // ProductServiceClient is the client API for ProductService service. @@ -191,8 +195,11 @@ type ProductServiceClient interface { RequireStorageNullableFilteredTagSummaryById(ctx context.Context, in *RequireStorageNullableFilteredTagSummaryByIdRequest, opts ...grpc.CallOption) (*RequireStorageNullableFilteredTagSummaryByIdResponse, error) RequireStorageOperationReportById(ctx context.Context, in *RequireStorageOperationReportByIdRequest, opts ...grpc.CallOption) (*RequireStorageOperationReportByIdResponse, error) RequireStorageOptionalLatestOperationById(ctx context.Context, in *RequireStorageOptionalLatestOperationByIdRequest, opts ...grpc.CallOption) (*RequireStorageOptionalLatestOperationByIdResponse, error) + RequireStorageOptionalOperationHistoryById(ctx context.Context, in *RequireStorageOptionalOperationHistoryByIdRequest, opts ...grpc.CallOption) (*RequireStorageOptionalOperationHistoryByIdResponse, error) RequireStorageOptionalProcessedMetadataById(ctx context.Context, in *RequireStorageOptionalProcessedMetadataByIdRequest, opts ...grpc.CallOption) (*RequireStorageOptionalProcessedMetadataByIdResponse, error) + RequireStorageOptionalProcessedMetadataHistoryById(ctx context.Context, in *RequireStorageOptionalProcessedMetadataHistoryByIdRequest, opts ...grpc.CallOption) (*RequireStorageOptionalProcessedMetadataHistoryByIdResponse, error) RequireStorageOptionalProcessedTagsById(ctx context.Context, in *RequireStorageOptionalProcessedTagsByIdRequest, opts ...grpc.CallOption) (*RequireStorageOptionalProcessedTagsByIdResponse, error) + RequireStorageOptionalRecommendedItemsById(ctx context.Context, in *RequireStorageOptionalRecommendedItemsByIdRequest, opts ...grpc.CallOption) (*RequireStorageOptionalRecommendedItemsByIdResponse, error) RequireStorageOptionalTagSummaryById(ctx context.Context, in *RequireStorageOptionalTagSummaryByIdRequest, opts ...grpc.CallOption) (*RequireStorageOptionalTagSummaryByIdResponse, error) RequireStorageProcessedMetadataById(ctx context.Context, in *RequireStorageProcessedMetadataByIdRequest, opts ...grpc.CallOption) (*RequireStorageProcessedMetadataByIdResponse, error) RequireStorageProcessedMetadataHistoryById(ctx context.Context, in *RequireStorageProcessedMetadataHistoryByIdRequest, opts ...grpc.CallOption) (*RequireStorageProcessedMetadataHistoryByIdResponse, error) @@ -202,6 +209,7 @@ type ProductServiceClient interface { RequireStorageSecuritySummaryById(ctx context.Context, in *RequireStorageSecuritySummaryByIdRequest, opts ...grpc.CallOption) (*RequireStorageSecuritySummaryByIdResponse, error) RequireStorageStockHealthScoreById(ctx context.Context, in *RequireStorageStockHealthScoreByIdRequest, opts ...grpc.CallOption) (*RequireStorageStockHealthScoreByIdResponse, error) RequireStorageTagSummaryById(ctx context.Context, in *RequireStorageTagSummaryByIdRequest, opts ...grpc.CallOption) (*RequireStorageTagSummaryByIdResponse, error) + RequireStorageTagsByLengthsById(ctx context.Context, in *RequireStorageTagsByLengthsByIdRequest, opts ...grpc.CallOption) (*RequireStorageTagsByLengthsByIdResponse, 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) @@ -858,6 +866,16 @@ func (c *productServiceClient) RequireStorageOptionalLatestOperationById(ctx con return out, nil } +func (c *productServiceClient) RequireStorageOptionalOperationHistoryById(ctx context.Context, in *RequireStorageOptionalOperationHistoryByIdRequest, opts ...grpc.CallOption) (*RequireStorageOptionalOperationHistoryByIdResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(RequireStorageOptionalOperationHistoryByIdResponse) + err := c.cc.Invoke(ctx, ProductService_RequireStorageOptionalOperationHistoryById_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *productServiceClient) RequireStorageOptionalProcessedMetadataById(ctx context.Context, in *RequireStorageOptionalProcessedMetadataByIdRequest, opts ...grpc.CallOption) (*RequireStorageOptionalProcessedMetadataByIdResponse, error) { cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(RequireStorageOptionalProcessedMetadataByIdResponse) @@ -868,6 +886,16 @@ func (c *productServiceClient) RequireStorageOptionalProcessedMetadataById(ctx c return out, nil } +func (c *productServiceClient) RequireStorageOptionalProcessedMetadataHistoryById(ctx context.Context, in *RequireStorageOptionalProcessedMetadataHistoryByIdRequest, opts ...grpc.CallOption) (*RequireStorageOptionalProcessedMetadataHistoryByIdResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(RequireStorageOptionalProcessedMetadataHistoryByIdResponse) + err := c.cc.Invoke(ctx, ProductService_RequireStorageOptionalProcessedMetadataHistoryById_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *productServiceClient) RequireStorageOptionalProcessedTagsById(ctx context.Context, in *RequireStorageOptionalProcessedTagsByIdRequest, opts ...grpc.CallOption) (*RequireStorageOptionalProcessedTagsByIdResponse, error) { cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(RequireStorageOptionalProcessedTagsByIdResponse) @@ -878,6 +906,16 @@ func (c *productServiceClient) RequireStorageOptionalProcessedTagsById(ctx conte return out, nil } +func (c *productServiceClient) RequireStorageOptionalRecommendedItemsById(ctx context.Context, in *RequireStorageOptionalRecommendedItemsByIdRequest, opts ...grpc.CallOption) (*RequireStorageOptionalRecommendedItemsByIdResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(RequireStorageOptionalRecommendedItemsByIdResponse) + err := c.cc.Invoke(ctx, ProductService_RequireStorageOptionalRecommendedItemsById_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *productServiceClient) RequireStorageOptionalTagSummaryById(ctx context.Context, in *RequireStorageOptionalTagSummaryByIdRequest, opts ...grpc.CallOption) (*RequireStorageOptionalTagSummaryByIdResponse, error) { cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(RequireStorageOptionalTagSummaryByIdResponse) @@ -968,6 +1006,16 @@ func (c *productServiceClient) RequireStorageTagSummaryById(ctx context.Context, return out, nil } +func (c *productServiceClient) RequireStorageTagsByLengthsById(ctx context.Context, in *RequireStorageTagsByLengthsByIdRequest, opts ...grpc.CallOption) (*RequireStorageTagsByLengthsByIdResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(RequireStorageTagsByLengthsByIdResponse) + err := c.cc.Invoke(ctx, ProductService_RequireStorageTagsByLengthsById_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *productServiceClient) RequireWarehouseStockHealthScoreById(ctx context.Context, in *RequireWarehouseStockHealthScoreByIdRequest, opts ...grpc.CallOption) (*RequireWarehouseStockHealthScoreByIdResponse, error) { cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(RequireWarehouseStockHealthScoreByIdResponse) @@ -1299,8 +1347,11 @@ type ProductServiceServer interface { RequireStorageNullableFilteredTagSummaryById(context.Context, *RequireStorageNullableFilteredTagSummaryByIdRequest) (*RequireStorageNullableFilteredTagSummaryByIdResponse, error) RequireStorageOperationReportById(context.Context, *RequireStorageOperationReportByIdRequest) (*RequireStorageOperationReportByIdResponse, error) RequireStorageOptionalLatestOperationById(context.Context, *RequireStorageOptionalLatestOperationByIdRequest) (*RequireStorageOptionalLatestOperationByIdResponse, error) + RequireStorageOptionalOperationHistoryById(context.Context, *RequireStorageOptionalOperationHistoryByIdRequest) (*RequireStorageOptionalOperationHistoryByIdResponse, error) RequireStorageOptionalProcessedMetadataById(context.Context, *RequireStorageOptionalProcessedMetadataByIdRequest) (*RequireStorageOptionalProcessedMetadataByIdResponse, error) + RequireStorageOptionalProcessedMetadataHistoryById(context.Context, *RequireStorageOptionalProcessedMetadataHistoryByIdRequest) (*RequireStorageOptionalProcessedMetadataHistoryByIdResponse, error) RequireStorageOptionalProcessedTagsById(context.Context, *RequireStorageOptionalProcessedTagsByIdRequest) (*RequireStorageOptionalProcessedTagsByIdResponse, error) + RequireStorageOptionalRecommendedItemsById(context.Context, *RequireStorageOptionalRecommendedItemsByIdRequest) (*RequireStorageOptionalRecommendedItemsByIdResponse, error) RequireStorageOptionalTagSummaryById(context.Context, *RequireStorageOptionalTagSummaryByIdRequest) (*RequireStorageOptionalTagSummaryByIdResponse, error) RequireStorageProcessedMetadataById(context.Context, *RequireStorageProcessedMetadataByIdRequest) (*RequireStorageProcessedMetadataByIdResponse, error) RequireStorageProcessedMetadataHistoryById(context.Context, *RequireStorageProcessedMetadataHistoryByIdRequest) (*RequireStorageProcessedMetadataHistoryByIdResponse, error) @@ -1310,6 +1361,7 @@ type ProductServiceServer interface { RequireStorageSecuritySummaryById(context.Context, *RequireStorageSecuritySummaryByIdRequest) (*RequireStorageSecuritySummaryByIdResponse, error) RequireStorageStockHealthScoreById(context.Context, *RequireStorageStockHealthScoreByIdRequest) (*RequireStorageStockHealthScoreByIdResponse, error) RequireStorageTagSummaryById(context.Context, *RequireStorageTagSummaryByIdRequest) (*RequireStorageTagSummaryByIdResponse, error) + RequireStorageTagsByLengthsById(context.Context, *RequireStorageTagsByLengthsByIdRequest) (*RequireStorageTagsByLengthsByIdResponse, error) RequireWarehouseStockHealthScoreById(context.Context, *RequireWarehouseStockHealthScoreByIdRequest) (*RequireWarehouseStockHealthScoreByIdResponse, error) ResolveCategoryActiveSubcategories(context.Context, *ResolveCategoryActiveSubcategoriesRequest) (*ResolveCategoryActiveSubcategoriesResponse, error) ResolveCategoryCategoryMetrics(context.Context, *ResolveCategoryCategoryMetricsRequest) (*ResolveCategoryCategoryMetricsResponse, error) @@ -1532,12 +1584,21 @@ func (UnimplementedProductServiceServer) RequireStorageOperationReportById(conte func (UnimplementedProductServiceServer) RequireStorageOptionalLatestOperationById(context.Context, *RequireStorageOptionalLatestOperationByIdRequest) (*RequireStorageOptionalLatestOperationByIdResponse, error) { return nil, status.Error(codes.Unimplemented, "method RequireStorageOptionalLatestOperationById not implemented") } +func (UnimplementedProductServiceServer) RequireStorageOptionalOperationHistoryById(context.Context, *RequireStorageOptionalOperationHistoryByIdRequest) (*RequireStorageOptionalOperationHistoryByIdResponse, error) { + return nil, status.Error(codes.Unimplemented, "method RequireStorageOptionalOperationHistoryById not implemented") +} func (UnimplementedProductServiceServer) RequireStorageOptionalProcessedMetadataById(context.Context, *RequireStorageOptionalProcessedMetadataByIdRequest) (*RequireStorageOptionalProcessedMetadataByIdResponse, error) { return nil, status.Error(codes.Unimplemented, "method RequireStorageOptionalProcessedMetadataById not implemented") } +func (UnimplementedProductServiceServer) RequireStorageOptionalProcessedMetadataHistoryById(context.Context, *RequireStorageOptionalProcessedMetadataHistoryByIdRequest) (*RequireStorageOptionalProcessedMetadataHistoryByIdResponse, error) { + return nil, status.Error(codes.Unimplemented, "method RequireStorageOptionalProcessedMetadataHistoryById not implemented") +} func (UnimplementedProductServiceServer) RequireStorageOptionalProcessedTagsById(context.Context, *RequireStorageOptionalProcessedTagsByIdRequest) (*RequireStorageOptionalProcessedTagsByIdResponse, error) { return nil, status.Error(codes.Unimplemented, "method RequireStorageOptionalProcessedTagsById not implemented") } +func (UnimplementedProductServiceServer) RequireStorageOptionalRecommendedItemsById(context.Context, *RequireStorageOptionalRecommendedItemsByIdRequest) (*RequireStorageOptionalRecommendedItemsByIdResponse, error) { + return nil, status.Error(codes.Unimplemented, "method RequireStorageOptionalRecommendedItemsById not implemented") +} func (UnimplementedProductServiceServer) RequireStorageOptionalTagSummaryById(context.Context, *RequireStorageOptionalTagSummaryByIdRequest) (*RequireStorageOptionalTagSummaryByIdResponse, error) { return nil, status.Error(codes.Unimplemented, "method RequireStorageOptionalTagSummaryById not implemented") } @@ -1565,6 +1626,9 @@ func (UnimplementedProductServiceServer) RequireStorageStockHealthScoreById(cont func (UnimplementedProductServiceServer) RequireStorageTagSummaryById(context.Context, *RequireStorageTagSummaryByIdRequest) (*RequireStorageTagSummaryByIdResponse, error) { return nil, status.Error(codes.Unimplemented, "method RequireStorageTagSummaryById not implemented") } +func (UnimplementedProductServiceServer) RequireStorageTagsByLengthsById(context.Context, *RequireStorageTagsByLengthsByIdRequest) (*RequireStorageTagsByLengthsByIdResponse, error) { + return nil, status.Error(codes.Unimplemented, "method RequireStorageTagsByLengthsById not implemented") +} func (UnimplementedProductServiceServer) RequireWarehouseStockHealthScoreById(context.Context, *RequireWarehouseStockHealthScoreByIdRequest) (*RequireWarehouseStockHealthScoreByIdResponse, error) { return nil, status.Error(codes.Unimplemented, "method RequireWarehouseStockHealthScoreById not implemented") } @@ -2780,6 +2844,24 @@ func _ProductService_RequireStorageOptionalLatestOperationById_Handler(srv inter return interceptor(ctx, in, info, handler) } +func _ProductService_RequireStorageOptionalOperationHistoryById_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(RequireStorageOptionalOperationHistoryByIdRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProductServiceServer).RequireStorageOptionalOperationHistoryById(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ProductService_RequireStorageOptionalOperationHistoryById_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProductServiceServer).RequireStorageOptionalOperationHistoryById(ctx, req.(*RequireStorageOptionalOperationHistoryByIdRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _ProductService_RequireStorageOptionalProcessedMetadataById_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(RequireStorageOptionalProcessedMetadataByIdRequest) if err := dec(in); err != nil { @@ -2798,6 +2880,24 @@ func _ProductService_RequireStorageOptionalProcessedMetadataById_Handler(srv int return interceptor(ctx, in, info, handler) } +func _ProductService_RequireStorageOptionalProcessedMetadataHistoryById_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(RequireStorageOptionalProcessedMetadataHistoryByIdRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProductServiceServer).RequireStorageOptionalProcessedMetadataHistoryById(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ProductService_RequireStorageOptionalProcessedMetadataHistoryById_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProductServiceServer).RequireStorageOptionalProcessedMetadataHistoryById(ctx, req.(*RequireStorageOptionalProcessedMetadataHistoryByIdRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _ProductService_RequireStorageOptionalProcessedTagsById_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(RequireStorageOptionalProcessedTagsByIdRequest) if err := dec(in); err != nil { @@ -2816,6 +2916,24 @@ func _ProductService_RequireStorageOptionalProcessedTagsById_Handler(srv interfa return interceptor(ctx, in, info, handler) } +func _ProductService_RequireStorageOptionalRecommendedItemsById_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(RequireStorageOptionalRecommendedItemsByIdRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProductServiceServer).RequireStorageOptionalRecommendedItemsById(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ProductService_RequireStorageOptionalRecommendedItemsById_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProductServiceServer).RequireStorageOptionalRecommendedItemsById(ctx, req.(*RequireStorageOptionalRecommendedItemsByIdRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _ProductService_RequireStorageOptionalTagSummaryById_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(RequireStorageOptionalTagSummaryByIdRequest) if err := dec(in); err != nil { @@ -2978,6 +3096,24 @@ func _ProductService_RequireStorageTagSummaryById_Handler(srv interface{}, ctx c return interceptor(ctx, in, info, handler) } +func _ProductService_RequireStorageTagsByLengthsById_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(RequireStorageTagsByLengthsByIdRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProductServiceServer).RequireStorageTagsByLengthsById(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ProductService_RequireStorageTagsByLengthsById_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProductServiceServer).RequireStorageTagsByLengthsById(ctx, req.(*RequireStorageTagsByLengthsByIdRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _ProductService_RequireWarehouseStockHealthScoreById_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(RequireWarehouseStockHealthScoreByIdRequest) if err := dec(in); err != nil { @@ -3701,14 +3837,26 @@ var ProductService_ServiceDesc = grpc.ServiceDesc{ MethodName: "RequireStorageOptionalLatestOperationById", Handler: _ProductService_RequireStorageOptionalLatestOperationById_Handler, }, + { + MethodName: "RequireStorageOptionalOperationHistoryById", + Handler: _ProductService_RequireStorageOptionalOperationHistoryById_Handler, + }, { MethodName: "RequireStorageOptionalProcessedMetadataById", Handler: _ProductService_RequireStorageOptionalProcessedMetadataById_Handler, }, + { + MethodName: "RequireStorageOptionalProcessedMetadataHistoryById", + Handler: _ProductService_RequireStorageOptionalProcessedMetadataHistoryById_Handler, + }, { MethodName: "RequireStorageOptionalProcessedTagsById", Handler: _ProductService_RequireStorageOptionalProcessedTagsById_Handler, }, + { + MethodName: "RequireStorageOptionalRecommendedItemsById", + Handler: _ProductService_RequireStorageOptionalRecommendedItemsById_Handler, + }, { MethodName: "RequireStorageOptionalTagSummaryById", Handler: _ProductService_RequireStorageOptionalTagSummaryById_Handler, @@ -3745,6 +3893,10 @@ var ProductService_ServiceDesc = grpc.ServiceDesc{ MethodName: "RequireStorageTagSummaryById", Handler: _ProductService_RequireStorageTagSummaryById_Handler, }, + { + MethodName: "RequireStorageTagsByLengthsById", + Handler: _ProductService_RequireStorageTagsByLengthsById_Handler, + }, { MethodName: "RequireWarehouseStockHealthScoreById", Handler: _ProductService_RequireWarehouseStockHealthScoreById_Handler, diff --git a/v2/pkg/grpctest/productv1/productv1connect/product.connect.go b/v2/pkg/grpctest/productv1/productv1connect/product.connect.go index 54f29f277f..e31d91d418 100644 --- a/v2/pkg/grpctest/productv1/productv1connect/product.connect.go +++ b/v2/pkg/grpctest/productv1/productv1connect/product.connect.go @@ -219,12 +219,21 @@ const ( // ProductServiceRequireStorageOptionalLatestOperationByIdProcedure is the fully-qualified name of // the ProductService's RequireStorageOptionalLatestOperationById RPC. ProductServiceRequireStorageOptionalLatestOperationByIdProcedure = "/productv1.ProductService/RequireStorageOptionalLatestOperationById" + // ProductServiceRequireStorageOptionalOperationHistoryByIdProcedure is the fully-qualified name of + // the ProductService's RequireStorageOptionalOperationHistoryById RPC. + ProductServiceRequireStorageOptionalOperationHistoryByIdProcedure = "/productv1.ProductService/RequireStorageOptionalOperationHistoryById" // ProductServiceRequireStorageOptionalProcessedMetadataByIdProcedure is the fully-qualified name of // the ProductService's RequireStorageOptionalProcessedMetadataById RPC. ProductServiceRequireStorageOptionalProcessedMetadataByIdProcedure = "/productv1.ProductService/RequireStorageOptionalProcessedMetadataById" + // ProductServiceRequireStorageOptionalProcessedMetadataHistoryByIdProcedure is the fully-qualified + // name of the ProductService's RequireStorageOptionalProcessedMetadataHistoryById RPC. + ProductServiceRequireStorageOptionalProcessedMetadataHistoryByIdProcedure = "/productv1.ProductService/RequireStorageOptionalProcessedMetadataHistoryById" // ProductServiceRequireStorageOptionalProcessedTagsByIdProcedure is the fully-qualified name of the // ProductService's RequireStorageOptionalProcessedTagsById RPC. ProductServiceRequireStorageOptionalProcessedTagsByIdProcedure = "/productv1.ProductService/RequireStorageOptionalProcessedTagsById" + // ProductServiceRequireStorageOptionalRecommendedItemsByIdProcedure is the fully-qualified name of + // the ProductService's RequireStorageOptionalRecommendedItemsById RPC. + ProductServiceRequireStorageOptionalRecommendedItemsByIdProcedure = "/productv1.ProductService/RequireStorageOptionalRecommendedItemsById" // ProductServiceRequireStorageOptionalTagSummaryByIdProcedure is the fully-qualified name of the // ProductService's RequireStorageOptionalTagSummaryById RPC. ProductServiceRequireStorageOptionalTagSummaryByIdProcedure = "/productv1.ProductService/RequireStorageOptionalTagSummaryById" @@ -252,6 +261,9 @@ const ( // ProductServiceRequireStorageTagSummaryByIdProcedure is the fully-qualified name of the // ProductService's RequireStorageTagSummaryById RPC. ProductServiceRequireStorageTagSummaryByIdProcedure = "/productv1.ProductService/RequireStorageTagSummaryById" + // ProductServiceRequireStorageTagsByLengthsByIdProcedure is the fully-qualified name of the + // ProductService's RequireStorageTagsByLengthsById RPC. + ProductServiceRequireStorageTagsByLengthsByIdProcedure = "/productv1.ProductService/RequireStorageTagsByLengthsById" // ProductServiceRequireWarehouseStockHealthScoreByIdProcedure is the fully-qualified name of the // ProductService's RequireWarehouseStockHealthScoreById RPC. ProductServiceRequireWarehouseStockHealthScoreByIdProcedure = "/productv1.ProductService/RequireWarehouseStockHealthScoreById" @@ -399,8 +411,11 @@ type ProductServiceClient interface { RequireStorageNullableFilteredTagSummaryById(context.Context, *connect.Request[productv1.RequireStorageNullableFilteredTagSummaryByIdRequest]) (*connect.Response[productv1.RequireStorageNullableFilteredTagSummaryByIdResponse], error) RequireStorageOperationReportById(context.Context, *connect.Request[productv1.RequireStorageOperationReportByIdRequest]) (*connect.Response[productv1.RequireStorageOperationReportByIdResponse], error) RequireStorageOptionalLatestOperationById(context.Context, *connect.Request[productv1.RequireStorageOptionalLatestOperationByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalLatestOperationByIdResponse], error) + RequireStorageOptionalOperationHistoryById(context.Context, *connect.Request[productv1.RequireStorageOptionalOperationHistoryByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalOperationHistoryByIdResponse], error) RequireStorageOptionalProcessedMetadataById(context.Context, *connect.Request[productv1.RequireStorageOptionalProcessedMetadataByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalProcessedMetadataByIdResponse], error) + RequireStorageOptionalProcessedMetadataHistoryById(context.Context, *connect.Request[productv1.RequireStorageOptionalProcessedMetadataHistoryByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalProcessedMetadataHistoryByIdResponse], error) RequireStorageOptionalProcessedTagsById(context.Context, *connect.Request[productv1.RequireStorageOptionalProcessedTagsByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalProcessedTagsByIdResponse], error) + RequireStorageOptionalRecommendedItemsById(context.Context, *connect.Request[productv1.RequireStorageOptionalRecommendedItemsByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalRecommendedItemsByIdResponse], error) RequireStorageOptionalTagSummaryById(context.Context, *connect.Request[productv1.RequireStorageOptionalTagSummaryByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalTagSummaryByIdResponse], error) RequireStorageProcessedMetadataById(context.Context, *connect.Request[productv1.RequireStorageProcessedMetadataByIdRequest]) (*connect.Response[productv1.RequireStorageProcessedMetadataByIdResponse], error) RequireStorageProcessedMetadataHistoryById(context.Context, *connect.Request[productv1.RequireStorageProcessedMetadataHistoryByIdRequest]) (*connect.Response[productv1.RequireStorageProcessedMetadataHistoryByIdResponse], error) @@ -410,6 +425,7 @@ type ProductServiceClient interface { RequireStorageSecuritySummaryById(context.Context, *connect.Request[productv1.RequireStorageSecuritySummaryByIdRequest]) (*connect.Response[productv1.RequireStorageSecuritySummaryByIdResponse], error) RequireStorageStockHealthScoreById(context.Context, *connect.Request[productv1.RequireStorageStockHealthScoreByIdRequest]) (*connect.Response[productv1.RequireStorageStockHealthScoreByIdResponse], error) RequireStorageTagSummaryById(context.Context, *connect.Request[productv1.RequireStorageTagSummaryByIdRequest]) (*connect.Response[productv1.RequireStorageTagSummaryByIdResponse], error) + RequireStorageTagsByLengthsById(context.Context, *connect.Request[productv1.RequireStorageTagsByLengthsByIdRequest]) (*connect.Response[productv1.RequireStorageTagsByLengthsByIdResponse], error) RequireWarehouseStockHealthScoreById(context.Context, *connect.Request[productv1.RequireWarehouseStockHealthScoreByIdRequest]) (*connect.Response[productv1.RequireWarehouseStockHealthScoreByIdResponse], error) ResolveCategoryActiveSubcategories(context.Context, *connect.Request[productv1.ResolveCategoryActiveSubcategoriesRequest]) (*connect.Response[productv1.ResolveCategoryActiveSubcategoriesResponse], error) ResolveCategoryCategoryMetrics(context.Context, *connect.Request[productv1.ResolveCategoryCategoryMetricsRequest]) (*connect.Response[productv1.ResolveCategoryCategoryMetricsResponse], error) @@ -821,18 +837,36 @@ func NewProductServiceClient(httpClient connect.HTTPClient, baseURL string, opts connect.WithSchema(productServiceMethods.ByName("RequireStorageOptionalLatestOperationById")), connect.WithClientOptions(opts...), ), + requireStorageOptionalOperationHistoryById: connect.NewClient[productv1.RequireStorageOptionalOperationHistoryByIdRequest, productv1.RequireStorageOptionalOperationHistoryByIdResponse]( + httpClient, + baseURL+ProductServiceRequireStorageOptionalOperationHistoryByIdProcedure, + connect.WithSchema(productServiceMethods.ByName("RequireStorageOptionalOperationHistoryById")), + connect.WithClientOptions(opts...), + ), requireStorageOptionalProcessedMetadataById: connect.NewClient[productv1.RequireStorageOptionalProcessedMetadataByIdRequest, productv1.RequireStorageOptionalProcessedMetadataByIdResponse]( httpClient, baseURL+ProductServiceRequireStorageOptionalProcessedMetadataByIdProcedure, connect.WithSchema(productServiceMethods.ByName("RequireStorageOptionalProcessedMetadataById")), connect.WithClientOptions(opts...), ), + requireStorageOptionalProcessedMetadataHistoryById: connect.NewClient[productv1.RequireStorageOptionalProcessedMetadataHistoryByIdRequest, productv1.RequireStorageOptionalProcessedMetadataHistoryByIdResponse]( + httpClient, + baseURL+ProductServiceRequireStorageOptionalProcessedMetadataHistoryByIdProcedure, + connect.WithSchema(productServiceMethods.ByName("RequireStorageOptionalProcessedMetadataHistoryById")), + connect.WithClientOptions(opts...), + ), requireStorageOptionalProcessedTagsById: connect.NewClient[productv1.RequireStorageOptionalProcessedTagsByIdRequest, productv1.RequireStorageOptionalProcessedTagsByIdResponse]( httpClient, baseURL+ProductServiceRequireStorageOptionalProcessedTagsByIdProcedure, connect.WithSchema(productServiceMethods.ByName("RequireStorageOptionalProcessedTagsById")), connect.WithClientOptions(opts...), ), + requireStorageOptionalRecommendedItemsById: connect.NewClient[productv1.RequireStorageOptionalRecommendedItemsByIdRequest, productv1.RequireStorageOptionalRecommendedItemsByIdResponse]( + httpClient, + baseURL+ProductServiceRequireStorageOptionalRecommendedItemsByIdProcedure, + connect.WithSchema(productServiceMethods.ByName("RequireStorageOptionalRecommendedItemsById")), + connect.WithClientOptions(opts...), + ), requireStorageOptionalTagSummaryById: connect.NewClient[productv1.RequireStorageOptionalTagSummaryByIdRequest, productv1.RequireStorageOptionalTagSummaryByIdResponse]( httpClient, baseURL+ProductServiceRequireStorageOptionalTagSummaryByIdProcedure, @@ -887,6 +921,12 @@ func NewProductServiceClient(httpClient connect.HTTPClient, baseURL string, opts connect.WithSchema(productServiceMethods.ByName("RequireStorageTagSummaryById")), connect.WithClientOptions(opts...), ), + requireStorageTagsByLengthsById: connect.NewClient[productv1.RequireStorageTagsByLengthsByIdRequest, productv1.RequireStorageTagsByLengthsByIdResponse]( + httpClient, + baseURL+ProductServiceRequireStorageTagsByLengthsByIdProcedure, + connect.WithSchema(productServiceMethods.ByName("RequireStorageTagsByLengthsById")), + connect.WithClientOptions(opts...), + ), requireWarehouseStockHealthScoreById: connect.NewClient[productv1.RequireWarehouseStockHealthScoreByIdRequest, productv1.RequireWarehouseStockHealthScoreByIdResponse]( httpClient, baseURL+ProductServiceRequireWarehouseStockHealthScoreByIdProcedure, @@ -1048,105 +1088,109 @@ func NewProductServiceClient(httpClient connect.HTTPClient, baseURL string, opts // productServiceClient implements ProductServiceClient. type productServiceClient struct { - lookupProductById *connect.Client[productv1.LookupProductByIdRequest, productv1.LookupProductByIdResponse] - lookupStorageById *connect.Client[productv1.LookupStorageByIdRequest, productv1.LookupStorageByIdResponse] - lookupWarehouseById *connect.Client[productv1.LookupWarehouseByIdRequest, productv1.LookupWarehouseByIdResponse] - mutationBulkCreateAuthors *connect.Client[productv1.MutationBulkCreateAuthorsRequest, productv1.MutationBulkCreateAuthorsResponse] - mutationBulkCreateBlogPosts *connect.Client[productv1.MutationBulkCreateBlogPostsRequest, productv1.MutationBulkCreateBlogPostsResponse] - mutationBulkUpdateAuthors *connect.Client[productv1.MutationBulkUpdateAuthorsRequest, productv1.MutationBulkUpdateAuthorsResponse] - mutationBulkUpdateBlogPosts *connect.Client[productv1.MutationBulkUpdateBlogPostsRequest, productv1.MutationBulkUpdateBlogPostsResponse] - mutationCreateAuthor *connect.Client[productv1.MutationCreateAuthorRequest, productv1.MutationCreateAuthorResponse] - mutationCreateBlogPost *connect.Client[productv1.MutationCreateBlogPostRequest, productv1.MutationCreateBlogPostResponse] - mutationCreateNullableFieldsType *connect.Client[productv1.MutationCreateNullableFieldsTypeRequest, productv1.MutationCreateNullableFieldsTypeResponse] - mutationCreateUser *connect.Client[productv1.MutationCreateUserRequest, productv1.MutationCreateUserResponse] - mutationPerformAction *connect.Client[productv1.MutationPerformActionRequest, productv1.MutationPerformActionResponse] - mutationUpdateAuthor *connect.Client[productv1.MutationUpdateAuthorRequest, productv1.MutationUpdateAuthorResponse] - mutationUpdateBlogPost *connect.Client[productv1.MutationUpdateBlogPostRequest, productv1.MutationUpdateBlogPostResponse] - mutationUpdateNullableFieldsType *connect.Client[productv1.MutationUpdateNullableFieldsTypeRequest, productv1.MutationUpdateNullableFieldsTypeResponse] - queryAllAuthors *connect.Client[productv1.QueryAllAuthorsRequest, productv1.QueryAllAuthorsResponse] - queryAllBlogPosts *connect.Client[productv1.QueryAllBlogPostsRequest, productv1.QueryAllBlogPostsResponse] - queryAllNullableFieldsTypes *connect.Client[productv1.QueryAllNullableFieldsTypesRequest, productv1.QueryAllNullableFieldsTypesResponse] - queryAllPets *connect.Client[productv1.QueryAllPetsRequest, productv1.QueryAllPetsResponse] - queryAuthor *connect.Client[productv1.QueryAuthorRequest, productv1.QueryAuthorResponse] - queryAuthorById *connect.Client[productv1.QueryAuthorByIdRequest, productv1.QueryAuthorByIdResponse] - queryAuthorsWithFilter *connect.Client[productv1.QueryAuthorsWithFilterRequest, productv1.QueryAuthorsWithFilterResponse] - queryBlogPost *connect.Client[productv1.QueryBlogPostRequest, productv1.QueryBlogPostResponse] - queryBlogPostById *connect.Client[productv1.QueryBlogPostByIdRequest, productv1.QueryBlogPostByIdResponse] - queryBlogPostsWithFilter *connect.Client[productv1.QueryBlogPostsWithFilterRequest, productv1.QueryBlogPostsWithFilterResponse] - queryBulkSearchAuthors *connect.Client[productv1.QueryBulkSearchAuthorsRequest, productv1.QueryBulkSearchAuthorsResponse] - queryBulkSearchBlogPosts *connect.Client[productv1.QueryBulkSearchBlogPostsRequest, productv1.QueryBulkSearchBlogPostsResponse] - queryCalculateTotals *connect.Client[productv1.QueryCalculateTotalsRequest, productv1.QueryCalculateTotalsResponse] - queryCategories *connect.Client[productv1.QueryCategoriesRequest, productv1.QueryCategoriesResponse] - queryCategoriesByKind *connect.Client[productv1.QueryCategoriesByKindRequest, productv1.QueryCategoriesByKindResponse] - queryCategoriesByKinds *connect.Client[productv1.QueryCategoriesByKindsRequest, productv1.QueryCategoriesByKindsResponse] - queryCategory *connect.Client[productv1.QueryCategoryRequest, productv1.QueryCategoryResponse] - queryComplexFilterType *connect.Client[productv1.QueryComplexFilterTypeRequest, productv1.QueryComplexFilterTypeResponse] - queryConditionalSearch *connect.Client[productv1.QueryConditionalSearchRequest, productv1.QueryConditionalSearchResponse] - queryFilterCategories *connect.Client[productv1.QueryFilterCategoriesRequest, productv1.QueryFilterCategoriesResponse] - queryNestedType *connect.Client[productv1.QueryNestedTypeRequest, productv1.QueryNestedTypeResponse] - queryNullableFieldsType *connect.Client[productv1.QueryNullableFieldsTypeRequest, productv1.QueryNullableFieldsTypeResponse] - queryNullableFieldsTypeById *connect.Client[productv1.QueryNullableFieldsTypeByIdRequest, productv1.QueryNullableFieldsTypeByIdResponse] - queryNullableFieldsTypeWithFilter *connect.Client[productv1.QueryNullableFieldsTypeWithFilterRequest, productv1.QueryNullableFieldsTypeWithFilterResponse] - queryRandomPet *connect.Client[productv1.QueryRandomPetRequest, productv1.QueryRandomPetResponse] - queryRandomSearchResult *connect.Client[productv1.QueryRandomSearchResultRequest, productv1.QueryRandomSearchResultResponse] - queryRecursiveType *connect.Client[productv1.QueryRecursiveTypeRequest, productv1.QueryRecursiveTypeResponse] - querySearch *connect.Client[productv1.QuerySearchRequest, productv1.QuerySearchResponse] - queryTestContainer *connect.Client[productv1.QueryTestContainerRequest, productv1.QueryTestContainerResponse] - queryTestContainers *connect.Client[productv1.QueryTestContainersRequest, productv1.QueryTestContainersResponse] - queryTypeFilterWithArguments *connect.Client[productv1.QueryTypeFilterWithArgumentsRequest, productv1.QueryTypeFilterWithArgumentsResponse] - queryTypeWithMultipleFilterFields *connect.Client[productv1.QueryTypeWithMultipleFilterFieldsRequest, productv1.QueryTypeWithMultipleFilterFieldsResponse] - queryUser *connect.Client[productv1.QueryUserRequest, productv1.QueryUserResponse] - queryUsers *connect.Client[productv1.QueryUsersRequest, productv1.QueryUsersResponse] - requireStorageCategoryInfoSummaryById *connect.Client[productv1.RequireStorageCategoryInfoSummaryByIdRequest, productv1.RequireStorageCategoryInfoSummaryByIdResponse] - requireStorageDeepItemInfoById *connect.Client[productv1.RequireStorageDeepItemInfoByIdRequest, productv1.RequireStorageDeepItemInfoByIdResponse] - requireStorageFilteredTagSummaryById *connect.Client[productv1.RequireStorageFilteredTagSummaryByIdRequest, productv1.RequireStorageFilteredTagSummaryByIdResponse] - requireStorageItemHandlerInfoById *connect.Client[productv1.RequireStorageItemHandlerInfoByIdRequest, productv1.RequireStorageItemHandlerInfoByIdResponse] - requireStorageItemInfoById *connect.Client[productv1.RequireStorageItemInfoByIdRequest, productv1.RequireStorageItemInfoByIdResponse] - requireStorageItemSpecsInfoById *connect.Client[productv1.RequireStorageItemSpecsInfoByIdRequest, productv1.RequireStorageItemSpecsInfoByIdResponse] - requireStorageKindSummaryById *connect.Client[productv1.RequireStorageKindSummaryByIdRequest, productv1.RequireStorageKindSummaryByIdResponse] - requireStorageLatestOperationById *connect.Client[productv1.RequireStorageLatestOperationByIdRequest, productv1.RequireStorageLatestOperationByIdResponse] - requireStorageMetadataScoreById *connect.Client[productv1.RequireStorageMetadataScoreByIdRequest, productv1.RequireStorageMetadataScoreByIdResponse] - requireStorageMultiFilteredTagSummaryById *connect.Client[productv1.RequireStorageMultiFilteredTagSummaryByIdRequest, productv1.RequireStorageMultiFilteredTagSummaryByIdResponse] - requireStorageNullableFilteredTagSummaryById *connect.Client[productv1.RequireStorageNullableFilteredTagSummaryByIdRequest, productv1.RequireStorageNullableFilteredTagSummaryByIdResponse] - requireStorageOperationReportById *connect.Client[productv1.RequireStorageOperationReportByIdRequest, productv1.RequireStorageOperationReportByIdResponse] - requireStorageOptionalLatestOperationById *connect.Client[productv1.RequireStorageOptionalLatestOperationByIdRequest, productv1.RequireStorageOptionalLatestOperationByIdResponse] - requireStorageOptionalProcessedMetadataById *connect.Client[productv1.RequireStorageOptionalProcessedMetadataByIdRequest, productv1.RequireStorageOptionalProcessedMetadataByIdResponse] - requireStorageOptionalProcessedTagsById *connect.Client[productv1.RequireStorageOptionalProcessedTagsByIdRequest, productv1.RequireStorageOptionalProcessedTagsByIdResponse] - requireStorageOptionalTagSummaryById *connect.Client[productv1.RequireStorageOptionalTagSummaryByIdRequest, productv1.RequireStorageOptionalTagSummaryByIdResponse] - requireStorageProcessedMetadataById *connect.Client[productv1.RequireStorageProcessedMetadataByIdRequest, productv1.RequireStorageProcessedMetadataByIdResponse] - requireStorageProcessedMetadataHistoryById *connect.Client[productv1.RequireStorageProcessedMetadataHistoryByIdRequest, productv1.RequireStorageProcessedMetadataHistoryByIdResponse] - requireStorageProcessedTagsById *connect.Client[productv1.RequireStorageProcessedTagsByIdRequest, productv1.RequireStorageProcessedTagsByIdResponse] - requireStorageRecommendedItemById *connect.Client[productv1.RequireStorageRecommendedItemByIdRequest, productv1.RequireStorageRecommendedItemByIdResponse] - requireStorageRecommendedItemsById *connect.Client[productv1.RequireStorageRecommendedItemsByIdRequest, productv1.RequireStorageRecommendedItemsByIdResponse] - requireStorageSecuritySummaryById *connect.Client[productv1.RequireStorageSecuritySummaryByIdRequest, productv1.RequireStorageSecuritySummaryByIdResponse] - requireStorageStockHealthScoreById *connect.Client[productv1.RequireStorageStockHealthScoreByIdRequest, productv1.RequireStorageStockHealthScoreByIdResponse] - requireStorageTagSummaryById *connect.Client[productv1.RequireStorageTagSummaryByIdRequest, productv1.RequireStorageTagSummaryByIdResponse] - requireWarehouseStockHealthScoreById *connect.Client[productv1.RequireWarehouseStockHealthScoreByIdRequest, productv1.RequireWarehouseStockHealthScoreByIdResponse] - resolveCategoryActiveSubcategories *connect.Client[productv1.ResolveCategoryActiveSubcategoriesRequest, productv1.ResolveCategoryActiveSubcategoriesResponse] - resolveCategoryCategoryMetrics *connect.Client[productv1.ResolveCategoryCategoryMetricsRequest, productv1.ResolveCategoryCategoryMetricsResponse] - resolveCategoryCategoryStatus *connect.Client[productv1.ResolveCategoryCategoryStatusRequest, productv1.ResolveCategoryCategoryStatusResponse] - resolveCategoryChildCategories *connect.Client[productv1.ResolveCategoryChildCategoriesRequest, productv1.ResolveCategoryChildCategoriesResponse] - resolveCategoryMascot *connect.Client[productv1.ResolveCategoryMascotRequest, productv1.ResolveCategoryMascotResponse] - resolveCategoryMetricsAverageScore *connect.Client[productv1.ResolveCategoryMetricsAverageScoreRequest, productv1.ResolveCategoryMetricsAverageScoreResponse] - resolveCategoryMetricsNormalizedScore *connect.Client[productv1.ResolveCategoryMetricsNormalizedScoreRequest, productv1.ResolveCategoryMetricsNormalizedScoreResponse] - resolveCategoryMetricsRelatedCategory *connect.Client[productv1.ResolveCategoryMetricsRelatedCategoryRequest, productv1.ResolveCategoryMetricsRelatedCategoryResponse] - resolveCategoryOptionalCategories *connect.Client[productv1.ResolveCategoryOptionalCategoriesRequest, productv1.ResolveCategoryOptionalCategoriesResponse] - resolveCategoryPopularityScore *connect.Client[productv1.ResolveCategoryPopularityScoreRequest, productv1.ResolveCategoryPopularityScoreResponse] - resolveCategoryProductCount *connect.Client[productv1.ResolveCategoryProductCountRequest, productv1.ResolveCategoryProductCountResponse] - resolveCategoryTopSubcategory *connect.Client[productv1.ResolveCategoryTopSubcategoryRequest, productv1.ResolveCategoryTopSubcategoryResponse] - resolveCategoryTotalProducts *connect.Client[productv1.ResolveCategoryTotalProductsRequest, productv1.ResolveCategoryTotalProductsResponse] - resolveProductMascotRecommendation *connect.Client[productv1.ResolveProductMascotRecommendationRequest, productv1.ResolveProductMascotRecommendationResponse] - resolveProductProductDetails *connect.Client[productv1.ResolveProductProductDetailsRequest, productv1.ResolveProductProductDetailsResponse] - resolveProductRecommendedCategory *connect.Client[productv1.ResolveProductRecommendedCategoryRequest, productv1.ResolveProductRecommendedCategoryResponse] - resolveProductShippingEstimate *connect.Client[productv1.ResolveProductShippingEstimateRequest, productv1.ResolveProductShippingEstimateResponse] - resolveProductStockStatus *connect.Client[productv1.ResolveProductStockStatusRequest, productv1.ResolveProductStockStatusResponse] - resolveStorageLinkedStorages *connect.Client[productv1.ResolveStorageLinkedStoragesRequest, productv1.ResolveStorageLinkedStoragesResponse] - resolveStorageNearbyStorages *connect.Client[productv1.ResolveStorageNearbyStoragesRequest, productv1.ResolveStorageNearbyStoragesResponse] - resolveStorageStorageStatus *connect.Client[productv1.ResolveStorageStorageStatusRequest, productv1.ResolveStorageStorageStatusResponse] - resolveSubcategoryFeaturedCategory *connect.Client[productv1.ResolveSubcategoryFeaturedCategoryRequest, productv1.ResolveSubcategoryFeaturedCategoryResponse] - resolveSubcategoryItemCount *connect.Client[productv1.ResolveSubcategoryItemCountRequest, productv1.ResolveSubcategoryItemCountResponse] - resolveSubcategoryParentCategory *connect.Client[productv1.ResolveSubcategoryParentCategoryRequest, productv1.ResolveSubcategoryParentCategoryResponse] - resolveTestContainerDetails *connect.Client[productv1.ResolveTestContainerDetailsRequest, productv1.ResolveTestContainerDetailsResponse] + lookupProductById *connect.Client[productv1.LookupProductByIdRequest, productv1.LookupProductByIdResponse] + lookupStorageById *connect.Client[productv1.LookupStorageByIdRequest, productv1.LookupStorageByIdResponse] + lookupWarehouseById *connect.Client[productv1.LookupWarehouseByIdRequest, productv1.LookupWarehouseByIdResponse] + mutationBulkCreateAuthors *connect.Client[productv1.MutationBulkCreateAuthorsRequest, productv1.MutationBulkCreateAuthorsResponse] + mutationBulkCreateBlogPosts *connect.Client[productv1.MutationBulkCreateBlogPostsRequest, productv1.MutationBulkCreateBlogPostsResponse] + mutationBulkUpdateAuthors *connect.Client[productv1.MutationBulkUpdateAuthorsRequest, productv1.MutationBulkUpdateAuthorsResponse] + mutationBulkUpdateBlogPosts *connect.Client[productv1.MutationBulkUpdateBlogPostsRequest, productv1.MutationBulkUpdateBlogPostsResponse] + mutationCreateAuthor *connect.Client[productv1.MutationCreateAuthorRequest, productv1.MutationCreateAuthorResponse] + mutationCreateBlogPost *connect.Client[productv1.MutationCreateBlogPostRequest, productv1.MutationCreateBlogPostResponse] + mutationCreateNullableFieldsType *connect.Client[productv1.MutationCreateNullableFieldsTypeRequest, productv1.MutationCreateNullableFieldsTypeResponse] + mutationCreateUser *connect.Client[productv1.MutationCreateUserRequest, productv1.MutationCreateUserResponse] + mutationPerformAction *connect.Client[productv1.MutationPerformActionRequest, productv1.MutationPerformActionResponse] + mutationUpdateAuthor *connect.Client[productv1.MutationUpdateAuthorRequest, productv1.MutationUpdateAuthorResponse] + mutationUpdateBlogPost *connect.Client[productv1.MutationUpdateBlogPostRequest, productv1.MutationUpdateBlogPostResponse] + mutationUpdateNullableFieldsType *connect.Client[productv1.MutationUpdateNullableFieldsTypeRequest, productv1.MutationUpdateNullableFieldsTypeResponse] + queryAllAuthors *connect.Client[productv1.QueryAllAuthorsRequest, productv1.QueryAllAuthorsResponse] + queryAllBlogPosts *connect.Client[productv1.QueryAllBlogPostsRequest, productv1.QueryAllBlogPostsResponse] + queryAllNullableFieldsTypes *connect.Client[productv1.QueryAllNullableFieldsTypesRequest, productv1.QueryAllNullableFieldsTypesResponse] + queryAllPets *connect.Client[productv1.QueryAllPetsRequest, productv1.QueryAllPetsResponse] + queryAuthor *connect.Client[productv1.QueryAuthorRequest, productv1.QueryAuthorResponse] + queryAuthorById *connect.Client[productv1.QueryAuthorByIdRequest, productv1.QueryAuthorByIdResponse] + queryAuthorsWithFilter *connect.Client[productv1.QueryAuthorsWithFilterRequest, productv1.QueryAuthorsWithFilterResponse] + queryBlogPost *connect.Client[productv1.QueryBlogPostRequest, productv1.QueryBlogPostResponse] + queryBlogPostById *connect.Client[productv1.QueryBlogPostByIdRequest, productv1.QueryBlogPostByIdResponse] + queryBlogPostsWithFilter *connect.Client[productv1.QueryBlogPostsWithFilterRequest, productv1.QueryBlogPostsWithFilterResponse] + queryBulkSearchAuthors *connect.Client[productv1.QueryBulkSearchAuthorsRequest, productv1.QueryBulkSearchAuthorsResponse] + queryBulkSearchBlogPosts *connect.Client[productv1.QueryBulkSearchBlogPostsRequest, productv1.QueryBulkSearchBlogPostsResponse] + queryCalculateTotals *connect.Client[productv1.QueryCalculateTotalsRequest, productv1.QueryCalculateTotalsResponse] + queryCategories *connect.Client[productv1.QueryCategoriesRequest, productv1.QueryCategoriesResponse] + queryCategoriesByKind *connect.Client[productv1.QueryCategoriesByKindRequest, productv1.QueryCategoriesByKindResponse] + queryCategoriesByKinds *connect.Client[productv1.QueryCategoriesByKindsRequest, productv1.QueryCategoriesByKindsResponse] + queryCategory *connect.Client[productv1.QueryCategoryRequest, productv1.QueryCategoryResponse] + queryComplexFilterType *connect.Client[productv1.QueryComplexFilterTypeRequest, productv1.QueryComplexFilterTypeResponse] + queryConditionalSearch *connect.Client[productv1.QueryConditionalSearchRequest, productv1.QueryConditionalSearchResponse] + queryFilterCategories *connect.Client[productv1.QueryFilterCategoriesRequest, productv1.QueryFilterCategoriesResponse] + queryNestedType *connect.Client[productv1.QueryNestedTypeRequest, productv1.QueryNestedTypeResponse] + queryNullableFieldsType *connect.Client[productv1.QueryNullableFieldsTypeRequest, productv1.QueryNullableFieldsTypeResponse] + queryNullableFieldsTypeById *connect.Client[productv1.QueryNullableFieldsTypeByIdRequest, productv1.QueryNullableFieldsTypeByIdResponse] + queryNullableFieldsTypeWithFilter *connect.Client[productv1.QueryNullableFieldsTypeWithFilterRequest, productv1.QueryNullableFieldsTypeWithFilterResponse] + queryRandomPet *connect.Client[productv1.QueryRandomPetRequest, productv1.QueryRandomPetResponse] + queryRandomSearchResult *connect.Client[productv1.QueryRandomSearchResultRequest, productv1.QueryRandomSearchResultResponse] + queryRecursiveType *connect.Client[productv1.QueryRecursiveTypeRequest, productv1.QueryRecursiveTypeResponse] + querySearch *connect.Client[productv1.QuerySearchRequest, productv1.QuerySearchResponse] + queryTestContainer *connect.Client[productv1.QueryTestContainerRequest, productv1.QueryTestContainerResponse] + queryTestContainers *connect.Client[productv1.QueryTestContainersRequest, productv1.QueryTestContainersResponse] + queryTypeFilterWithArguments *connect.Client[productv1.QueryTypeFilterWithArgumentsRequest, productv1.QueryTypeFilterWithArgumentsResponse] + queryTypeWithMultipleFilterFields *connect.Client[productv1.QueryTypeWithMultipleFilterFieldsRequest, productv1.QueryTypeWithMultipleFilterFieldsResponse] + queryUser *connect.Client[productv1.QueryUserRequest, productv1.QueryUserResponse] + queryUsers *connect.Client[productv1.QueryUsersRequest, productv1.QueryUsersResponse] + requireStorageCategoryInfoSummaryById *connect.Client[productv1.RequireStorageCategoryInfoSummaryByIdRequest, productv1.RequireStorageCategoryInfoSummaryByIdResponse] + requireStorageDeepItemInfoById *connect.Client[productv1.RequireStorageDeepItemInfoByIdRequest, productv1.RequireStorageDeepItemInfoByIdResponse] + requireStorageFilteredTagSummaryById *connect.Client[productv1.RequireStorageFilteredTagSummaryByIdRequest, productv1.RequireStorageFilteredTagSummaryByIdResponse] + requireStorageItemHandlerInfoById *connect.Client[productv1.RequireStorageItemHandlerInfoByIdRequest, productv1.RequireStorageItemHandlerInfoByIdResponse] + requireStorageItemInfoById *connect.Client[productv1.RequireStorageItemInfoByIdRequest, productv1.RequireStorageItemInfoByIdResponse] + requireStorageItemSpecsInfoById *connect.Client[productv1.RequireStorageItemSpecsInfoByIdRequest, productv1.RequireStorageItemSpecsInfoByIdResponse] + requireStorageKindSummaryById *connect.Client[productv1.RequireStorageKindSummaryByIdRequest, productv1.RequireStorageKindSummaryByIdResponse] + requireStorageLatestOperationById *connect.Client[productv1.RequireStorageLatestOperationByIdRequest, productv1.RequireStorageLatestOperationByIdResponse] + requireStorageMetadataScoreById *connect.Client[productv1.RequireStorageMetadataScoreByIdRequest, productv1.RequireStorageMetadataScoreByIdResponse] + requireStorageMultiFilteredTagSummaryById *connect.Client[productv1.RequireStorageMultiFilteredTagSummaryByIdRequest, productv1.RequireStorageMultiFilteredTagSummaryByIdResponse] + requireStorageNullableFilteredTagSummaryById *connect.Client[productv1.RequireStorageNullableFilteredTagSummaryByIdRequest, productv1.RequireStorageNullableFilteredTagSummaryByIdResponse] + requireStorageOperationReportById *connect.Client[productv1.RequireStorageOperationReportByIdRequest, productv1.RequireStorageOperationReportByIdResponse] + requireStorageOptionalLatestOperationById *connect.Client[productv1.RequireStorageOptionalLatestOperationByIdRequest, productv1.RequireStorageOptionalLatestOperationByIdResponse] + requireStorageOptionalOperationHistoryById *connect.Client[productv1.RequireStorageOptionalOperationHistoryByIdRequest, productv1.RequireStorageOptionalOperationHistoryByIdResponse] + requireStorageOptionalProcessedMetadataById *connect.Client[productv1.RequireStorageOptionalProcessedMetadataByIdRequest, productv1.RequireStorageOptionalProcessedMetadataByIdResponse] + requireStorageOptionalProcessedMetadataHistoryById *connect.Client[productv1.RequireStorageOptionalProcessedMetadataHistoryByIdRequest, productv1.RequireStorageOptionalProcessedMetadataHistoryByIdResponse] + requireStorageOptionalProcessedTagsById *connect.Client[productv1.RequireStorageOptionalProcessedTagsByIdRequest, productv1.RequireStorageOptionalProcessedTagsByIdResponse] + requireStorageOptionalRecommendedItemsById *connect.Client[productv1.RequireStorageOptionalRecommendedItemsByIdRequest, productv1.RequireStorageOptionalRecommendedItemsByIdResponse] + requireStorageOptionalTagSummaryById *connect.Client[productv1.RequireStorageOptionalTagSummaryByIdRequest, productv1.RequireStorageOptionalTagSummaryByIdResponse] + requireStorageProcessedMetadataById *connect.Client[productv1.RequireStorageProcessedMetadataByIdRequest, productv1.RequireStorageProcessedMetadataByIdResponse] + requireStorageProcessedMetadataHistoryById *connect.Client[productv1.RequireStorageProcessedMetadataHistoryByIdRequest, productv1.RequireStorageProcessedMetadataHistoryByIdResponse] + requireStorageProcessedTagsById *connect.Client[productv1.RequireStorageProcessedTagsByIdRequest, productv1.RequireStorageProcessedTagsByIdResponse] + requireStorageRecommendedItemById *connect.Client[productv1.RequireStorageRecommendedItemByIdRequest, productv1.RequireStorageRecommendedItemByIdResponse] + requireStorageRecommendedItemsById *connect.Client[productv1.RequireStorageRecommendedItemsByIdRequest, productv1.RequireStorageRecommendedItemsByIdResponse] + requireStorageSecuritySummaryById *connect.Client[productv1.RequireStorageSecuritySummaryByIdRequest, productv1.RequireStorageSecuritySummaryByIdResponse] + requireStorageStockHealthScoreById *connect.Client[productv1.RequireStorageStockHealthScoreByIdRequest, productv1.RequireStorageStockHealthScoreByIdResponse] + requireStorageTagSummaryById *connect.Client[productv1.RequireStorageTagSummaryByIdRequest, productv1.RequireStorageTagSummaryByIdResponse] + requireStorageTagsByLengthsById *connect.Client[productv1.RequireStorageTagsByLengthsByIdRequest, productv1.RequireStorageTagsByLengthsByIdResponse] + requireWarehouseStockHealthScoreById *connect.Client[productv1.RequireWarehouseStockHealthScoreByIdRequest, productv1.RequireWarehouseStockHealthScoreByIdResponse] + resolveCategoryActiveSubcategories *connect.Client[productv1.ResolveCategoryActiveSubcategoriesRequest, productv1.ResolveCategoryActiveSubcategoriesResponse] + resolveCategoryCategoryMetrics *connect.Client[productv1.ResolveCategoryCategoryMetricsRequest, productv1.ResolveCategoryCategoryMetricsResponse] + resolveCategoryCategoryStatus *connect.Client[productv1.ResolveCategoryCategoryStatusRequest, productv1.ResolveCategoryCategoryStatusResponse] + resolveCategoryChildCategories *connect.Client[productv1.ResolveCategoryChildCategoriesRequest, productv1.ResolveCategoryChildCategoriesResponse] + resolveCategoryMascot *connect.Client[productv1.ResolveCategoryMascotRequest, productv1.ResolveCategoryMascotResponse] + resolveCategoryMetricsAverageScore *connect.Client[productv1.ResolveCategoryMetricsAverageScoreRequest, productv1.ResolveCategoryMetricsAverageScoreResponse] + resolveCategoryMetricsNormalizedScore *connect.Client[productv1.ResolveCategoryMetricsNormalizedScoreRequest, productv1.ResolveCategoryMetricsNormalizedScoreResponse] + resolveCategoryMetricsRelatedCategory *connect.Client[productv1.ResolveCategoryMetricsRelatedCategoryRequest, productv1.ResolveCategoryMetricsRelatedCategoryResponse] + resolveCategoryOptionalCategories *connect.Client[productv1.ResolveCategoryOptionalCategoriesRequest, productv1.ResolveCategoryOptionalCategoriesResponse] + resolveCategoryPopularityScore *connect.Client[productv1.ResolveCategoryPopularityScoreRequest, productv1.ResolveCategoryPopularityScoreResponse] + resolveCategoryProductCount *connect.Client[productv1.ResolveCategoryProductCountRequest, productv1.ResolveCategoryProductCountResponse] + resolveCategoryTopSubcategory *connect.Client[productv1.ResolveCategoryTopSubcategoryRequest, productv1.ResolveCategoryTopSubcategoryResponse] + resolveCategoryTotalProducts *connect.Client[productv1.ResolveCategoryTotalProductsRequest, productv1.ResolveCategoryTotalProductsResponse] + resolveProductMascotRecommendation *connect.Client[productv1.ResolveProductMascotRecommendationRequest, productv1.ResolveProductMascotRecommendationResponse] + resolveProductProductDetails *connect.Client[productv1.ResolveProductProductDetailsRequest, productv1.ResolveProductProductDetailsResponse] + resolveProductRecommendedCategory *connect.Client[productv1.ResolveProductRecommendedCategoryRequest, productv1.ResolveProductRecommendedCategoryResponse] + resolveProductShippingEstimate *connect.Client[productv1.ResolveProductShippingEstimateRequest, productv1.ResolveProductShippingEstimateResponse] + resolveProductStockStatus *connect.Client[productv1.ResolveProductStockStatusRequest, productv1.ResolveProductStockStatusResponse] + resolveStorageLinkedStorages *connect.Client[productv1.ResolveStorageLinkedStoragesRequest, productv1.ResolveStorageLinkedStoragesResponse] + resolveStorageNearbyStorages *connect.Client[productv1.ResolveStorageNearbyStoragesRequest, productv1.ResolveStorageNearbyStoragesResponse] + resolveStorageStorageStatus *connect.Client[productv1.ResolveStorageStorageStatusRequest, productv1.ResolveStorageStorageStatusResponse] + resolveSubcategoryFeaturedCategory *connect.Client[productv1.ResolveSubcategoryFeaturedCategoryRequest, productv1.ResolveSubcategoryFeaturedCategoryResponse] + resolveSubcategoryItemCount *connect.Client[productv1.ResolveSubcategoryItemCountRequest, productv1.ResolveSubcategoryItemCountResponse] + resolveSubcategoryParentCategory *connect.Client[productv1.ResolveSubcategoryParentCategoryRequest, productv1.ResolveSubcategoryParentCategoryResponse] + resolveTestContainerDetails *connect.Client[productv1.ResolveTestContainerDetailsRequest, productv1.ResolveTestContainerDetailsResponse] } // LookupProductById calls productv1.ProductService.LookupProductById. @@ -1469,18 +1513,36 @@ func (c *productServiceClient) RequireStorageOptionalLatestOperationById(ctx con return c.requireStorageOptionalLatestOperationById.CallUnary(ctx, req) } +// RequireStorageOptionalOperationHistoryById calls +// productv1.ProductService.RequireStorageOptionalOperationHistoryById. +func (c *productServiceClient) RequireStorageOptionalOperationHistoryById(ctx context.Context, req *connect.Request[productv1.RequireStorageOptionalOperationHistoryByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalOperationHistoryByIdResponse], error) { + return c.requireStorageOptionalOperationHistoryById.CallUnary(ctx, req) +} + // RequireStorageOptionalProcessedMetadataById calls // productv1.ProductService.RequireStorageOptionalProcessedMetadataById. func (c *productServiceClient) RequireStorageOptionalProcessedMetadataById(ctx context.Context, req *connect.Request[productv1.RequireStorageOptionalProcessedMetadataByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalProcessedMetadataByIdResponse], error) { return c.requireStorageOptionalProcessedMetadataById.CallUnary(ctx, req) } +// RequireStorageOptionalProcessedMetadataHistoryById calls +// productv1.ProductService.RequireStorageOptionalProcessedMetadataHistoryById. +func (c *productServiceClient) RequireStorageOptionalProcessedMetadataHistoryById(ctx context.Context, req *connect.Request[productv1.RequireStorageOptionalProcessedMetadataHistoryByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalProcessedMetadataHistoryByIdResponse], error) { + return c.requireStorageOptionalProcessedMetadataHistoryById.CallUnary(ctx, req) +} + // RequireStorageOptionalProcessedTagsById calls // productv1.ProductService.RequireStorageOptionalProcessedTagsById. func (c *productServiceClient) RequireStorageOptionalProcessedTagsById(ctx context.Context, req *connect.Request[productv1.RequireStorageOptionalProcessedTagsByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalProcessedTagsByIdResponse], error) { return c.requireStorageOptionalProcessedTagsById.CallUnary(ctx, req) } +// RequireStorageOptionalRecommendedItemsById calls +// productv1.ProductService.RequireStorageOptionalRecommendedItemsById. +func (c *productServiceClient) RequireStorageOptionalRecommendedItemsById(ctx context.Context, req *connect.Request[productv1.RequireStorageOptionalRecommendedItemsByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalRecommendedItemsByIdResponse], error) { + return c.requireStorageOptionalRecommendedItemsById.CallUnary(ctx, req) +} + // RequireStorageOptionalTagSummaryById calls // productv1.ProductService.RequireStorageOptionalTagSummaryById. func (c *productServiceClient) RequireStorageOptionalTagSummaryById(ctx context.Context, req *connect.Request[productv1.RequireStorageOptionalTagSummaryByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalTagSummaryByIdResponse], error) { @@ -1533,6 +1595,11 @@ func (c *productServiceClient) RequireStorageTagSummaryById(ctx context.Context, return c.requireStorageTagSummaryById.CallUnary(ctx, req) } +// RequireStorageTagsByLengthsById calls productv1.ProductService.RequireStorageTagsByLengthsById. +func (c *productServiceClient) RequireStorageTagsByLengthsById(ctx context.Context, req *connect.Request[productv1.RequireStorageTagsByLengthsByIdRequest]) (*connect.Response[productv1.RequireStorageTagsByLengthsByIdResponse], error) { + return c.requireStorageTagsByLengthsById.CallUnary(ctx, req) +} + // RequireWarehouseStockHealthScoreById calls // productv1.ProductService.RequireWarehouseStockHealthScoreById. func (c *productServiceClient) RequireWarehouseStockHealthScoreById(ctx context.Context, req *connect.Request[productv1.RequireWarehouseStockHealthScoreByIdRequest]) (*connect.Response[productv1.RequireWarehouseStockHealthScoreByIdResponse], error) { @@ -1739,8 +1806,11 @@ type ProductServiceHandler interface { RequireStorageNullableFilteredTagSummaryById(context.Context, *connect.Request[productv1.RequireStorageNullableFilteredTagSummaryByIdRequest]) (*connect.Response[productv1.RequireStorageNullableFilteredTagSummaryByIdResponse], error) RequireStorageOperationReportById(context.Context, *connect.Request[productv1.RequireStorageOperationReportByIdRequest]) (*connect.Response[productv1.RequireStorageOperationReportByIdResponse], error) RequireStorageOptionalLatestOperationById(context.Context, *connect.Request[productv1.RequireStorageOptionalLatestOperationByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalLatestOperationByIdResponse], error) + RequireStorageOptionalOperationHistoryById(context.Context, *connect.Request[productv1.RequireStorageOptionalOperationHistoryByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalOperationHistoryByIdResponse], error) RequireStorageOptionalProcessedMetadataById(context.Context, *connect.Request[productv1.RequireStorageOptionalProcessedMetadataByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalProcessedMetadataByIdResponse], error) + RequireStorageOptionalProcessedMetadataHistoryById(context.Context, *connect.Request[productv1.RequireStorageOptionalProcessedMetadataHistoryByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalProcessedMetadataHistoryByIdResponse], error) RequireStorageOptionalProcessedTagsById(context.Context, *connect.Request[productv1.RequireStorageOptionalProcessedTagsByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalProcessedTagsByIdResponse], error) + RequireStorageOptionalRecommendedItemsById(context.Context, *connect.Request[productv1.RequireStorageOptionalRecommendedItemsByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalRecommendedItemsByIdResponse], error) RequireStorageOptionalTagSummaryById(context.Context, *connect.Request[productv1.RequireStorageOptionalTagSummaryByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalTagSummaryByIdResponse], error) RequireStorageProcessedMetadataById(context.Context, *connect.Request[productv1.RequireStorageProcessedMetadataByIdRequest]) (*connect.Response[productv1.RequireStorageProcessedMetadataByIdResponse], error) RequireStorageProcessedMetadataHistoryById(context.Context, *connect.Request[productv1.RequireStorageProcessedMetadataHistoryByIdRequest]) (*connect.Response[productv1.RequireStorageProcessedMetadataHistoryByIdResponse], error) @@ -1750,6 +1820,7 @@ type ProductServiceHandler interface { RequireStorageSecuritySummaryById(context.Context, *connect.Request[productv1.RequireStorageSecuritySummaryByIdRequest]) (*connect.Response[productv1.RequireStorageSecuritySummaryByIdResponse], error) RequireStorageStockHealthScoreById(context.Context, *connect.Request[productv1.RequireStorageStockHealthScoreByIdRequest]) (*connect.Response[productv1.RequireStorageStockHealthScoreByIdResponse], error) RequireStorageTagSummaryById(context.Context, *connect.Request[productv1.RequireStorageTagSummaryByIdRequest]) (*connect.Response[productv1.RequireStorageTagSummaryByIdResponse], error) + RequireStorageTagsByLengthsById(context.Context, *connect.Request[productv1.RequireStorageTagsByLengthsByIdRequest]) (*connect.Response[productv1.RequireStorageTagsByLengthsByIdResponse], error) RequireWarehouseStockHealthScoreById(context.Context, *connect.Request[productv1.RequireWarehouseStockHealthScoreByIdRequest]) (*connect.Response[productv1.RequireWarehouseStockHealthScoreByIdResponse], error) ResolveCategoryActiveSubcategories(context.Context, *connect.Request[productv1.ResolveCategoryActiveSubcategoriesRequest]) (*connect.Response[productv1.ResolveCategoryActiveSubcategoriesResponse], error) ResolveCategoryCategoryMetrics(context.Context, *connect.Request[productv1.ResolveCategoryCategoryMetricsRequest]) (*connect.Response[productv1.ResolveCategoryCategoryMetricsResponse], error) @@ -2157,18 +2228,36 @@ func NewProductServiceHandler(svc ProductServiceHandler, opts ...connect.Handler connect.WithSchema(productServiceMethods.ByName("RequireStorageOptionalLatestOperationById")), connect.WithHandlerOptions(opts...), ) + productServiceRequireStorageOptionalOperationHistoryByIdHandler := connect.NewUnaryHandler( + ProductServiceRequireStorageOptionalOperationHistoryByIdProcedure, + svc.RequireStorageOptionalOperationHistoryById, + connect.WithSchema(productServiceMethods.ByName("RequireStorageOptionalOperationHistoryById")), + connect.WithHandlerOptions(opts...), + ) productServiceRequireStorageOptionalProcessedMetadataByIdHandler := connect.NewUnaryHandler( ProductServiceRequireStorageOptionalProcessedMetadataByIdProcedure, svc.RequireStorageOptionalProcessedMetadataById, connect.WithSchema(productServiceMethods.ByName("RequireStorageOptionalProcessedMetadataById")), connect.WithHandlerOptions(opts...), ) + productServiceRequireStorageOptionalProcessedMetadataHistoryByIdHandler := connect.NewUnaryHandler( + ProductServiceRequireStorageOptionalProcessedMetadataHistoryByIdProcedure, + svc.RequireStorageOptionalProcessedMetadataHistoryById, + connect.WithSchema(productServiceMethods.ByName("RequireStorageOptionalProcessedMetadataHistoryById")), + connect.WithHandlerOptions(opts...), + ) productServiceRequireStorageOptionalProcessedTagsByIdHandler := connect.NewUnaryHandler( ProductServiceRequireStorageOptionalProcessedTagsByIdProcedure, svc.RequireStorageOptionalProcessedTagsById, connect.WithSchema(productServiceMethods.ByName("RequireStorageOptionalProcessedTagsById")), connect.WithHandlerOptions(opts...), ) + productServiceRequireStorageOptionalRecommendedItemsByIdHandler := connect.NewUnaryHandler( + ProductServiceRequireStorageOptionalRecommendedItemsByIdProcedure, + svc.RequireStorageOptionalRecommendedItemsById, + connect.WithSchema(productServiceMethods.ByName("RequireStorageOptionalRecommendedItemsById")), + connect.WithHandlerOptions(opts...), + ) productServiceRequireStorageOptionalTagSummaryByIdHandler := connect.NewUnaryHandler( ProductServiceRequireStorageOptionalTagSummaryByIdProcedure, svc.RequireStorageOptionalTagSummaryById, @@ -2223,6 +2312,12 @@ func NewProductServiceHandler(svc ProductServiceHandler, opts ...connect.Handler connect.WithSchema(productServiceMethods.ByName("RequireStorageTagSummaryById")), connect.WithHandlerOptions(opts...), ) + productServiceRequireStorageTagsByLengthsByIdHandler := connect.NewUnaryHandler( + ProductServiceRequireStorageTagsByLengthsByIdProcedure, + svc.RequireStorageTagsByLengthsById, + connect.WithSchema(productServiceMethods.ByName("RequireStorageTagsByLengthsById")), + connect.WithHandlerOptions(opts...), + ) productServiceRequireWarehouseStockHealthScoreByIdHandler := connect.NewUnaryHandler( ProductServiceRequireWarehouseStockHealthScoreByIdProcedure, svc.RequireWarehouseStockHealthScoreById, @@ -2505,10 +2600,16 @@ func NewProductServiceHandler(svc ProductServiceHandler, opts ...connect.Handler productServiceRequireStorageOperationReportByIdHandler.ServeHTTP(w, r) case ProductServiceRequireStorageOptionalLatestOperationByIdProcedure: productServiceRequireStorageOptionalLatestOperationByIdHandler.ServeHTTP(w, r) + case ProductServiceRequireStorageOptionalOperationHistoryByIdProcedure: + productServiceRequireStorageOptionalOperationHistoryByIdHandler.ServeHTTP(w, r) case ProductServiceRequireStorageOptionalProcessedMetadataByIdProcedure: productServiceRequireStorageOptionalProcessedMetadataByIdHandler.ServeHTTP(w, r) + case ProductServiceRequireStorageOptionalProcessedMetadataHistoryByIdProcedure: + productServiceRequireStorageOptionalProcessedMetadataHistoryByIdHandler.ServeHTTP(w, r) case ProductServiceRequireStorageOptionalProcessedTagsByIdProcedure: productServiceRequireStorageOptionalProcessedTagsByIdHandler.ServeHTTP(w, r) + case ProductServiceRequireStorageOptionalRecommendedItemsByIdProcedure: + productServiceRequireStorageOptionalRecommendedItemsByIdHandler.ServeHTTP(w, r) case ProductServiceRequireStorageOptionalTagSummaryByIdProcedure: productServiceRequireStorageOptionalTagSummaryByIdHandler.ServeHTTP(w, r) case ProductServiceRequireStorageProcessedMetadataByIdProcedure: @@ -2527,6 +2628,8 @@ func NewProductServiceHandler(svc ProductServiceHandler, opts ...connect.Handler productServiceRequireStorageStockHealthScoreByIdHandler.ServeHTTP(w, r) case ProductServiceRequireStorageTagSummaryByIdProcedure: productServiceRequireStorageTagSummaryByIdHandler.ServeHTTP(w, r) + case ProductServiceRequireStorageTagsByLengthsByIdProcedure: + productServiceRequireStorageTagsByLengthsByIdHandler.ServeHTTP(w, r) case ProductServiceRequireWarehouseStockHealthScoreByIdProcedure: productServiceRequireWarehouseStockHealthScoreByIdHandler.ServeHTTP(w, r) case ProductServiceResolveCategoryActiveSubcategoriesProcedure: @@ -2836,14 +2939,26 @@ func (UnimplementedProductServiceHandler) RequireStorageOptionalLatestOperationB return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.RequireStorageOptionalLatestOperationById is not implemented")) } +func (UnimplementedProductServiceHandler) RequireStorageOptionalOperationHistoryById(context.Context, *connect.Request[productv1.RequireStorageOptionalOperationHistoryByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalOperationHistoryByIdResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.RequireStorageOptionalOperationHistoryById is not implemented")) +} + func (UnimplementedProductServiceHandler) RequireStorageOptionalProcessedMetadataById(context.Context, *connect.Request[productv1.RequireStorageOptionalProcessedMetadataByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalProcessedMetadataByIdResponse], error) { return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.RequireStorageOptionalProcessedMetadataById is not implemented")) } +func (UnimplementedProductServiceHandler) RequireStorageOptionalProcessedMetadataHistoryById(context.Context, *connect.Request[productv1.RequireStorageOptionalProcessedMetadataHistoryByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalProcessedMetadataHistoryByIdResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.RequireStorageOptionalProcessedMetadataHistoryById is not implemented")) +} + func (UnimplementedProductServiceHandler) RequireStorageOptionalProcessedTagsById(context.Context, *connect.Request[productv1.RequireStorageOptionalProcessedTagsByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalProcessedTagsByIdResponse], error) { return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.RequireStorageOptionalProcessedTagsById is not implemented")) } +func (UnimplementedProductServiceHandler) RequireStorageOptionalRecommendedItemsById(context.Context, *connect.Request[productv1.RequireStorageOptionalRecommendedItemsByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalRecommendedItemsByIdResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.RequireStorageOptionalRecommendedItemsById is not implemented")) +} + func (UnimplementedProductServiceHandler) RequireStorageOptionalTagSummaryById(context.Context, *connect.Request[productv1.RequireStorageOptionalTagSummaryByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalTagSummaryByIdResponse], error) { return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.RequireStorageOptionalTagSummaryById is not implemented")) } @@ -2880,6 +2995,10 @@ func (UnimplementedProductServiceHandler) RequireStorageTagSummaryById(context.C return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.RequireStorageTagSummaryById is not implemented")) } +func (UnimplementedProductServiceHandler) RequireStorageTagsByLengthsById(context.Context, *connect.Request[productv1.RequireStorageTagsByLengthsByIdRequest]) (*connect.Response[productv1.RequireStorageTagsByLengthsByIdResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.RequireStorageTagsByLengthsById is not implemented")) +} + func (UnimplementedProductServiceHandler) RequireWarehouseStockHealthScoreById(context.Context, *connect.Request[productv1.RequireWarehouseStockHealthScoreByIdRequest]) (*connect.Response[productv1.RequireWarehouseStockHealthScoreByIdResponse], error) { return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.RequireWarehouseStockHealthScoreById is not implemented")) } diff --git a/v2/pkg/grpctest/schema.go b/v2/pkg/grpctest/schema.go index b02ad699e3..b0d606a628 100644 --- a/v2/pkg/grpctest/schema.go +++ b/v2/pkg/grpctest/schema.go @@ -553,6 +553,16 @@ func GetFieldConfigurations() plan.FieldConfigurations { }, }, }, + { + TypeName: "Storage", + FieldName: "tagsByLengths", + Arguments: []plan.ArgumentConfiguration{ + { + Name: "lengths", + SourceType: plan.FieldArgumentSource, + }, + }, + }, { TypeName: "Category", FieldName: "productCount", @@ -814,6 +824,26 @@ func GetDataSourceMetadata() *plan.DataSourceMetadata { FieldName: "nullableFilteredTagSummary", SelectionSet: "tags", }, + { + TypeName: "Storage", + FieldName: "optionalProcessedMetadataHistory", + SelectionSet: "metadataHistory { capacity zone }", + }, + { + TypeName: "Storage", + FieldName: "optionalRecommendedItems", + SelectionSet: "tags", + }, + { + TypeName: "Storage", + FieldName: "optionalOperationHistory", + SelectionSet: "storageKind", + }, + { + TypeName: "Storage", + FieldName: "tagsByLengths", + SelectionSet: "tags", + }, { TypeName: "Warehouse", FieldName: "stockHealthScore", @@ -924,6 +954,10 @@ func GetDataSourceMetadata() *plan.DataSourceMetadata { "filteredTagSummary", "multiFilteredTagSummary", "nullableFilteredTagSummary", + "optionalProcessedMetadataHistory", + "optionalRecommendedItems", + "optionalOperationHistory", + "tagsByLengths", }, ExternalFieldNames: []string{ "itemCount", @@ -1009,6 +1043,10 @@ func GetDataSourceMetadata() *plan.DataSourceMetadata { "filteredTagSummary", "multiFilteredTagSummary", "nullableFilteredTagSummary", + "optionalProcessedMetadataHistory", + "optionalRecommendedItems", + "optionalOperationHistory", + "tagsByLengths", }, ExternalFieldNames: []string{ "itemCount", diff --git a/v2/pkg/grpctest/testdata/products.graphqls b/v2/pkg/grpctest/testdata/products.graphqls index 42cc3944eb..cbd10eb4d9 100644 --- a/v2/pkg/grpctest/testdata/products.graphqls +++ b/v2/pkg/grpctest/testdata/products.graphqls @@ -30,7 +30,7 @@ type Storage @key(fields: "id") { optionalTags: [String!] @external metadata: StorageMetadata! @external metadataHistory: [StorageMetadata!]! @external - + # @requires fields returning scalars tagSummary: String! @requires(fields: "tags") optionalTagSummary: String @requires(fields: "optionalTags") @@ -47,6 +47,16 @@ type Storage @key(fields: "id") { # @requires fields returning lists of complex types processedMetadataHistory: [StorageMetadata!]! @requires(fields: "metadataHistory { capacity zone }") + # @requires fields returning nullable lists. + # A nullable list is modelled with a ListOfX wrapper message so that a null list can be + # distinguished from an empty one. The wrapper must be emitted even when no other field + # in the schema registers it. + # Pattern A: nullable list of a concrete object type -> ListOfStorageMetadata + optionalProcessedMetadataHistory: [StorageMetadata!] @requires(fields: "metadataHistory { capacity zone }") + + # @requires field with a nullable list field argument -> ListOfInt + tagsByLengths(lengths: [Int!]): [String!] @requires(fields: "tags") + # External enum field for direct @requires testing storageKind: CategoryKind! @external @@ -85,6 +95,10 @@ type Storage @key(fields: "id") { latestOperation: StorageOperationResult! @requires(fields: "storageKind") # Pattern 10: nullable union return type optionalLatestOperation: StorageOperationResult @requires(fields: "optionalTags") + # Pattern B: nullable list of an interface type -> ListOfStorageItem + optionalRecommendedItems: [StorageItem!] @requires(fields: "tags") + # Pattern C: nullable list of a union type -> ListOfStorageOperationResult + optionalOperationHistory: [StorageOperationResult!] @requires(fields: "storageKind") # @connect_fieldResolver fields storageStatus(checkHealth: Boolean!): ActionResult! @connect__fieldResolver(context: "id name")