diff --git a/execution/engine/execution_engine_grpc_requires_test.go b/execution/engine/execution_engine_grpc_requires_test.go index 3af6636c94..096dac40e4 100644 --- a/execution/engine/execution_engine_grpc_requires_test.go +++ b/execution/engine/execution_engine_grpc_requires_test.go @@ -39,11 +39,26 @@ const requiresSupergraphSDL = ` itemCount: Int! restockData: RestockData! tags: [String!]! + optionalTags: [String!] metadata: StorageMetadata! + storageKind: CategoryKind! + primaryItem: StorageItem! + lastStorageOperation: StorageOperationResult! + securitySetup: SecuritySetup! stockHealthScore: Float! tagSummary: String! metadataScore: Float! filteredTagSummary(prefix: String!): String + itemInfo: String! + operationReport: String! + securitySummary: String! + itemHandlerInfo: String! + itemSpecsInfo: String! + deepItemInfo: String! + recommendedItem: StorageItem! + recommendedItems: [StorageItem!]! + latestOperation: StorageOperationResult! + optionalLatestOperation: StorageOperationResult } type Warehouse { @@ -64,6 +79,84 @@ const requiresSupergraphSDL = ` zone: String! priority: Int! } +` + compositeTypeDefinitions + +// compositeTypeDefinitions holds the abstract types (interface/union) and their members used by the +// composite-type @requires cases. They are shared verbatim by the supergraph and the owning subgraph +// SDL: as value types both subgraphs know them, the owning subgraph produces them as @requires input +// and the gRPC subgraph returns them from @requires fields. +const compositeTypeDefinitions = ` + enum CategoryKind { + BOOK + ELECTRONICS + FURNITURE + OTHER + } + + interface StorageItem { + id: ID! + name: String! + weight: Float! + } + + type PalletItem implements StorageItem { + id: ID! + name: String! + weight: Float! + palletCount: Int! + handler: ItemHandler! + specs: PalletSpecs! + } + + type ContainerItem implements StorageItem { + id: ID! + name: String! + weight: Float! + containerSize: String! + handler: ItemHandler! + specs: ContainerSpecs! + } + + type ItemHandler { + id: ID! + name: String! + assignedItem: StorageItem! + } + + type PalletSpecs { + name: String! + maxWeight: Float! + dimensions: Dimensions! + } + + type ContainerSpecs { + name: String! + volume: Float! + dimensions: Dimensions! + } + + type Dimensions { + length: Float! + width: Float! + height: Float! + } + + union StorageOperationResult = StorageSuccess | StorageFailure + + type StorageSuccess { + message: String! + completedAt: String! + } + + type StorageFailure { + message: String! + errorCode: String! + } + + type SecuritySetup { + securityLevel: String! + primaryItem: StorageItem! + } ` // owningSubgraphSDL is the single, shared SDL for the "owning" subgraph across all @requires cases. @@ -80,7 +173,12 @@ const owningSubgraphSDL = ` itemCount: Int! restockData: RestockData! tags: [String!]! + optionalTags: [String!] metadata: StorageMetadata! + storageKind: CategoryKind! + primaryItem: StorageItem! + lastStorageOperation: StorageOperationResult! + securitySetup: SecuritySetup! } type Warehouse @key(fields: "id") { @@ -97,7 +195,7 @@ const owningSubgraphSDL = ` capacity: Int! zone: String! } -` +` + compositeTypeDefinitions // requiresFieldConfigurations covers the arguments of every field the test operations use: the // entity root fields and the @requires field that also takes an argument. @@ -127,12 +225,24 @@ func newOwningSubgraphMetadata() *plan.DataSourceMetadata { return &plan.DataSourceMetadata{ RootNodes: []plan.TypeField{ {TypeName: "Query", FieldNames: []string{"storageProvider", "warehouseProvider"}}, - {TypeName: "Storage", FieldNames: []string{"id", "itemCount", "restockData", "tags", "metadata"}}, + {TypeName: "Storage", FieldNames: []string{"id", "itemCount", "restockData", "tags", "optionalTags", "metadata", "storageKind", "primaryItem", "lastStorageOperation", "securitySetup"}}, {TypeName: "Warehouse", FieldNames: []string{"id", "inventoryCount", "restockData"}}, }, ChildNodes: []plan.TypeField{ {TypeName: "RestockData", FieldNames: []string{"lastRestockDate"}}, {TypeName: "StorageMetadata", FieldNames: []string{"capacity", "zone"}}, + // The abstract types and their members are value types owned by both subgraphs. The owning + // subgraph produces them as @requires input for the gRPC subgraph. + {TypeName: "StorageItem", FieldNames: []string{"id", "name", "weight"}}, + {TypeName: "PalletItem", FieldNames: []string{"id", "name", "weight", "palletCount", "handler", "specs"}}, + {TypeName: "ContainerItem", FieldNames: []string{"id", "name", "weight", "containerSize", "handler", "specs"}}, + {TypeName: "ItemHandler", FieldNames: []string{"id", "name", "assignedItem"}}, + {TypeName: "PalletSpecs", FieldNames: []string{"name", "maxWeight", "dimensions"}}, + {TypeName: "ContainerSpecs", FieldNames: []string{"name", "volume", "dimensions"}}, + {TypeName: "Dimensions", FieldNames: []string{"length", "width", "height"}}, + {TypeName: "StorageSuccess", FieldNames: []string{"message", "completedAt"}}, + {TypeName: "StorageFailure", FieldNames: []string{"message", "errorCode"}}, + {TypeName: "SecuritySetup", FieldNames: []string{"securityLevel", "primaryItem"}}, }, FederationMetaData: plan.FederationMetaData{ Keys: plan.FederationFieldConfigurations{ @@ -235,6 +345,167 @@ func TestGRPCSubgraphRequiresFullExecution(t *testing.T) { } } +// TestGRPCSubgraphRequiresCompositeTypesFullExecution exercises @requires against composite +// (abstract) types end-to-end: the owning subgraph is asked for a representation containing an +// interface/union, the representation travels to the gRPC subgraph, and the gRPC subgraph resolves +// the @requires field. Two directions are covered: +// +// - abstract types inside the @requires selection set (itemInfo, operationReport, +// securitySummary, itemHandlerInfo, itemSpecsInfo, deepItemInfo) — here the concrete member has +// to be written into the request's protobuf oneof. +// - abstract types as the @requires field's return type (recommendedItem, recommendedItems, +// latestOperation, optionalLatestOperation) — here the concrete member has to be read back out +// of the response's oneof, so that __typename reports the concrete type and only the matching +// inline fragment's fields are returned. +func TestGRPCSubgraphRequiresCompositeTypesFullExecution(t *testing.T) { + t.Parallel() + + conn := setupGRPCTestGoPluginServer(t) + + testCases := []requiresTestCase{ + { + // Pattern 1: flat interface in the @requires selection set. The owning subgraph resolves + // primaryItem to a PalletItem, so the mock must see the PalletItem oneof member. + name: "Storage @requires an interface with inline fragments", + owningResponseJSON: `{"data":{"storageProvider":{"__typename":"Storage","id":"1","primaryItem":{"__typename":"PalletItem","name":"Euro pallet","palletCount":12}}}}`, + operation: `query { storageProvider(id: "1") { itemInfo } }`, + assert: expectJSON(`{"data":{"storageProvider":{"itemInfo":"Pallet: Euro pallet (count: 12)"}}}`), + }, + { + // Pattern 2: flat union in the @requires selection set, resolved to the failure member. + name: "Storage @requires a union with inline fragments", + owningResponseJSON: `{"data":{"storageProvider":{"__typename":"Storage","id":"1","lastStorageOperation":{"__typename":"StorageFailure","message":"Disk full","errorCode":"E_DISK"}}}}`, + operation: `query { storageProvider(id: "1") { operationReport } }`, + assert: expectJSON(`{"data":{"storageProvider":{"operationReport":"Failure: Disk full (code: E_DISK)"}}}`), + }, + { + // Pattern 3: concrete type (SecuritySetup) wrapping an abstract type. + name: "Storage @requires a concrete type wrapping an interface", + owningResponseJSON: `{"data":{"storageProvider":{"__typename":"Storage","id":"1","securitySetup":{"__typename":"SecuritySetup","securityLevel":"HIGH","primaryItem":{"__typename":"ContainerItem","name":"Reefer","containerSize":"40ft"}}}}}`, + operation: `query { storageProvider(id: "1") { securitySummary } }`, + assert: expectJSON(`{"data":{"storageProvider":{"securitySummary":"[HIGH] Container: Reefer (size: 40ft)"}}}`), + }, + { + // Pattern 4: concrete message (handler) selected inside an inline fragment. + name: "Storage @requires a concrete type inside an inline fragment", + owningResponseJSON: `{"data":{"storageProvider":{"__typename":"Storage","id":"1","primaryItem":{"__typename":"ContainerItem","handler":{"__typename":"ItemHandler","name":"Dock crew"}}}}}`, + operation: `query { storageProvider(id: "1") { itemHandlerInfo } }`, + assert: expectJSON(`{"data":{"storageProvider":{"itemHandlerInfo":"ContainerHandler: Dock crew"}}}`), + }, + { + // Pattern 5: deep concrete nesting (specs → dimensions) inside an inline fragment. + name: "Storage @requires deeply nested concrete types inside an inline fragment", + owningResponseJSON: `{"data":{"storageProvider":{"__typename":"Storage","id":"1","primaryItem":{"__typename":"PalletItem","specs":{"__typename":"PalletSpecs","name":"EUR-1","dimensions":{"__typename":"Dimensions","length":120,"width":80}}}}}}`, + operation: `query { storageProvider(id: "1") { itemSpecsInfo } }`, + assert: expectJSON(`{"data":{"storageProvider":{"itemSpecsInfo":"PalletSpecs: EUR-1 (120.0x80.0)"}}}`), + }, + { + // Pattern 6: a second abstract type nested behind a concrete intermediary + // (primaryItem → handler → assignedItem), so two oneofs have to be written per request. + name: "Storage @requires a nested interface behind a concrete intermediary", + owningResponseJSON: `{"data":{"storageProvider":{"__typename":"Storage","id":"1","primaryItem":{"__typename":"PalletItem","handler":{"__typename":"ItemHandler","assignedItem":{"__typename":"ContainerItem","name":"Nested reefer","containerSize":"20ft"}}}}}}`, + operation: `query { storageProvider(id: "1") { deepItemInfo } }`, + assert: expectJSON(`{"data":{"storageProvider":{"deepItemInfo":"PalletHandler->Container: Nested reefer (size: 20ft)"}}}`), + }, + { + // Pattern 7: the @requires field returns an interface. capacity 200 > 100 => PalletItem, + // palletCount = capacity / 10 = 20, weight = palletCount * 12.5 = 250. Interface fields are + // selected directly next to the inline fragments. + name: "Storage @requires field returning an interface", + owningResponseJSON: `{"data":{"storageProvider":{"__typename":"Storage","id":"1","metadata":{"__typename":"StorageMetadata","capacity":200,"zone":"A"}}}}`, + operation: `query { storageProvider(id: "1") { recommendedItem { __typename id name weight ... on PalletItem { palletCount } ... on ContainerItem { containerSize } } } }`, + assert: expectJSON(`{"data":{"storageProvider":{"recommendedItem":{"__typename":"PalletItem","id":"pallet-A-200","name":"Pallet for zone A","weight":250,"palletCount":20}}}}`), + }, + { + // Pattern 7, other member and one level deeper: capacity 50 <= 100 => ContainerItem, whose + // handler.assignedItem is itself abstract and must resolve to its own concrete member. + name: "Storage @requires field returning an interface with a nested interface", + owningResponseJSON: `{"data":{"storageProvider":{"__typename":"Storage","id":"2","metadata":{"__typename":"StorageMetadata","capacity":50,"zone":"B"}}}}`, + operation: `query { storageProvider(id: "2") { recommendedItem { __typename ... on PalletItem { name palletCount } ... on ContainerItem { name containerSize handler { name assignedItem { __typename ... on PalletItem { name palletCount } ... on ContainerItem { name containerSize } } } } } } }`, + assert: expectJSON(`{"data":{"storageProvider":{"recommendedItem":{"__typename":"ContainerItem","name":"Container for zone B","containerSize":"50L","handler":{"name":"Handler for Container for zone B","assignedItem":{"__typename":"PalletItem","name":"Container for zone B assigned pallet","palletCount":7}}}}}}`), + }, + { + // Pattern 8: the @requires field returns a list of an interface — one entry per required + // tag, alternating between both concrete members by index. + name: "Storage @requires field returning a list of an interface", + owningResponseJSON: `{"data":{"storageProvider":{"__typename":"Storage","id":"1","tags":["alpha","beta","gamma"]}}}`, + operation: `query { storageProvider(id: "1") { recommendedItems { __typename name ... on PalletItem { palletCount } ... on ContainerItem { containerSize } } } }`, + assert: expectJSON(`{"data":{"storageProvider":{"recommendedItems":[ + {"__typename":"PalletItem","name":"Pallet alpha","palletCount":1}, + {"__typename":"ContainerItem","name":"Container beta","containerSize":"BETA"}, + {"__typename":"PalletItem","name":"Pallet gamma","palletCount":3} + ]}}}`), + }, + { + // Pattern 8 with an empty required list: an empty list, not null. + name: "Storage @requires field returning an empty list of an interface", + owningResponseJSON: `{"data":{"storageProvider":{"__typename":"Storage","id":"1","tags":[]}}}`, + operation: `query { storageProvider(id: "1") { recommendedItems { __typename name } } }`, + assert: expectJSON(`{"data":{"storageProvider":{"recommendedItems":[]}}}`), + }, + { + // Pattern 9: the @requires field returns a union, keyed off the required enum. A known kind + // yields StorageSuccess, so the StorageFailure fragment must contribute nothing. + name: "Storage @requires field returning a union", + owningResponseJSON: `{"data":{"storageProvider":{"__typename":"Storage","id":"1","storageKind":"ELECTRONICS"}}}`, + operation: `query { storageProvider(id: "1") { latestOperation { __typename ... on StorageSuccess { message completedAt } ... on StorageFailure { message errorCode } } } }`, + assert: expectJSON(`{"data":{"storageProvider":{"latestOperation":{"__typename":"StorageSuccess","message":"Operation completed for CATEGORY_KIND_ELECTRONICS","completedAt":"2024-01-01T00:00:00Z"}}}}`), + }, + { + // Pattern 9, the other union member: an unknown kind yields StorageFailure. + name: "Storage @requires field returning the other union member", + owningResponseJSON: `{"data":{"storageProvider":{"__typename":"Storage","id":"1","storageKind":"OTHER"}}}`, + operation: `query { storageProvider(id: "1") { latestOperation { __typename ... on StorageSuccess { message completedAt } ... on StorageFailure { message errorCode } } } }`, + assert: expectJSON(`{"data":{"storageProvider":{"latestOperation":{"__typename":"StorageFailure","message":"Operation failed for CATEGORY_KIND_OTHER","errorCode":"UNSUPPORTED_KIND"}}}}`), + }, + { + // Pattern 10: nullable union return type. An odd number of required optional tags yields + // StorageSuccess. + name: "Storage @requires field returning a nullable union", + owningResponseJSON: `{"data":{"storageProvider":{"__typename":"Storage","id":"1","optionalTags":["alpha"]}}}`, + operation: `query { storageProvider(id: "1") { optionalLatestOperation { __typename ... on StorageSuccess { message completedAt } ... on StorageFailure { errorCode } } } }`, + assert: expectJSON(`{"data":{"storageProvider":{"optionalLatestOperation":{"__typename":"StorageSuccess","message":"Operation completed for tags: alpha","completedAt":"2024-01-02T00:00:00Z"}}}}`), + }, + { + // Pattern 10 with no required tags: the mock returns no union value at all, which must + // surface as null rather than an empty object or an error. + name: "Storage @requires field returning a nullable union resolves to null", + owningResponseJSON: `{"data":{"storageProvider":{"__typename":"Storage","id":"1","optionalTags":null}}}`, + operation: `query { storageProvider(id: "1") { optionalLatestOperation { __typename ... on StorageSuccess { message } ... on StorageFailure { errorCode } } } }`, + assert: expectJSON(`{"data":{"storageProvider":{"optionalLatestOperation":null}}}`), + }, + { + // Abstract return types alongside a scalar @requires field and the entity lookup, so all + // three kinds of gRPC call are planned against the same representation. + name: "Storage @requires abstract return types combined with a scalar field and a lookup", + owningResponseJSON: `{"data":{"storageProvider":{"__typename":"Storage","id":"1","tags":["alpha","beta"],"storageKind":"BOOK"}}}`, + operation: `query { storageProvider(id: "1") { name tagSummary recommendedItems { __typename name } latestOperation { __typename ... on StorageSuccess { message } ... on StorageFailure { errorCode } } } }`, + assert: expectJSON(`{"data":{"storageProvider":{ + "name":"Storage 1", + "tagSummary":"alpha, beta", + "recommendedItems":[ + {"__typename":"PalletItem","name":"Pallet alpha"}, + {"__typename":"ContainerItem","name":"Container beta"} + ], + "latestOperation":{"__typename":"StorageSuccess","message":"Operation completed for CATEGORY_KIND_BOOK"} + }}}`), + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + t.Parallel() + + owningDS := setupOwningSubgraph(t, tc.owningResponseJSON) + grpcDS := setupGRPCProductsSubgraph(t, conn) + + response := runRequiresOperation(t, []plan.DataSource{owningDS, grpcDS}, tc.operation) + + tc.assert(t, response) + }) + } +} + // setupOwningSubgraph builds the "owning" subgraph: a graphql_datasource over an httptest.Server // that returns responseJSON for any request. Its SDL (owningSubgraphSDL) and metadata are shared // across all cases; only responseJSON varies. It owns the entity root fields plus the fields the diff --git a/v2/pkg/engine/datasource/grpc_datasource/execution_plan.go b/v2/pkg/engine/datasource/grpc_datasource/execution_plan.go index 5dbae80ebd..d286c99dae 100644 --- a/v2/pkg/engine/datasource/grpc_datasource/execution_plan.go +++ b/v2/pkg/engine/datasource/grpc_datasource/execution_plan.go @@ -921,20 +921,26 @@ type fragmentSelection struct { selectionSetRef int } -// enterResolverCompositeSelectionSet handles logic when entering a composite selection set for a given field resolver. -// It appends the inline fragment selections to the resolved field and sets the fragment type. -func (r *rpcPlanningContext) enterResolverCompositeSelectionSet(oneOfType OneOfType, selectionSetRef int, resolvedField *resolverField) { - resolvedField.fieldsSelectionSetRef = ast.InvalidRef - resolvedField.fragmentType = oneOfType +type compositeTypeConfig struct { + oneOfType OneOfType + fieldsSelectionSetRef int + fragmentSelections []fragmentSelection +} + +func (r *rpcPlanningContext) buildCompositeTypeConfig(oneOfType OneOfType, selectionSetRef int) compositeTypeConfig { + config := compositeTypeConfig{ + oneOfType: oneOfType, + fieldsSelectionSetRef: ast.InvalidRef, + } // In case of an interface we can select individual fields from the interface without having to use an inline fragment. if len(r.operation.SelectionSetFieldRefs(selectionSetRef)) > 0 { - resolvedField.fieldsSelectionSetRef = selectionSetRef + config.fieldsSelectionSetRef = selectionSetRef } inlineFragSelections := r.operation.SelectionSetInlineFragmentSelections(selectionSetRef) if len(inlineFragSelections) == 0 { - return + return config } for _, inlineFragSelectionRef := range inlineFragSelections { @@ -944,11 +950,13 @@ func (r *rpcPlanningContext) enterResolverCompositeSelectionSet(oneOfType OneOfT continue } - resolvedField.fragmentSelections = append(resolvedField.fragmentSelections, fragmentSelection{ + config.fragmentSelections = append(config.fragmentSelections, fragmentSelection{ typeName: r.operation.InlineFragmentTypeConditionNameString(inlineFragRef), selectionSetRef: inlinFragSelectionSetRef, }) } + + return config } // isFieldResolver checks if a field is a field resolver. 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 c5bd4960d2..0d998b5080 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 @@ -3577,6 +3577,757 @@ func TestExecutionPlan_FederationRequires_AbstractTypes(t *testing.T) { } } +// TestExecutionPlan_FederationRequires_AbstractReturnTypes covers @requires fields whose +// *return* type is abstract (interface or union). This is distinct from +// TestExecutionPlan_FederationRequires_AbstractTypes, which covers abstract types appearing +// in the @requires *selection set*. +// +// The expected plans mirror the shape the field resolver path already produces for abstract +// return types (see TestExecutionPlan_EntityLookupWithFieldResolvers, Animal/ActionResult): +// the response message must carry OneOfType, MemberTypes and FragmentFields so the compiler +// can resolve the concrete member from the protobuf oneof. +func TestExecutionPlan_FederationRequires_AbstractReturnTypes(t *testing.T) { + t.Parallel() + + // storageEntityLookupCall returns the common entity lookup call shared by all tests + storageEntityLookupCall := func() RPCCall { + return RPCCall{ + ServiceName: "Products", + MethodName: "LookupStorageById", + Kind: CallKindEntity, + 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", + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + }, + }, + }, + }, + }, + } + } + + storageKeyMessage := func() *RPCMessage { + return &RPCMessage{ + Name: "LookupStorageByIdRequestKey", + MemberTypes: []string{"Storage"}, + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + }, + }, + } + } + + // storageItemMessage returns the expected StorageItem interface message for a response. + storageItemMessage := func() *RPCMessage { + return &RPCMessage{ + Name: "StorageItem", + OneOfType: OneOfTypeInterface, + MemberTypes: []string{"PalletItem", "ContainerItem"}, + FragmentFields: RPCFieldSelectionSet{ + "PalletItem": { + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + { + Name: "pallet_count", + ProtoTypeName: DataTypeInt32, + JSONPath: "palletCount", + }, + }, + "ContainerItem": { + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + { + Name: "container_size", + ProtoTypeName: DataTypeString, + JSONPath: "containerSize", + }, + }, + }, + } + } + + tests := []struct { + name string + query string + expectedPlan *RPCExecutionPlan + mapping *GRPCMapping + federationConfigs plan.FederationFieldConfigurations + }{ + { + name: "requires field returning an interface type", + query: `query EntityLookup($representations: [_Any!]!) { _entities(representations: $representations) { ... on Storage { __typename name recommendedItem { ... on PalletItem { name palletCount } ... on ContainerItem { name containerSize } } } } }`, + mapping: testMapping(), + federationConfigs: plan.FederationFieldConfigurations{ + { + TypeName: "Storage", + SelectionSet: "id", + }, + { + TypeName: "Storage", + FieldName: "recommendedItem", + SelectionSet: "metadata { capacity zone }", + }, + }, + expectedPlan: &RPCExecutionPlan{ + Calls: []RPCCall{ + storageEntityLookupCall(), + { + ID: 1, + ServiceName: "Products", + Kind: CallKindRequired, + MethodName: "RequireStorageRecommendedItemById", + ResponsePath: buildPath("_entities.recommendedItem"), + Request: RPCMessage{ + Name: "RequireStorageRecommendedItemByIdRequest", + Fields: []RPCField{ + { + Name: "context", + ProtoTypeName: DataTypeMessage, + Repeated: true, + JSONPath: "representations", + Message: &RPCMessage{ + Name: "RequireStorageRecommendedItemByIdContext", + Fields: []RPCField{ + { + Name: "key", + ProtoTypeName: DataTypeMessage, + Message: storageKeyMessage(), + }, + { + Name: "fields", + ProtoTypeName: DataTypeMessage, + Message: &RPCMessage{ + Name: "RequireStorageRecommendedItemByIdFields", + Fields: []RPCField{ + { + Name: "metadata", + ProtoTypeName: DataTypeMessage, + JSONPath: "metadata", + Message: &RPCMessage{ + Name: "RequireStorageRecommendedItemByIdFields.StorageMetadata", + Fields: []RPCField{ + { + Name: "capacity", + ProtoTypeName: DataTypeInt32, + JSONPath: "capacity", + }, + { + Name: "zone", + ProtoTypeName: DataTypeString, + JSONPath: "zone", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + Response: RPCMessage{ + Name: "RequireStorageRecommendedItemByIdResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + Repeated: true, + JSONPath: "result", + Message: &RPCMessage{ + Name: "RequireStorageRecommendedItemByIdResult", + Fields: RPCFields{ + { + Name: "recommended_item", + ProtoTypeName: DataTypeMessage, + JSONPath: "recommendedItem", + Message: storageItemMessage(), + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + { + name: "requires field returning an interface type with a nested interface type", + query: `query EntityLookup($representations: [_Any!]!) { _entities(representations: $representations) { ... on Storage { __typename name recommendedItem { ... on PalletItem { name handler { name assignedItem { ... on ContainerItem { name containerSize } ... on PalletItem { name palletCount } } } } ... on ContainerItem { name containerSize } } } } }`, + mapping: testMapping(), + federationConfigs: plan.FederationFieldConfigurations{ + { + TypeName: "Storage", + SelectionSet: "id", + }, + { + TypeName: "Storage", + FieldName: "recommendedItem", + SelectionSet: "metadata { capacity zone }", + }, + }, + expectedPlan: &RPCExecutionPlan{ + Calls: []RPCCall{ + storageEntityLookupCall(), + { + ID: 1, + ServiceName: "Products", + Kind: CallKindRequired, + MethodName: "RequireStorageRecommendedItemById", + ResponsePath: buildPath("_entities.recommendedItem"), + Request: RPCMessage{ + Name: "RequireStorageRecommendedItemByIdRequest", + Fields: []RPCField{ + { + Name: "context", + ProtoTypeName: DataTypeMessage, + Repeated: true, + JSONPath: "representations", + Message: &RPCMessage{ + Name: "RequireStorageRecommendedItemByIdContext", + Fields: []RPCField{ + { + Name: "key", + ProtoTypeName: DataTypeMessage, + Message: storageKeyMessage(), + }, + { + Name: "fields", + ProtoTypeName: DataTypeMessage, + Message: &RPCMessage{ + Name: "RequireStorageRecommendedItemByIdFields", + Fields: []RPCField{ + { + Name: "metadata", + ProtoTypeName: DataTypeMessage, + JSONPath: "metadata", + Message: &RPCMessage{ + Name: "RequireStorageRecommendedItemByIdFields.StorageMetadata", + Fields: []RPCField{ + { + Name: "capacity", + ProtoTypeName: DataTypeInt32, + JSONPath: "capacity", + }, + { + Name: "zone", + ProtoTypeName: DataTypeString, + JSONPath: "zone", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + Response: RPCMessage{ + Name: "RequireStorageRecommendedItemByIdResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + Repeated: true, + JSONPath: "result", + Message: &RPCMessage{ + Name: "RequireStorageRecommendedItemByIdResult", + Fields: RPCFields{ + { + Name: "recommended_item", + ProtoTypeName: DataTypeMessage, + JSONPath: "recommendedItem", + Message: &RPCMessage{ + Name: "StorageItem", + OneOfType: OneOfTypeInterface, + MemberTypes: []string{"PalletItem", "ContainerItem"}, + FragmentFields: RPCFieldSelectionSet{ + "PalletItem": { + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + { + Name: "handler", + ProtoTypeName: DataTypeMessage, + JSONPath: "handler", + Message: &RPCMessage{ + Name: "ItemHandler", + Fields: RPCFields{ + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + { + // The nested abstract type resolves through + // the concrete ItemHandler intermediary. + Name: "assigned_item", + ProtoTypeName: DataTypeMessage, + JSONPath: "assignedItem", + Message: &RPCMessage{ + Name: "StorageItem", + OneOfType: OneOfTypeInterface, + MemberTypes: []string{"PalletItem", "ContainerItem"}, + FragmentFields: RPCFieldSelectionSet{ + "PalletItem": { + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + { + Name: "pallet_count", + ProtoTypeName: DataTypeInt32, + JSONPath: "palletCount", + }, + }, + "ContainerItem": { + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + { + Name: "container_size", + ProtoTypeName: DataTypeString, + JSONPath: "containerSize", + }, + }, + }, + }, + }, + }, + }, + }, + }, + "ContainerItem": { + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + { + Name: "container_size", + ProtoTypeName: DataTypeString, + JSONPath: "containerSize", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + { + name: "requires field returning a list of an interface type", + query: `query EntityLookup($representations: [_Any!]!) { _entities(representations: $representations) { ... on Storage { __typename name recommendedItems { ... on PalletItem { name palletCount } ... on ContainerItem { name containerSize } } } } }`, + mapping: testMapping(), + federationConfigs: plan.FederationFieldConfigurations{ + { + TypeName: "Storage", + SelectionSet: "id", + }, + { + TypeName: "Storage", + FieldName: "recommendedItems", + SelectionSet: "tags", + }, + }, + expectedPlan: &RPCExecutionPlan{ + Calls: []RPCCall{ + storageEntityLookupCall(), + { + ID: 1, + ServiceName: "Products", + Kind: CallKindRequired, + MethodName: "RequireStorageRecommendedItemsById", + ResponsePath: buildPath("_entities.recommendedItems"), + Request: RPCMessage{ + Name: "RequireStorageRecommendedItemsByIdRequest", + Fields: []RPCField{ + { + Name: "context", + ProtoTypeName: DataTypeMessage, + Repeated: true, + JSONPath: "representations", + Message: &RPCMessage{ + Name: "RequireStorageRecommendedItemsByIdContext", + Fields: []RPCField{ + { + Name: "key", + ProtoTypeName: DataTypeMessage, + Message: storageKeyMessage(), + }, + { + Name: "fields", + ProtoTypeName: DataTypeMessage, + Message: &RPCMessage{ + Name: "RequireStorageRecommendedItemsByIdFields", + Fields: []RPCField{ + { + Name: "tags", + ProtoTypeName: DataTypeString, + Repeated: true, + JSONPath: "tags", + }, + }, + }, + }, + }, + }, + }, + }, + }, + Response: RPCMessage{ + Name: "RequireStorageRecommendedItemsByIdResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + Repeated: true, + JSONPath: "result", + Message: &RPCMessage{ + Name: "RequireStorageRecommendedItemsByIdResult", + Fields: RPCFields{ + { + Name: "recommended_items", + ProtoTypeName: DataTypeMessage, + Repeated: true, + JSONPath: "recommendedItems", + Message: storageItemMessage(), + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + { + name: "requires field returning a union type", + query: `query EntityLookup($representations: [_Any!]!) { _entities(representations: $representations) { ... on Storage { __typename name latestOperation { ... on StorageSuccess { message completedAt } ... on StorageFailure { message errorCode } } } } }`, + mapping: testMapping(), + federationConfigs: plan.FederationFieldConfigurations{ + { + TypeName: "Storage", + SelectionSet: "id", + }, + { + TypeName: "Storage", + FieldName: "latestOperation", + SelectionSet: "storageKind", + }, + }, + expectedPlan: &RPCExecutionPlan{ + Calls: []RPCCall{ + storageEntityLookupCall(), + { + ID: 1, + ServiceName: "Products", + Kind: CallKindRequired, + MethodName: "RequireStorageLatestOperationById", + ResponsePath: buildPath("_entities.latestOperation"), + Request: RPCMessage{ + Name: "RequireStorageLatestOperationByIdRequest", + Fields: []RPCField{ + { + Name: "context", + ProtoTypeName: DataTypeMessage, + Repeated: true, + JSONPath: "representations", + Message: &RPCMessage{ + Name: "RequireStorageLatestOperationByIdContext", + Fields: []RPCField{ + { + Name: "key", + ProtoTypeName: DataTypeMessage, + Message: storageKeyMessage(), + }, + { + Name: "fields", + ProtoTypeName: DataTypeMessage, + Message: &RPCMessage{ + Name: "RequireStorageLatestOperationByIdFields", + Fields: []RPCField{ + { + Name: "storage_kind", + ProtoTypeName: DataTypeEnum, + JSONPath: "storageKind", + EnumName: "CategoryKind", + }, + }, + }, + }, + }, + }, + }, + }, + }, + Response: RPCMessage{ + Name: "RequireStorageLatestOperationByIdResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + Repeated: true, + JSONPath: "result", + Message: &RPCMessage{ + Name: "RequireStorageLatestOperationByIdResult", + Fields: RPCFields{ + { + Name: "latest_operation", + ProtoTypeName: DataTypeMessage, + JSONPath: "latestOperation", + Message: &RPCMessage{ + Name: "StorageOperationResult", + OneOfType: OneOfTypeUnion, + MemberTypes: []string{"StorageSuccess", "StorageFailure"}, + FragmentFields: RPCFieldSelectionSet{ + "StorageSuccess": { + { + Name: "message", + ProtoTypeName: DataTypeString, + JSONPath: "message", + }, + { + Name: "completed_at", + ProtoTypeName: DataTypeString, + JSONPath: "completedAt", + }, + }, + "StorageFailure": { + { + Name: "message", + ProtoTypeName: DataTypeString, + JSONPath: "message", + }, + { + Name: "error_code", + ProtoTypeName: DataTypeString, + JSONPath: "errorCode", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + { + name: "requires field returning a nullable union type", + query: `query EntityLookup($representations: [_Any!]!) { _entities(representations: $representations) { ... on Storage { __typename name optionalLatestOperation { ... on StorageSuccess { message } ... on StorageFailure { errorCode } } } } }`, + mapping: testMapping(), + federationConfigs: plan.FederationFieldConfigurations{ + { + TypeName: "Storage", + SelectionSet: "id", + }, + { + TypeName: "Storage", + FieldName: "optionalLatestOperation", + SelectionSet: "optionalTags", + }, + }, + expectedPlan: &RPCExecutionPlan{ + Calls: []RPCCall{ + storageEntityLookupCall(), + { + ID: 1, + ServiceName: "Products", + Kind: CallKindRequired, + MethodName: "RequireStorageOptionalLatestOperationById", + ResponsePath: buildPath("_entities.optionalLatestOperation"), + Request: RPCMessage{ + Name: "RequireStorageOptionalLatestOperationByIdRequest", + Fields: []RPCField{ + { + Name: "context", + ProtoTypeName: DataTypeMessage, + Repeated: true, + JSONPath: "representations", + Message: &RPCMessage{ + Name: "RequireStorageOptionalLatestOperationByIdContext", + Fields: []RPCField{ + { + Name: "key", + ProtoTypeName: DataTypeMessage, + Message: storageKeyMessage(), + }, + { + Name: "fields", + ProtoTypeName: DataTypeMessage, + Message: &RPCMessage{ + Name: "RequireStorageOptionalLatestOperationByIdFields", + Fields: []RPCField{ + { + Name: "optional_tags", + ProtoTypeName: DataTypeString, + JSONPath: "optionalTags", + Optional: true, + IsListType: true, + ListMetadata: &ListMetadata{ + NestingLevel: 1, + LevelInfo: []LevelInfo{{Optional: true}}, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + Response: RPCMessage{ + Name: "RequireStorageOptionalLatestOperationByIdResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + Repeated: true, + JSONPath: "result", + Message: &RPCMessage{ + Name: "RequireStorageOptionalLatestOperationByIdResult", + Fields: RPCFields{ + { + Name: "optional_latest_operation", + ProtoTypeName: DataTypeMessage, + JSONPath: "optionalLatestOperation", + Optional: true, + Message: &RPCMessage{ + Name: "StorageOperationResult", + OneOfType: OneOfTypeUnion, + MemberTypes: []string{"StorageSuccess", "StorageFailure"}, + FragmentFields: RPCFieldSelectionSet{ + "StorageSuccess": { + { + Name: "message", + ProtoTypeName: DataTypeString, + JSONPath: "message", + }, + }, + "StorageFailure": { + { + Name: "error_code", + ProtoTypeName: DataTypeString, + JSONPath: "errorCode", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + t.Parallel() + // Parse the GraphQL schema + schemaDoc := grpctest.MustGraphQLSchema(t) + + // Parse the GraphQL query + queryDoc, report := astparser.ParseGraphqlDocumentString(tt.query) + if report.HasErrors() { + t.Fatalf("failed to parse query: %s", report.Error()) + } + + planner, err := NewPlanner("Products", tt.mapping, tt.federationConfigs) + if err != nil { + t.Fatalf("failed to create planner: %s", err) + } + plan, err := planner.PlanOperation(&queryDoc, &schemaDoc) + if err != nil { + t.Fatalf("failed to plan operation: %s", err) + } + + diff := cmp.Diff(tt.expectedPlan, plan) + if diff != "" { + t.Fatalf("execution plan mismatch: %s", diff) + } + }) + } +} + func TestExecutionPlan_FederationRequires_WithFieldResolvers(t *testing.T) { t.Parallel() diff --git a/v2/pkg/engine/datasource/grpc_datasource/execution_plan_visitor.go b/v2/pkg/engine/datasource/grpc_datasource/execution_plan_visitor.go index 649b1fa5ca..7645ee3a64 100644 --- a/v2/pkg/engine/datasource/grpc_datasource/execution_plan_visitor.go +++ b/v2/pkg/engine/datasource/grpc_datasource/execution_plan_visitor.go @@ -212,7 +212,12 @@ func (r *rpcPlanVisitor) EnterSelectionSet(ref int) { } resolvedField := &r.resolverFields[resolverFieldAncestor] resolvedField.memberTypes = memberTypes - r.planCtx.enterResolverCompositeSelectionSet(compositType, ref, resolvedField) + + config := r.planCtx.buildCompositeTypeConfig(compositType, ref) + resolvedField.fieldsSelectionSetRef = config.fieldsSelectionSetRef + resolvedField.fragmentType = config.oneOfType + resolvedField.fragmentSelections = config.fragmentSelections + return } diff --git a/v2/pkg/engine/datasource/grpc_datasource/execution_plan_visitor_federation.go b/v2/pkg/engine/datasource/grpc_datasource/execution_plan_visitor_federation.go index e30fd712ab..f9bfa1dda3 100644 --- a/v2/pkg/engine/datasource/grpc_datasource/execution_plan_visitor_federation.go +++ b/v2/pkg/engine/datasource/grpc_datasource/execution_plan_visitor_federation.go @@ -206,7 +206,12 @@ func (r *rpcPlanVisitorFederation) EnterSelectionSet(ref int) { } resolvedField := &r.resolverFields[resolvedFieldAncestor] resolvedField.memberTypes = memberTypes - r.planCtx.enterResolverCompositeSelectionSet(compositType, ref, resolvedField) + + config := r.planCtx.buildCompositeTypeConfig(compositType, ref) + resolvedField.fieldsSelectionSetRef = config.fieldsSelectionSetRef + resolvedField.fragmentType = config.oneOfType + resolvedField.fragmentSelections = config.fragmentSelections + return } @@ -424,11 +429,35 @@ func (r *rpcPlanVisitorFederation) enterRequiredField(ref, fieldDefRef int, pare if field.ProtoTypeName == DataTypeMessage { fieldDefType := r.definition.FieldDefinitionType(fieldDefRef) - message, err := r.planCtx.buildMessageForField(buildFieldMessageConfig{ - typeName: r.definition.ResolveTypeNameString(fieldDefType), + typeName := r.definition.ResolveTypeNameString(fieldDefType) + + node, found := r.definition.NodeByNameStr(typeName) + if !found { + r.walker.StopWithInternalErr(fmt.Errorf("definition node not found for type %s", typeName)) + return + } + + bfmc := buildFieldMessageConfig{ + typeName: typeName, fieldsSelectionSetRef: r.operation.Fields[ref].SelectionSet, - }) + } + + if fragmentType := r.planCtx.getCompositeType(node); fragmentType != OneOfTypeNone { + memberTypes, err := r.planCtx.getMemberTypes(node) + if err != nil { + r.walker.StopWithInternalErr(err) + return + } + + bfmc.fragmentType = fragmentType + bfmc.memberTypes = memberTypes + + c := r.planCtx.buildCompositeTypeConfig(fragmentType, r.operation.Fields[ref].SelectionSet) + bfmc.fieldsSelectionSetRef = c.fieldsSelectionSetRef + bfmc.fragmentSelections = c.fragmentSelections + } + message, err := r.planCtx.buildMessageForField(bfmc) if err != nil { r.walker.StopWithInternalErr(err) return 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 89d49c7dca..53f30e3057 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 @@ -2087,3 +2087,512 @@ func Test_DataSource_Load_WithEntity_Calls_And_Requires_AbstractTypes(t *testing }) } } + +// Test_DataSource_Load_WithEntity_Calls_And_Requires_AbstractReturnTypes covers @requires +// fields whose *return* type is abstract (interface or union), as opposed to +// Test_DataSource_Load_WithEntity_Calls_And_Requires_AbstractTypes which covers abstract +// types appearing in the @requires selection set. +// +// The concrete member must be resolved from the protobuf oneof, so that __typename reports +// the concrete type and only the matching inline fragment's fields are returned. +func Test_DataSource_Load_WithEntity_Calls_And_Requires_AbstractReturnTypes(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"` + } + + // entities asserts the number of returned entities and returns them as objects. + entities := func(t *testing.T, data map[string]any, expectedLen int) []map[string]any { + t.Helper() + rawEntities, ok := data["_entities"].([]any) + require.True(t, ok, "_entities should be an array") + require.Len(t, rawEntities, expectedLen) + + result := make([]map[string]any, 0, len(rawEntities)) + for i, rawEntity := range rawEntities { + entity, ok := rawEntity.(map[string]any) + require.True(t, ok, "entity %d should be an object", i) + result = append(result, entity) + } + + return result + } + + 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) + }{ + { + name: "Query Storage with recommendedItem returning an interface type", + query: `query($representations: [_Any!]!) { _entities(representations: $representations) { ...on Storage { id name recommendedItem { __typename ... on PalletItem { name palletCount } ... on ContainerItem { name containerSize } } } } }`, + vars: `{"variables":{"representations":[ + {"__typename":"Storage","id":"1","metadata":{"capacity":200,"zone":"A"}}, + {"__typename":"Storage","id":"2","metadata":{"capacity":50,"zone":"B"}} + ]}}`, + federationConfigs: plan.FederationFieldConfigurations{ + { + TypeName: "Storage", + SelectionSet: "id", + }, + { + TypeName: "Storage", + FieldName: "recommendedItem", + SelectionSet: "metadata { capacity zone }", + }, + }, + validate: func(t *testing.T, data map[string]any) { + storages := entities(t, data, 2) + + // capacity 200 > 100 -> PalletItem, palletCount = capacity / 10 + storage1 := storages[0] + require.Equal(t, "1", storage1["id"]) + require.Equal(t, "Storage 1", storage1["name"]) + + item1, ok := storage1["recommendedItem"].(map[string]any) + require.True(t, ok, "recommendedItem should be an object") + require.Equal(t, "PalletItem", item1["__typename"]) + require.Equal(t, "Pallet for zone A", item1["name"]) + require.Equal(t, float64(20), item1["palletCount"]) + require.NotContains(t, item1, "containerSize", "ContainerItem fields must not leak into a PalletItem") + + // capacity 50 <= 100 -> ContainerItem, containerSize = "L" + storage2 := storages[1] + require.Equal(t, "2", storage2["id"]) + require.Equal(t, "Storage 2", storage2["name"]) + + item2, ok := storage2["recommendedItem"].(map[string]any) + require.True(t, ok, "recommendedItem should be an object") + require.Equal(t, "ContainerItem", item2["__typename"]) + require.Equal(t, "Container for zone B", item2["name"]) + require.Equal(t, "50L", item2["containerSize"]) + require.NotContains(t, item2, "palletCount", "PalletItem fields must not leak into a ContainerItem") + }, + validateError: func(t *testing.T, errorData []graphqlError) { + require.Empty(t, errorData) + }, + }, + { + name: "Query Storage with recommendedItem selecting interface fields directly alongside fragments", + query: `query($representations: [_Any!]!) { _entities(representations: $representations) { ...on Storage { id recommendedItem { __typename id name weight ... on PalletItem { palletCount specs { name dimensions { length width } } } ... on ContainerItem { containerSize } } } } }`, + vars: `{"variables":{"representations":[ + {"__typename":"Storage","id":"1","metadata":{"capacity":200,"zone":"A"}}, + {"__typename":"Storage","id":"2","metadata":{"capacity":50,"zone":"B"}} + ]}}`, + federationConfigs: plan.FederationFieldConfigurations{ + { + TypeName: "Storage", + SelectionSet: "id", + }, + { + TypeName: "Storage", + FieldName: "recommendedItem", + SelectionSet: "metadata { capacity zone }", + }, + }, + validate: func(t *testing.T, data map[string]any) { + storages := entities(t, data, 2) + + storage1 := storages[0] + item1, ok := storage1["recommendedItem"].(map[string]any) + require.True(t, ok, "recommendedItem should be an object") + + // Fields selected on the interface itself resolve for the concrete member + require.Equal(t, "PalletItem", item1["__typename"]) + require.Equal(t, "pallet-A-200", item1["id"]) + require.Equal(t, "Pallet for zone A", item1["name"]) + require.Equal(t, float64(250), item1["weight"]) + require.Equal(t, float64(20), item1["palletCount"]) + + // Concrete nesting inside the fragment resolves too + specs, ok := item1["specs"].(map[string]any) + require.True(t, ok, "specs should be an object") + require.Equal(t, "Pallet for zone A specs", specs["name"]) + dimensions, ok := specs["dimensions"].(map[string]any) + require.True(t, ok, "dimensions should be an object") + require.Equal(t, float64(120), dimensions["length"]) + require.Equal(t, float64(80), dimensions["width"]) + require.NotContains(t, dimensions, "height", "unselected fields must not be returned") + + storage2 := storages[1] + item2, ok := storage2["recommendedItem"].(map[string]any) + require.True(t, ok, "recommendedItem should be an object") + require.Equal(t, "ContainerItem", item2["__typename"]) + require.Equal(t, "container-B-50", item2["id"]) + require.Equal(t, "Container for zone B", item2["name"]) + require.Equal(t, 22.5, item2["weight"]) + require.Equal(t, "50L", item2["containerSize"]) + require.NotContains(t, item2, "specs", "PalletItem fragment fields must not leak into a ContainerItem") + }, + validateError: func(t *testing.T, errorData []graphqlError) { + require.Empty(t, errorData) + }, + }, + { + name: "Query Storage with recommendedItem returning an interface type containing a nested interface type", + query: `query($representations: [_Any!]!) { _entities(representations: $representations) { ...on Storage { id recommendedItem { __typename ... on PalletItem { name palletCount handler { name assignedItem { __typename ... on ContainerItem { name containerSize } ... on PalletItem { name palletCount } } } } ... on ContainerItem { name containerSize handler { name assignedItem { __typename ... on ContainerItem { name containerSize } ... on PalletItem { name palletCount } } } } } } } }`, + vars: `{"variables":{"representations":[ + {"__typename":"Storage","id":"1","metadata":{"capacity":200,"zone":"A"}}, + {"__typename":"Storage","id":"2","metadata":{"capacity":50,"zone":"B"}} + ]}}`, + federationConfigs: plan.FederationFieldConfigurations{ + { + TypeName: "Storage", + SelectionSet: "id", + }, + { + TypeName: "Storage", + FieldName: "recommendedItem", + SelectionSet: "metadata { capacity zone }", + }, + }, + validate: func(t *testing.T, data map[string]any) { + storages := entities(t, data, 2) + + // PalletItem -> handler -> assignedItem resolves to a ContainerItem + item1, ok := storages[0]["recommendedItem"].(map[string]any) + require.True(t, ok, "recommendedItem should be an object") + require.Equal(t, "PalletItem", item1["__typename"]) + require.Equal(t, "Pallet for zone A", item1["name"]) + + handler1, ok := item1["handler"].(map[string]any) + require.True(t, ok, "handler should be an object") + require.Equal(t, "Handler for Pallet for zone A", handler1["name"]) + + assigned1, ok := handler1["assignedItem"].(map[string]any) + require.True(t, ok, "assignedItem should be an object") + require.Equal(t, "ContainerItem", assigned1["__typename"]) + require.Equal(t, "Pallet for zone A assigned container", assigned1["name"]) + require.Equal(t, "20ft", assigned1["containerSize"]) + require.NotContains(t, assigned1, "palletCount", "the nested abstract type must resolve its own concrete member") + + // ContainerItem -> handler -> assignedItem resolves to a PalletItem + item2, ok := storages[1]["recommendedItem"].(map[string]any) + require.True(t, ok, "recommendedItem should be an object") + require.Equal(t, "ContainerItem", item2["__typename"]) + require.Equal(t, "Container for zone B", item2["name"]) + + handler2, ok := item2["handler"].(map[string]any) + require.True(t, ok, "handler should be an object") + require.Equal(t, "Handler for Container for zone B", handler2["name"]) + + assigned2, ok := handler2["assignedItem"].(map[string]any) + require.True(t, ok, "assignedItem should be an object") + require.Equal(t, "PalletItem", assigned2["__typename"]) + require.Equal(t, "Container for zone B assigned pallet", assigned2["name"]) + require.Equal(t, float64(7), assigned2["palletCount"]) + require.NotContains(t, assigned2, "containerSize", "the nested abstract type must resolve its own concrete member") + }, + validateError: func(t *testing.T, errorData []graphqlError) { + require.Empty(t, errorData) + }, + }, + { + name: "Query Storage with recommendedItems returning a list of interfaces containing nested interface types", + query: `query($representations: [_Any!]!) { _entities(representations: $representations) { ...on Storage { id recommendedItems { __typename ... on PalletItem { name handler { assignedItem { __typename ... on ContainerItem { name containerSize } } } } ... on ContainerItem { name handler { assignedItem { __typename ... on PalletItem { name palletCount } } } } } } } }`, + vars: `{"variables":{"representations":[ + {"__typename":"Storage","id":"1","tags":["alpha","beta"]} + ]}}`, + federationConfigs: plan.FederationFieldConfigurations{ + { + TypeName: "Storage", + SelectionSet: "id", + }, + { + TypeName: "Storage", + FieldName: "recommendedItems", + SelectionSet: "tags", + }, + }, + validate: func(t *testing.T, data map[string]any) { + storage1 := entities(t, data, 1)[0] + items, ok := storage1["recommendedItems"].([]any) + require.True(t, ok, "recommendedItems should be an array") + require.Len(t, items, 2) + + // Each list element resolves its own concrete member and its own nested abstract type + item0, ok := items[0].(map[string]any) + require.True(t, ok, "item 0 should be an object") + require.Equal(t, "PalletItem", item0["__typename"]) + require.Equal(t, "Pallet alpha", item0["name"]) + handler0, ok := item0["handler"].(map[string]any) + require.True(t, ok, "handler should be an object") + assigned0, ok := handler0["assignedItem"].(map[string]any) + require.True(t, ok, "assignedItem should be an object") + require.Equal(t, "ContainerItem", assigned0["__typename"]) + require.Equal(t, "Pallet alpha assigned container", assigned0["name"]) + require.Equal(t, "20ft", assigned0["containerSize"]) + + item1, ok := items[1].(map[string]any) + require.True(t, ok, "item 1 should be an object") + require.Equal(t, "ContainerItem", item1["__typename"]) + require.Equal(t, "Container beta", item1["name"]) + handler1, ok := item1["handler"].(map[string]any) + require.True(t, ok, "handler should be an object") + assigned1, ok := handler1["assignedItem"].(map[string]any) + require.True(t, ok, "assignedItem should be an object") + require.Equal(t, "PalletItem", assigned1["__typename"]) + require.Equal(t, "Container beta assigned pallet", assigned1["name"]) + require.Equal(t, float64(7), assigned1["palletCount"]) + }, + validateError: func(t *testing.T, errorData []graphqlError) { + require.Empty(t, errorData) + }, + }, + { + name: "Query Storage with recommendedItems returning a list of an interface type", + query: `query($representations: [_Any!]!) { _entities(representations: $representations) { ...on Storage { id recommendedItems { __typename name ... on PalletItem { palletCount } ... on ContainerItem { containerSize } } } } }`, + vars: `{"variables":{"representations":[ + {"__typename":"Storage","id":"1","tags":["alpha","beta","gamma"]}, + {"__typename":"Storage","id":"2","tags":[]} + ]}}`, + federationConfigs: plan.FederationFieldConfigurations{ + { + TypeName: "Storage", + SelectionSet: "id", + }, + { + TypeName: "Storage", + FieldName: "recommendedItems", + SelectionSet: "tags", + }, + }, + validate: func(t *testing.T, data map[string]any) { + storages := entities(t, data, 2) + + // One item per tag, alternating PalletItem / ContainerItem by index + storage1 := storages[0] + items, ok := storage1["recommendedItems"].([]any) + require.True(t, ok, "recommendedItems should be an array") + require.Len(t, items, 3) + + item0, ok := items[0].(map[string]any) + require.True(t, ok, "item 0 should be an object") + require.Equal(t, "PalletItem", item0["__typename"]) + require.Equal(t, "Pallet alpha", item0["name"]) + require.Equal(t, float64(1), item0["palletCount"]) + require.NotContains(t, item0, "containerSize") + + item1, ok := items[1].(map[string]any) + require.True(t, ok, "item 1 should be an object") + require.Equal(t, "ContainerItem", item1["__typename"]) + require.Equal(t, "Container beta", item1["name"]) + require.Equal(t, "BETA", item1["containerSize"]) + require.NotContains(t, item1, "palletCount") + + item2, ok := items[2].(map[string]any) + require.True(t, ok, "item 2 should be an object") + require.Equal(t, "PalletItem", item2["__typename"]) + require.Equal(t, "Pallet gamma", item2["name"]) + require.Equal(t, float64(3), item2["palletCount"]) + + // No tags -> empty list, not null + storage2 := storages[1] + emptyItems, ok := storage2["recommendedItems"].([]any) + require.True(t, ok, "recommendedItems should be an array") + require.Empty(t, emptyItems) + }, + validateError: func(t *testing.T, errorData []graphqlError) { + require.Empty(t, errorData) + }, + }, + { + name: "Query Storage with latestOperation returning a union type", + query: `query($representations: [_Any!]!) { _entities(representations: $representations) { ...on Storage { id latestOperation { __typename ... on StorageSuccess { message completedAt } ... on StorageFailure { message errorCode } } } } }`, + vars: `{"variables":{"representations":[ + {"__typename":"Storage","id":"1","storageKind":"ELECTRONICS"}, + {"__typename":"Storage","id":"2","storageKind":"OTHER"} + ]}}`, + federationConfigs: plan.FederationFieldConfigurations{ + { + TypeName: "Storage", + SelectionSet: "id", + }, + { + TypeName: "Storage", + FieldName: "latestOperation", + SelectionSet: "storageKind", + }, + }, + validate: func(t *testing.T, data map[string]any) { + storages := entities(t, data, 2) + + // Known kind -> StorageSuccess + storage1 := storages[0] + operation1, ok := storage1["latestOperation"].(map[string]any) + require.True(t, ok, "latestOperation should be an object") + require.Equal(t, "StorageSuccess", operation1["__typename"]) + require.Equal(t, "Operation completed for CATEGORY_KIND_ELECTRONICS", operation1["message"]) + require.Equal(t, "2024-01-01T00:00:00Z", operation1["completedAt"]) + require.NotContains(t, operation1, "errorCode", "StorageFailure fields must not leak into a StorageSuccess") + + // OTHER -> StorageFailure + storage2 := storages[1] + operation2, ok := storage2["latestOperation"].(map[string]any) + require.True(t, ok, "latestOperation should be an object") + require.Equal(t, "StorageFailure", operation2["__typename"]) + require.Equal(t, "Operation failed for CATEGORY_KIND_OTHER", operation2["message"]) + require.Equal(t, "UNSUPPORTED_KIND", operation2["errorCode"]) + require.NotContains(t, operation2, "completedAt", "StorageSuccess fields must not leak into a StorageFailure") + }, + validateError: func(t *testing.T, errorData []graphqlError) { + require.Empty(t, errorData) + }, + }, + { + name: "Query Storage with optionalLatestOperation returning a nullable union type", + query: `query($representations: [_Any!]!) { _entities(representations: $representations) { ...on Storage { id optionalLatestOperation { __typename ... on StorageSuccess { message completedAt } ... on StorageFailure { errorCode } } } } }`, + vars: `{"variables":{"representations":[ + {"__typename":"Storage","id":"1","optionalTags":["a"]}, + {"__typename":"Storage","id":"2","optionalTags":["a","b"]}, + {"__typename":"Storage","id":"3","optionalTags":null} + ]}}`, + federationConfigs: plan.FederationFieldConfigurations{ + { + TypeName: "Storage", + SelectionSet: "id", + }, + { + TypeName: "Storage", + FieldName: "optionalLatestOperation", + SelectionSet: "optionalTags", + }, + }, + validate: func(t *testing.T, data map[string]any) { + storages := entities(t, data, 3) + + // Odd tag count -> StorageSuccess + storage1 := storages[0] + operation1, ok := storage1["optionalLatestOperation"].(map[string]any) + require.True(t, ok, "optionalLatestOperation should be an object") + require.Equal(t, "StorageSuccess", operation1["__typename"]) + require.Equal(t, "Operation completed for tags: a", operation1["message"]) + require.Equal(t, "2024-01-02T00:00:00Z", operation1["completedAt"]) + + // Even tag count -> StorageFailure. Only errorCode is selected on this member. + storage2 := storages[1] + operation2, ok := storage2["optionalLatestOperation"].(map[string]any) + require.True(t, ok, "optionalLatestOperation should be an object") + require.Equal(t, "StorageFailure", operation2["__typename"]) + require.Equal(t, "EVEN_TAG_COUNT", operation2["errorCode"]) + require.NotContains(t, operation2, "message", "unselected fragment fields must not be returned") + + // No tags -> null + storage3 := storages[2] + require.Contains(t, storage3, "optionalLatestOperation") + require.Nil(t, storage3["optionalLatestOperation"]) + }, + validateError: func(t *testing.T, errorData []graphqlError) { + require.Empty(t, errorData) + }, + }, + { + name: "Query Storage with abstract return types combined with a scalar required field", + query: `query($representations: [_Any!]!) { _entities(representations: $representations) { ...on Storage { id tagSummary recommendedItems { __typename name } latestOperation { __typename ... on StorageSuccess { message } ... on StorageFailure { errorCode } } } } }`, + vars: `{"variables":{"representations":[ + {"__typename":"Storage","id":"1","tags":["alpha","beta"],"storageKind":"BOOK"} + ]}}`, + federationConfigs: plan.FederationFieldConfigurations{ + { + TypeName: "Storage", + SelectionSet: "id", + }, + { + TypeName: "Storage", + FieldName: "tagSummary", + SelectionSet: "tags", + }, + { + TypeName: "Storage", + FieldName: "recommendedItems", + SelectionSet: "tags", + }, + { + TypeName: "Storage", + FieldName: "latestOperation", + SelectionSet: "storageKind", + }, + }, + validate: func(t *testing.T, data map[string]any) { + storage1 := entities(t, data, 1)[0] + require.Equal(t, "1", storage1["id"]) + require.Equal(t, "alpha, beta", storage1["tagSummary"]) + + // __typename alone is a valid selection on an abstract type + items, ok := storage1["recommendedItems"].([]any) + require.True(t, ok, "recommendedItems should be an array") + require.Len(t, items, 2) + + item0, ok := items[0].(map[string]any) + require.True(t, ok, "item 0 should be an object") + require.Equal(t, "PalletItem", item0["__typename"]) + require.Equal(t, "Pallet alpha", item0["name"]) + + item1, ok := items[1].(map[string]any) + require.True(t, ok, "item 1 should be an object") + require.Equal(t, "ContainerItem", item1["__typename"]) + require.Equal(t, "Container beta", item1["name"]) + + operation, ok := storage1["latestOperation"].(map[string]any) + require.True(t, ok, "latestOperation should be an object") + require.Equal(t, "StorageSuccess", operation["__typename"]) + require.Equal(t, "Operation completed for CATEGORY_KIND_BOOK", operation["message"]) + }, + 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 ed7d9dd88d..392cb724c7 100644 --- a/v2/pkg/engine/datasource/grpc_datasource/mapping_test_helper.go +++ b/v2/pkg/engine/datasource/grpc_datasource/mapping_test_helper.go @@ -674,6 +674,38 @@ func testMapping() *GRPCMapping { Response: "RequireStorageDeepItemInfoByIdResponse", }, }, + "recommendedItem": { + TargetName: "recommended_item", + RPCConfig: RPCConfig{ + RPC: "RequireStorageRecommendedItemById", + Request: "RequireStorageRecommendedItemByIdRequest", + Response: "RequireStorageRecommendedItemByIdResponse", + }, + }, + "recommendedItems": { + TargetName: "recommended_items", + RPCConfig: RPCConfig{ + RPC: "RequireStorageRecommendedItemsById", + Request: "RequireStorageRecommendedItemsByIdRequest", + Response: "RequireStorageRecommendedItemsByIdResponse", + }, + }, + "latestOperation": { + TargetName: "latest_operation", + RPCConfig: RPCConfig{ + RPC: "RequireStorageLatestOperationById", + Request: "RequireStorageLatestOperationByIdRequest", + Response: "RequireStorageLatestOperationByIdResponse", + }, + }, + "optionalLatestOperation": { + TargetName: "optional_latest_operation", + RPCConfig: RPCConfig{ + RPC: "RequireStorageOptionalLatestOperationById", + Request: "RequireStorageOptionalLatestOperationByIdRequest", + Response: "RequireStorageOptionalLatestOperationByIdResponse", + }, + }, "filteredTagSummary": { TargetName: "filtered_tag_summary", RPCConfig: RPCConfig{ @@ -1127,6 +1159,18 @@ func testMapping() *GRPCMapping { "deepItemInfo": { TargetName: "deep_item_info", }, + "recommendedItem": { + TargetName: "recommended_item", + }, + "recommendedItems": { + TargetName: "recommended_items", + }, + "latestOperation": { + TargetName: "latest_operation", + }, + "optionalLatestOperation": { + TargetName: "optional_latest_operation", + }, "storageStatus": { TargetName: "storage_status", ArgumentMappings: FieldArgumentMap{ diff --git a/v2/pkg/grpctest/mapping/mapping.go b/v2/pkg/grpctest/mapping/mapping.go index a8546e4d79..27e28114d7 100644 --- a/v2/pkg/grpctest/mapping/mapping.go +++ b/v2/pkg/grpctest/mapping/mapping.go @@ -680,6 +680,38 @@ func DefaultGRPCMapping() *grpcdatasource.GRPCMapping { Response: "RequireStorageDeepItemInfoByIdResponse", }, }, + "recommendedItem": { + TargetName: "recommended_item", + RPCConfig: grpcdatasource.RPCConfig{ + RPC: "RequireStorageRecommendedItemById", + Request: "RequireStorageRecommendedItemByIdRequest", + Response: "RequireStorageRecommendedItemByIdResponse", + }, + }, + "recommendedItems": { + TargetName: "recommended_items", + RPCConfig: grpcdatasource.RPCConfig{ + RPC: "RequireStorageRecommendedItemsById", + Request: "RequireStorageRecommendedItemsByIdRequest", + Response: "RequireStorageRecommendedItemsByIdResponse", + }, + }, + "latestOperation": { + TargetName: "latest_operation", + RPCConfig: grpcdatasource.RPCConfig{ + RPC: "RequireStorageLatestOperationById", + Request: "RequireStorageLatestOperationByIdRequest", + Response: "RequireStorageLatestOperationByIdResponse", + }, + }, + "optionalLatestOperation": { + TargetName: "optional_latest_operation", + RPCConfig: grpcdatasource.RPCConfig{ + RPC: "RequireStorageOptionalLatestOperationById", + Request: "RequireStorageOptionalLatestOperationByIdRequest", + Response: "RequireStorageOptionalLatestOperationByIdResponse", + }, + }, "filteredTagSummary": { TargetName: "filtered_tag_summary", RPCConfig: grpcdatasource.RPCConfig{ @@ -1133,6 +1165,18 @@ func DefaultGRPCMapping() *grpcdatasource.GRPCMapping { "deepItemInfo": { TargetName: "deep_item_info", }, + "recommendedItem": { + TargetName: "recommended_item", + }, + "recommendedItems": { + TargetName: "recommended_items", + }, + "latestOperation": { + TargetName: "latest_operation", + }, + "optionalLatestOperation": { + TargetName: "optional_latest_operation", + }, "storageStatus": { TargetName: "storage_status", ArgumentMappings: grpcdatasource.FieldArgumentMap{ diff --git a/v2/pkg/grpctest/mockservice_requires.go b/v2/pkg/grpctest/mockservice_requires.go index 9bc05510e8..9f57abdd01 100644 --- a/v2/pkg/grpctest/mockservice_requires.go +++ b/v2/pkg/grpctest/mockservice_requires.go @@ -474,6 +474,227 @@ func (s *MockService) RequireStorageDeepItemInfoById(_ context.Context, req *pro return &productv1.RequireStorageDeepItemInfoByIdResponse{Result: results}, nil } +// newPalletStorageItem builds a fully populated PalletItem wrapped in the StorageItem interface message. +// assignedItem is attached to the item's handler and may be nil to terminate the recursion, +// as StorageItem is reachable from itself via handler.assignedItem. +func newPalletStorageItem(id, name string, palletCount int32, assignedItem *productv1.StorageItem) *productv1.StorageItem { + return &productv1.StorageItem{ + Instance: &productv1.StorageItem_PalletItem{ + PalletItem: &productv1.PalletItem{ + Id: id, + Name: name, + Weight: float64(palletCount) * 12.5, + PalletCount: palletCount, + Handler: &productv1.ItemHandler{ + Id: id + "-handler", + Name: "Handler for " + name, + AssignedItem: assignedItem, + }, + Specs: &productv1.PalletSpecs{ + Name: name + " specs", + MaxWeight: float64(palletCount) * 100, + Dimensions: &productv1.Dimensions{ + Length: 120.0, + Width: 80.0, + Height: 15.0, + }, + }, + }, + }, + } +} + +// newContainerStorageItem builds a fully populated ContainerItem wrapped in the StorageItem interface message. +// assignedItem is attached to the item's handler and may be nil to terminate the recursion, +// as StorageItem is reachable from itself via handler.assignedItem. +func newContainerStorageItem(id, name, containerSize string, assignedItem *productv1.StorageItem) *productv1.StorageItem { + return &productv1.StorageItem{ + Instance: &productv1.StorageItem_ContainerItem{ + ContainerItem: &productv1.ContainerItem{ + Id: id, + Name: name, + Weight: float64(len(containerSize)) * 7.5, + ContainerSize: containerSize, + Handler: &productv1.ItemHandler{ + Id: id + "-handler", + Name: "Handler for " + name, + AssignedItem: assignedItem, + }, + Specs: &productv1.ContainerSpecs{ + Name: name + " specs", + Volume: float64(len(containerSize)) * 33.3, + Dimensions: &productv1.Dimensions{ + Length: 240.0, + Width: 120.0, + Height: 260.0, + }, + }, + }, + }, + } +} + +// newHandledPalletStorageItem builds a PalletItem whose handler is assigned a ContainerItem, +// so that a nested abstract type is reachable within an abstract result. +func newHandledPalletStorageItem(id, name string, palletCount int32) *productv1.StorageItem { + assigned := newContainerStorageItem(id+"-assigned", name+" assigned container", "20ft", nil) + return newPalletStorageItem(id, name, palletCount, assigned) +} + +// newHandledContainerStorageItem builds a ContainerItem whose handler is assigned a PalletItem, +// so that a nested abstract type is reachable within an abstract result. +func newHandledContainerStorageItem(id, name, containerSize string) *productv1.StorageItem { + assigned := newPalletStorageItem(id+"-assigned", name+" assigned pallet", 7, nil) + return newContainerStorageItem(id, name, containerSize, assigned) +} + +// RequireStorageRecommendedItemById implements [productv1.ProductServiceServer]. +// Returns an interface (StorageItem) derived from the required metadata fields. +func (s *MockService) RequireStorageRecommendedItemById(_ context.Context, req *productv1.RequireStorageRecommendedItemByIdRequest) (*productv1.RequireStorageRecommendedItemByIdResponse, error) { + results := make([]*productv1.RequireStorageRecommendedItemByIdResult, 0, len(req.GetContext())) + + for _, ctx := range req.GetContext() { + metadata := ctx.GetFields().GetMetadata() + capacity := metadata.GetCapacity() + zone := metadata.GetZone() + + // High capacity storages get a pallet recommendation, everything else a container. + var item *productv1.StorageItem + if capacity > 100 { + item = newHandledPalletStorageItem( + fmt.Sprintf("pallet-%s-%d", zone, capacity), + fmt.Sprintf("Pallet for zone %s", zone), + capacity/10, + ) + } else { + item = newHandledContainerStorageItem( + fmt.Sprintf("container-%s-%d", zone, capacity), + fmt.Sprintf("Container for zone %s", zone), + fmt.Sprintf("%dL", capacity), + ) + } + + results = append(results, &productv1.RequireStorageRecommendedItemByIdResult{ + RecommendedItem: item, + }) + } + + return &productv1.RequireStorageRecommendedItemByIdResponse{Result: results}, nil +} + +// RequireStorageRecommendedItemsById implements [productv1.ProductServiceServer]. +// Returns a list of interfaces (StorageItem), one entry per required tag. +func (s *MockService) RequireStorageRecommendedItemsById(_ context.Context, req *productv1.RequireStorageRecommendedItemsByIdRequest) (*productv1.RequireStorageRecommendedItemsByIdResponse, error) { + results := make([]*productv1.RequireStorageRecommendedItemsByIdResult, 0, len(req.GetContext())) + + for _, ctx := range req.GetContext() { + tags := ctx.GetFields().GetTags() + + items := make([]*productv1.StorageItem, 0, len(tags)) + for i, tag := range tags { + // Alternate between both concrete types so every list contains a mix. + if i%2 == 0 { + items = append(items, newHandledPalletStorageItem( + fmt.Sprintf("pallet-%s", tag), + fmt.Sprintf("Pallet %s", tag), + int32(i+1), + )) + } else { + items = append(items, newHandledContainerStorageItem( + fmt.Sprintf("container-%s", tag), + fmt.Sprintf("Container %s", tag), + strings.ToUpper(tag), + )) + } + } + + results = append(results, &productv1.RequireStorageRecommendedItemsByIdResult{ + RecommendedItems: items, + }) + } + + return &productv1.RequireStorageRecommendedItemsByIdResponse{Result: results}, nil +} + +// RequireStorageLatestOperationById implements [productv1.ProductServiceServer]. +// Returns a union (StorageOperationResult) derived from the required storageKind enum. +func (s *MockService) RequireStorageLatestOperationById(_ context.Context, req *productv1.RequireStorageLatestOperationByIdRequest) (*productv1.RequireStorageLatestOperationByIdResponse, error) { + results := make([]*productv1.RequireStorageLatestOperationByIdResult, 0, len(req.GetContext())) + + for _, ctx := range req.GetContext() { + kind := ctx.GetFields().GetStorageKind() + + // Known kinds report a success, everything else a failure. + operation := &productv1.StorageOperationResult{} + switch kind { + case productv1.CategoryKind_CATEGORY_KIND_BOOK, + productv1.CategoryKind_CATEGORY_KIND_ELECTRONICS, + productv1.CategoryKind_CATEGORY_KIND_FURNITURE: + operation.Value = &productv1.StorageOperationResult_StorageSuccess{ + StorageSuccess: &productv1.StorageSuccess{ + Message: fmt.Sprintf("Operation completed for %s", kind.String()), + CompletedAt: "2024-01-01T00:00:00Z", + }, + } + default: + operation.Value = &productv1.StorageOperationResult_StorageFailure{ + StorageFailure: &productv1.StorageFailure{ + Message: fmt.Sprintf("Operation failed for %s", kind.String()), + ErrorCode: "UNSUPPORTED_KIND", + }, + } + } + + results = append(results, &productv1.RequireStorageLatestOperationByIdResult{ + LatestOperation: operation, + }) + } + + return &productv1.RequireStorageLatestOperationByIdResponse{Result: results}, nil +} + +// RequireStorageOptionalLatestOperationById implements [productv1.ProductServiceServer]. +// Returns a nullable union (StorageOperationResult) derived from the required optionalTags. +func (s *MockService) RequireStorageOptionalLatestOperationById(_ context.Context, req *productv1.RequireStorageOptionalLatestOperationByIdRequest) (*productv1.RequireStorageOptionalLatestOperationByIdResponse, error) { + results := make([]*productv1.RequireStorageOptionalLatestOperationByIdResult, 0, len(req.GetContext())) + + for _, ctx := range req.GetContext() { + optionalTags := ctx.GetFields().GetOptionalTags() + + var operation *productv1.StorageOperationResult + items := optionalTags.GetList().GetItems() + switch { + case len(items) == 0: + // No tags provided, the operation is unknown. + operation = nil + case len(items)%2 == 0: + operation = &productv1.StorageOperationResult{ + Value: &productv1.StorageOperationResult_StorageFailure{ + StorageFailure: &productv1.StorageFailure{ + Message: fmt.Sprintf("Operation failed for tags: %s", strings.Join(items, ", ")), + ErrorCode: "EVEN_TAG_COUNT", + }, + }, + } + default: + operation = &productv1.StorageOperationResult{ + Value: &productv1.StorageOperationResult_StorageSuccess{ + StorageSuccess: &productv1.StorageSuccess{ + Message: fmt.Sprintf("Operation completed for tags: %s", strings.Join(items, ", ")), + CompletedAt: "2024-01-02T00:00:00Z", + }, + }, + } + } + + results = append(results, &productv1.RequireStorageOptionalLatestOperationByIdResult{ + OptionalLatestOperation: operation, + }) + } + + return &productv1.RequireStorageOptionalLatestOperationByIdResponse{Result: results}, nil +} + // RequireStorageMultiFilteredTagSummaryById implements [productv1.ProductServiceServer]. // Returns a comma separated list of tags matching any of the given prefixes, capped at maxResults. func (s *MockService) RequireStorageMultiFilteredTagSummaryById(_ context.Context, req *productv1.RequireStorageMultiFilteredTagSummaryByIdRequest) (*productv1.RequireStorageMultiFilteredTagSummaryByIdResponse, error) { diff --git a/v2/pkg/grpctest/product.proto b/v2/pkg/grpctest/product.proto index 380fc957c6..19be1f4d51 100644 --- a/v2/pkg/grpctest/product.proto +++ b/v2/pkg/grpctest/product.proto @@ -66,16 +66,20 @@ service ProductService { rpc RequireStorageItemInfoById(RequireStorageItemInfoByIdRequest) returns (RequireStorageItemInfoByIdResponse) {} rpc RequireStorageItemSpecsInfoById(RequireStorageItemSpecsInfoByIdRequest) returns (RequireStorageItemSpecsInfoByIdResponse) {} rpc RequireStorageKindSummaryById(RequireStorageKindSummaryByIdRequest) returns (RequireStorageKindSummaryByIdResponse) {} + rpc RequireStorageLatestOperationById(RequireStorageLatestOperationByIdRequest) returns (RequireStorageLatestOperationByIdResponse) {} rpc RequireStorageMetadataScoreById(RequireStorageMetadataScoreByIdRequest) returns (RequireStorageMetadataScoreByIdResponse) {} rpc RequireStorageMultiFilteredTagSummaryById(RequireStorageMultiFilteredTagSummaryByIdRequest) returns (RequireStorageMultiFilteredTagSummaryByIdResponse) {} rpc RequireStorageNullableFilteredTagSummaryById(RequireStorageNullableFilteredTagSummaryByIdRequest) returns (RequireStorageNullableFilteredTagSummaryByIdResponse) {} rpc RequireStorageOperationReportById(RequireStorageOperationReportByIdRequest) returns (RequireStorageOperationReportByIdResponse) {} + rpc RequireStorageOptionalLatestOperationById(RequireStorageOptionalLatestOperationByIdRequest) returns (RequireStorageOptionalLatestOperationByIdResponse) {} rpc RequireStorageOptionalProcessedMetadataById(RequireStorageOptionalProcessedMetadataByIdRequest) returns (RequireStorageOptionalProcessedMetadataByIdResponse) {} rpc RequireStorageOptionalProcessedTagsById(RequireStorageOptionalProcessedTagsByIdRequest) returns (RequireStorageOptionalProcessedTagsByIdResponse) {} rpc RequireStorageOptionalTagSummaryById(RequireStorageOptionalTagSummaryByIdRequest) returns (RequireStorageOptionalTagSummaryByIdResponse) {} rpc RequireStorageProcessedMetadataById(RequireStorageProcessedMetadataByIdRequest) returns (RequireStorageProcessedMetadataByIdResponse) {} rpc RequireStorageProcessedMetadataHistoryById(RequireStorageProcessedMetadataHistoryByIdRequest) returns (RequireStorageProcessedMetadataHistoryByIdResponse) {} rpc RequireStorageProcessedTagsById(RequireStorageProcessedTagsByIdRequest) returns (RequireStorageProcessedTagsByIdResponse) {} + rpc RequireStorageRecommendedItemById(RequireStorageRecommendedItemByIdRequest) returns (RequireStorageRecommendedItemByIdResponse) {} + rpc RequireStorageRecommendedItemsById(RequireStorageRecommendedItemsByIdRequest) returns (RequireStorageRecommendedItemsByIdResponse) {} rpc RequireStorageSecuritySummaryById(RequireStorageSecuritySummaryByIdRequest) returns (RequireStorageSecuritySummaryByIdResponse) {} rpc RequireStorageStockHealthScoreById(RequireStorageStockHealthScoreByIdRequest) returns (RequireStorageStockHealthScoreByIdResponse) {} rpc RequireStorageTagSummaryById(RequireStorageTagSummaryByIdRequest) returns (RequireStorageTagSummaryByIdResponse) {} @@ -1858,6 +1862,103 @@ message RequireStorageDeepItemInfoByIdFields { StorageItem primary_item = 1; } +message RequireStorageRecommendedItemByIdRequest { + // RequireStorageRecommendedItemByIdContext provides the context for the required fields method RequireStorageRecommendedItemById. + repeated RequireStorageRecommendedItemByIdContext context = 1; +} + +message RequireStorageRecommendedItemByIdContext { + LookupStorageByIdRequestKey key = 1; + RequireStorageRecommendedItemByIdFields fields = 2; +} + +message RequireStorageRecommendedItemByIdResponse { + // RequireStorageRecommendedItemByIdResult provides the result for the required fields method RequireStorageRecommendedItemById. + repeated RequireStorageRecommendedItemByIdResult result = 1; +} + +message RequireStorageRecommendedItemByIdResult { + StorageItem recommended_item = 1; +} + +message RequireStorageRecommendedItemByIdFields { + message StorageMetadata { + int32 capacity = 1; + string zone = 2; + } + + StorageMetadata metadata = 1; +} + +message RequireStorageRecommendedItemsByIdRequest { + // RequireStorageRecommendedItemsByIdContext provides the context for the required fields method RequireStorageRecommendedItemsById. + repeated RequireStorageRecommendedItemsByIdContext context = 1; +} + +message RequireStorageRecommendedItemsByIdContext { + LookupStorageByIdRequestKey key = 1; + RequireStorageRecommendedItemsByIdFields fields = 2; +} + +message RequireStorageRecommendedItemsByIdResponse { + // RequireStorageRecommendedItemsByIdResult provides the result for the required fields method RequireStorageRecommendedItemsById. + repeated RequireStorageRecommendedItemsByIdResult result = 1; +} + +message RequireStorageRecommendedItemsByIdResult { + repeated StorageItem recommended_items = 1; +} + +message RequireStorageRecommendedItemsByIdFields { + repeated string tags = 1; +} + +message RequireStorageLatestOperationByIdRequest { + // RequireStorageLatestOperationByIdContext provides the context for the required fields method RequireStorageLatestOperationById. + repeated RequireStorageLatestOperationByIdContext context = 1; +} + +message RequireStorageLatestOperationByIdContext { + LookupStorageByIdRequestKey key = 1; + RequireStorageLatestOperationByIdFields fields = 2; +} + +message RequireStorageLatestOperationByIdResponse { + // RequireStorageLatestOperationByIdResult provides the result for the required fields method RequireStorageLatestOperationById. + repeated RequireStorageLatestOperationByIdResult result = 1; +} + +message RequireStorageLatestOperationByIdResult { + StorageOperationResult latest_operation = 1; +} + +message RequireStorageLatestOperationByIdFields { + CategoryKind storage_kind = 1; +} + +message RequireStorageOptionalLatestOperationByIdRequest { + // RequireStorageOptionalLatestOperationByIdContext provides the context for the required fields method RequireStorageOptionalLatestOperationById. + repeated RequireStorageOptionalLatestOperationByIdContext context = 1; +} + +message RequireStorageOptionalLatestOperationByIdContext { + LookupStorageByIdRequestKey key = 1; + RequireStorageOptionalLatestOperationByIdFields fields = 2; +} + +message RequireStorageOptionalLatestOperationByIdResponse { + // RequireStorageOptionalLatestOperationByIdResult provides the result for the required fields method RequireStorageOptionalLatestOperationById. + repeated RequireStorageOptionalLatestOperationByIdResult result = 1; +} + +message RequireStorageOptionalLatestOperationByIdResult { + StorageOperationResult optional_latest_operation = 1; +} + +message RequireStorageOptionalLatestOperationByIdFields { + ListOfString optional_tags = 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 93c91d669a..64746d38bc 100644 --- a/v2/pkg/grpctest/productv1/product.pb.go +++ b/v2/pkg/grpctest/productv1/product.pb.go @@ -1,7 +1,7 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.36.11 -// protoc v7.34.0 +// protoc (unknown) // source: product.proto package productv1 @@ -15219,6 +15219,926 @@ func (x *RequireStorageDeepItemInfoByIdFields) GetPrimaryItem() *RequireStorageD return nil } +type RequireStorageRecommendedItemByIdRequest 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"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RequireStorageRecommendedItemByIdRequest) Reset() { + *x = RequireStorageRecommendedItemByIdRequest{} + mi := &file_product_proto_msgTypes[328] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireStorageRecommendedItemByIdRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageRecommendedItemByIdRequest) ProtoMessage() {} + +func (x *RequireStorageRecommendedItemByIdRequest) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[328] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RequireStorageRecommendedItemByIdRequest.ProtoReflect.Descriptor instead. +func (*RequireStorageRecommendedItemByIdRequest) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{328} +} + +func (x *RequireStorageRecommendedItemByIdRequest) GetContext() []*RequireStorageRecommendedItemByIdContext { + if x != nil { + return x.Context + } + return nil +} + +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 *RequireStorageRecommendedItemByIdContext) Reset() { + *x = RequireStorageRecommendedItemByIdContext{} + mi := &file_product_proto_msgTypes[329] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireStorageRecommendedItemByIdContext) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageRecommendedItemByIdContext) ProtoMessage() {} + +func (x *RequireStorageRecommendedItemByIdContext) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[329] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RequireStorageRecommendedItemByIdContext.ProtoReflect.Descriptor instead. +func (*RequireStorageRecommendedItemByIdContext) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{329} +} + +func (x *RequireStorageRecommendedItemByIdContext) GetKey() *LookupStorageByIdRequestKey { + if x != nil { + return x.Key + } + return nil +} + +func (x *RequireStorageRecommendedItemByIdContext) GetFields() *RequireStorageRecommendedItemByIdFields { + if x != nil { + return x.Fields + } + return nil +} + +type RequireStorageRecommendedItemByIdResponse 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"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RequireStorageRecommendedItemByIdResponse) Reset() { + *x = RequireStorageRecommendedItemByIdResponse{} + mi := &file_product_proto_msgTypes[330] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireStorageRecommendedItemByIdResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageRecommendedItemByIdResponse) ProtoMessage() {} + +func (x *RequireStorageRecommendedItemByIdResponse) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[330] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RequireStorageRecommendedItemByIdResponse.ProtoReflect.Descriptor instead. +func (*RequireStorageRecommendedItemByIdResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{330} +} + +func (x *RequireStorageRecommendedItemByIdResponse) GetResult() []*RequireStorageRecommendedItemByIdResult { + 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"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RequireStorageRecommendedItemByIdResult) Reset() { + *x = RequireStorageRecommendedItemByIdResult{} + mi := &file_product_proto_msgTypes[331] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireStorageRecommendedItemByIdResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageRecommendedItemByIdResult) ProtoMessage() {} + +func (x *RequireStorageRecommendedItemByIdResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[331] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RequireStorageRecommendedItemByIdResult.ProtoReflect.Descriptor instead. +func (*RequireStorageRecommendedItemByIdResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{331} +} + +func (x *RequireStorageRecommendedItemByIdResult) GetRecommendedItem() *StorageItem { + if x != nil { + return x.RecommendedItem + } + return nil +} + +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 *RequireStorageRecommendedItemByIdFields) Reset() { + *x = RequireStorageRecommendedItemByIdFields{} + mi := &file_product_proto_msgTypes[332] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireStorageRecommendedItemByIdFields) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageRecommendedItemByIdFields) ProtoMessage() {} + +func (x *RequireStorageRecommendedItemByIdFields) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[332] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RequireStorageRecommendedItemByIdFields.ProtoReflect.Descriptor instead. +func (*RequireStorageRecommendedItemByIdFields) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{332} +} + +func (x *RequireStorageRecommendedItemByIdFields) GetMetadata() *RequireStorageRecommendedItemByIdFields_StorageMetadata { + if x != nil { + return x.Metadata + } + return nil +} + +type RequireStorageRecommendedItemsByIdRequest 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"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RequireStorageRecommendedItemsByIdRequest) Reset() { + *x = RequireStorageRecommendedItemsByIdRequest{} + mi := &file_product_proto_msgTypes[333] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireStorageRecommendedItemsByIdRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageRecommendedItemsByIdRequest) ProtoMessage() {} + +func (x *RequireStorageRecommendedItemsByIdRequest) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[333] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RequireStorageRecommendedItemsByIdRequest.ProtoReflect.Descriptor instead. +func (*RequireStorageRecommendedItemsByIdRequest) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{333} +} + +func (x *RequireStorageRecommendedItemsByIdRequest) GetContext() []*RequireStorageRecommendedItemsByIdContext { + 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"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RequireStorageRecommendedItemsByIdContext) Reset() { + *x = RequireStorageRecommendedItemsByIdContext{} + mi := &file_product_proto_msgTypes[334] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireStorageRecommendedItemsByIdContext) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageRecommendedItemsByIdContext) ProtoMessage() {} + +func (x *RequireStorageRecommendedItemsByIdContext) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[334] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RequireStorageRecommendedItemsByIdContext.ProtoReflect.Descriptor instead. +func (*RequireStorageRecommendedItemsByIdContext) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{334} +} + +func (x *RequireStorageRecommendedItemsByIdContext) GetKey() *LookupStorageByIdRequestKey { + if x != nil { + return x.Key + } + return nil +} + +func (x *RequireStorageRecommendedItemsByIdContext) GetFields() *RequireStorageRecommendedItemsByIdFields { + if x != nil { + return x.Fields + } + return nil +} + +type RequireStorageRecommendedItemsByIdResponse 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"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RequireStorageRecommendedItemsByIdResponse) Reset() { + *x = RequireStorageRecommendedItemsByIdResponse{} + mi := &file_product_proto_msgTypes[335] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireStorageRecommendedItemsByIdResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageRecommendedItemsByIdResponse) ProtoMessage() {} + +func (x *RequireStorageRecommendedItemsByIdResponse) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[335] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RequireStorageRecommendedItemsByIdResponse.ProtoReflect.Descriptor instead. +func (*RequireStorageRecommendedItemsByIdResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{335} +} + +func (x *RequireStorageRecommendedItemsByIdResponse) GetResult() []*RequireStorageRecommendedItemsByIdResult { + 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 +} + +func (x *RequireStorageRecommendedItemsByIdResult) Reset() { + *x = RequireStorageRecommendedItemsByIdResult{} + mi := &file_product_proto_msgTypes[336] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireStorageRecommendedItemsByIdResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageRecommendedItemsByIdResult) ProtoMessage() {} + +func (x *RequireStorageRecommendedItemsByIdResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[336] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RequireStorageRecommendedItemsByIdResult.ProtoReflect.Descriptor instead. +func (*RequireStorageRecommendedItemsByIdResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{336} +} + +func (x *RequireStorageRecommendedItemsByIdResult) GetRecommendedItems() []*StorageItem { + if x != nil { + return x.RecommendedItems + } + return nil +} + +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 *RequireStorageRecommendedItemsByIdFields) Reset() { + *x = RequireStorageRecommendedItemsByIdFields{} + mi := &file_product_proto_msgTypes[337] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireStorageRecommendedItemsByIdFields) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageRecommendedItemsByIdFields) ProtoMessage() {} + +func (x *RequireStorageRecommendedItemsByIdFields) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[337] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RequireStorageRecommendedItemsByIdFields.ProtoReflect.Descriptor instead. +func (*RequireStorageRecommendedItemsByIdFields) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{337} +} + +func (x *RequireStorageRecommendedItemsByIdFields) GetTags() []string { + if x != nil { + return x.Tags + } + return nil +} + +type RequireStorageLatestOperationByIdRequest 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"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RequireStorageLatestOperationByIdRequest) Reset() { + *x = RequireStorageLatestOperationByIdRequest{} + mi := &file_product_proto_msgTypes[338] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireStorageLatestOperationByIdRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageLatestOperationByIdRequest) ProtoMessage() {} + +func (x *RequireStorageLatestOperationByIdRequest) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[338] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RequireStorageLatestOperationByIdRequest.ProtoReflect.Descriptor instead. +func (*RequireStorageLatestOperationByIdRequest) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{338} +} + +func (x *RequireStorageLatestOperationByIdRequest) GetContext() []*RequireStorageLatestOperationByIdContext { + 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"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RequireStorageLatestOperationByIdContext) Reset() { + *x = RequireStorageLatestOperationByIdContext{} + mi := &file_product_proto_msgTypes[339] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireStorageLatestOperationByIdContext) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageLatestOperationByIdContext) ProtoMessage() {} + +func (x *RequireStorageLatestOperationByIdContext) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[339] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RequireStorageLatestOperationByIdContext.ProtoReflect.Descriptor instead. +func (*RequireStorageLatestOperationByIdContext) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{339} +} + +func (x *RequireStorageLatestOperationByIdContext) GetKey() *LookupStorageByIdRequestKey { + if x != nil { + return x.Key + } + return nil +} + +func (x *RequireStorageLatestOperationByIdContext) GetFields() *RequireStorageLatestOperationByIdFields { + if x != nil { + return x.Fields + } + return nil +} + +type RequireStorageLatestOperationByIdResponse 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"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RequireStorageLatestOperationByIdResponse) Reset() { + *x = RequireStorageLatestOperationByIdResponse{} + mi := &file_product_proto_msgTypes[340] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireStorageLatestOperationByIdResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageLatestOperationByIdResponse) ProtoMessage() {} + +func (x *RequireStorageLatestOperationByIdResponse) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[340] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RequireStorageLatestOperationByIdResponse.ProtoReflect.Descriptor instead. +func (*RequireStorageLatestOperationByIdResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{340} +} + +func (x *RequireStorageLatestOperationByIdResponse) GetResult() []*RequireStorageLatestOperationByIdResult { + 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 +} + +func (x *RequireStorageLatestOperationByIdResult) Reset() { + *x = RequireStorageLatestOperationByIdResult{} + mi := &file_product_proto_msgTypes[341] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireStorageLatestOperationByIdResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageLatestOperationByIdResult) ProtoMessage() {} + +func (x *RequireStorageLatestOperationByIdResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[341] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RequireStorageLatestOperationByIdResult.ProtoReflect.Descriptor instead. +func (*RequireStorageLatestOperationByIdResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{341} +} + +func (x *RequireStorageLatestOperationByIdResult) GetLatestOperation() *StorageOperationResult { + if x != nil { + return x.LatestOperation + } + return nil +} + +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 *RequireStorageLatestOperationByIdFields) Reset() { + *x = RequireStorageLatestOperationByIdFields{} + mi := &file_product_proto_msgTypes[342] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireStorageLatestOperationByIdFields) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageLatestOperationByIdFields) ProtoMessage() {} + +func (x *RequireStorageLatestOperationByIdFields) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[342] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RequireStorageLatestOperationByIdFields.ProtoReflect.Descriptor instead. +func (*RequireStorageLatestOperationByIdFields) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{342} +} + +func (x *RequireStorageLatestOperationByIdFields) GetStorageKind() CategoryKind { + if x != nil { + return x.StorageKind + } + return CategoryKind_CATEGORY_KIND_UNSPECIFIED +} + +type RequireStorageOptionalLatestOperationByIdRequest 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"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RequireStorageOptionalLatestOperationByIdRequest) Reset() { + *x = RequireStorageOptionalLatestOperationByIdRequest{} + mi := &file_product_proto_msgTypes[343] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireStorageOptionalLatestOperationByIdRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageOptionalLatestOperationByIdRequest) ProtoMessage() {} + +func (x *RequireStorageOptionalLatestOperationByIdRequest) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[343] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RequireStorageOptionalLatestOperationByIdRequest.ProtoReflect.Descriptor instead. +func (*RequireStorageOptionalLatestOperationByIdRequest) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{343} +} + +func (x *RequireStorageOptionalLatestOperationByIdRequest) GetContext() []*RequireStorageOptionalLatestOperationByIdContext { + 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"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RequireStorageOptionalLatestOperationByIdContext) Reset() { + *x = RequireStorageOptionalLatestOperationByIdContext{} + mi := &file_product_proto_msgTypes[344] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireStorageOptionalLatestOperationByIdContext) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageOptionalLatestOperationByIdContext) ProtoMessage() {} + +func (x *RequireStorageOptionalLatestOperationByIdContext) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[344] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RequireStorageOptionalLatestOperationByIdContext.ProtoReflect.Descriptor instead. +func (*RequireStorageOptionalLatestOperationByIdContext) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{344} +} + +func (x *RequireStorageOptionalLatestOperationByIdContext) GetKey() *LookupStorageByIdRequestKey { + if x != nil { + return x.Key + } + return nil +} + +func (x *RequireStorageOptionalLatestOperationByIdContext) GetFields() *RequireStorageOptionalLatestOperationByIdFields { + if x != nil { + return x.Fields + } + return nil +} + +type RequireStorageOptionalLatestOperationByIdResponse 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"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RequireStorageOptionalLatestOperationByIdResponse) Reset() { + *x = RequireStorageOptionalLatestOperationByIdResponse{} + mi := &file_product_proto_msgTypes[345] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireStorageOptionalLatestOperationByIdResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageOptionalLatestOperationByIdResponse) ProtoMessage() {} + +func (x *RequireStorageOptionalLatestOperationByIdResponse) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[345] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RequireStorageOptionalLatestOperationByIdResponse.ProtoReflect.Descriptor instead. +func (*RequireStorageOptionalLatestOperationByIdResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{345} +} + +func (x *RequireStorageOptionalLatestOperationByIdResponse) GetResult() []*RequireStorageOptionalLatestOperationByIdResult { + 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 +} + +func (x *RequireStorageOptionalLatestOperationByIdResult) Reset() { + *x = RequireStorageOptionalLatestOperationByIdResult{} + mi := &file_product_proto_msgTypes[346] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireStorageOptionalLatestOperationByIdResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageOptionalLatestOperationByIdResult) ProtoMessage() {} + +func (x *RequireStorageOptionalLatestOperationByIdResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[346] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RequireStorageOptionalLatestOperationByIdResult.ProtoReflect.Descriptor instead. +func (*RequireStorageOptionalLatestOperationByIdResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{346} +} + +func (x *RequireStorageOptionalLatestOperationByIdResult) GetOptionalLatestOperation() *StorageOperationResult { + if x != nil { + return x.OptionalLatestOperation + } + return nil +} + +type RequireStorageOptionalLatestOperationByIdFields struct { + state protoimpl.MessageState `protogen:"open.v1"` + OptionalTags *ListOfString `protobuf:"bytes,1,opt,name=optional_tags,json=optionalTags,proto3" json:"optional_tags,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RequireStorageOptionalLatestOperationByIdFields) Reset() { + *x = RequireStorageOptionalLatestOperationByIdFields{} + mi := &file_product_proto_msgTypes[347] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireStorageOptionalLatestOperationByIdFields) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageOptionalLatestOperationByIdFields) ProtoMessage() {} + +func (x *RequireStorageOptionalLatestOperationByIdFields) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[347] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RequireStorageOptionalLatestOperationByIdFields.ProtoReflect.Descriptor instead. +func (*RequireStorageOptionalLatestOperationByIdFields) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{347} +} + +func (x *RequireStorageOptionalLatestOperationByIdFields) GetOptionalTags() *ListOfString { + if x != nil { + return x.OptionalTags + } + return nil +} + type RequireStorageFilteredTagSummaryByIdRequest struct { state protoimpl.MessageState `protogen:"open.v1"` // RequireStorageFilteredTagSummaryByIdContext provides the context for the required fields method RequireStorageFilteredTagSummaryById. @@ -15231,7 +16151,7 @@ type RequireStorageFilteredTagSummaryByIdRequest struct { func (x *RequireStorageFilteredTagSummaryByIdRequest) Reset() { *x = RequireStorageFilteredTagSummaryByIdRequest{} - mi := &file_product_proto_msgTypes[328] + mi := &file_product_proto_msgTypes[348] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15243,7 +16163,7 @@ func (x *RequireStorageFilteredTagSummaryByIdRequest) String() string { func (*RequireStorageFilteredTagSummaryByIdRequest) ProtoMessage() {} func (x *RequireStorageFilteredTagSummaryByIdRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[328] + mi := &file_product_proto_msgTypes[348] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15256,7 +16176,7 @@ func (x *RequireStorageFilteredTagSummaryByIdRequest) ProtoReflect() protoreflec // Deprecated: Use RequireStorageFilteredTagSummaryByIdRequest.ProtoReflect.Descriptor instead. func (*RequireStorageFilteredTagSummaryByIdRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{328} + return file_product_proto_rawDescGZIP(), []int{348} } func (x *RequireStorageFilteredTagSummaryByIdRequest) GetContext() []*RequireStorageFilteredTagSummaryByIdContext { @@ -15283,7 +16203,7 @@ type RequireStorageFilteredTagSummaryByIdContext struct { func (x *RequireStorageFilteredTagSummaryByIdContext) Reset() { *x = RequireStorageFilteredTagSummaryByIdContext{} - mi := &file_product_proto_msgTypes[329] + mi := &file_product_proto_msgTypes[349] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15295,7 +16215,7 @@ func (x *RequireStorageFilteredTagSummaryByIdContext) String() string { func (*RequireStorageFilteredTagSummaryByIdContext) ProtoMessage() {} func (x *RequireStorageFilteredTagSummaryByIdContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[329] + mi := &file_product_proto_msgTypes[349] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15308,7 +16228,7 @@ func (x *RequireStorageFilteredTagSummaryByIdContext) ProtoReflect() protoreflec // Deprecated: Use RequireStorageFilteredTagSummaryByIdContext.ProtoReflect.Descriptor instead. func (*RequireStorageFilteredTagSummaryByIdContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{329} + return file_product_proto_rawDescGZIP(), []int{349} } func (x *RequireStorageFilteredTagSummaryByIdContext) GetKey() *LookupStorageByIdRequestKey { @@ -15334,7 +16254,7 @@ type RequireStorageFilteredTagSummaryByIdArgs struct { func (x *RequireStorageFilteredTagSummaryByIdArgs) Reset() { *x = RequireStorageFilteredTagSummaryByIdArgs{} - mi := &file_product_proto_msgTypes[330] + mi := &file_product_proto_msgTypes[350] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15346,7 +16266,7 @@ func (x *RequireStorageFilteredTagSummaryByIdArgs) String() string { func (*RequireStorageFilteredTagSummaryByIdArgs) ProtoMessage() {} func (x *RequireStorageFilteredTagSummaryByIdArgs) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[330] + mi := &file_product_proto_msgTypes[350] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15359,7 +16279,7 @@ func (x *RequireStorageFilteredTagSummaryByIdArgs) ProtoReflect() protoreflect.M // Deprecated: Use RequireStorageFilteredTagSummaryByIdArgs.ProtoReflect.Descriptor instead. func (*RequireStorageFilteredTagSummaryByIdArgs) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{330} + return file_product_proto_rawDescGZIP(), []int{350} } func (x *RequireStorageFilteredTagSummaryByIdArgs) GetPrefix() string { @@ -15379,7 +16299,7 @@ type RequireStorageFilteredTagSummaryByIdResponse struct { func (x *RequireStorageFilteredTagSummaryByIdResponse) Reset() { *x = RequireStorageFilteredTagSummaryByIdResponse{} - mi := &file_product_proto_msgTypes[331] + mi := &file_product_proto_msgTypes[351] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15391,7 +16311,7 @@ func (x *RequireStorageFilteredTagSummaryByIdResponse) String() string { func (*RequireStorageFilteredTagSummaryByIdResponse) ProtoMessage() {} func (x *RequireStorageFilteredTagSummaryByIdResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[331] + mi := &file_product_proto_msgTypes[351] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15404,7 +16324,7 @@ func (x *RequireStorageFilteredTagSummaryByIdResponse) ProtoReflect() protorefle // Deprecated: Use RequireStorageFilteredTagSummaryByIdResponse.ProtoReflect.Descriptor instead. func (*RequireStorageFilteredTagSummaryByIdResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{331} + return file_product_proto_rawDescGZIP(), []int{351} } func (x *RequireStorageFilteredTagSummaryByIdResponse) GetResult() []*RequireStorageFilteredTagSummaryByIdResult { @@ -15423,7 +16343,7 @@ type RequireStorageFilteredTagSummaryByIdResult struct { func (x *RequireStorageFilteredTagSummaryByIdResult) Reset() { *x = RequireStorageFilteredTagSummaryByIdResult{} - mi := &file_product_proto_msgTypes[332] + mi := &file_product_proto_msgTypes[352] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15435,7 +16355,7 @@ func (x *RequireStorageFilteredTagSummaryByIdResult) String() string { func (*RequireStorageFilteredTagSummaryByIdResult) ProtoMessage() {} func (x *RequireStorageFilteredTagSummaryByIdResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[332] + mi := &file_product_proto_msgTypes[352] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15448,7 +16368,7 @@ func (x *RequireStorageFilteredTagSummaryByIdResult) ProtoReflect() protoreflect // Deprecated: Use RequireStorageFilteredTagSummaryByIdResult.ProtoReflect.Descriptor instead. func (*RequireStorageFilteredTagSummaryByIdResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{332} + return file_product_proto_rawDescGZIP(), []int{352} } func (x *RequireStorageFilteredTagSummaryByIdResult) GetFilteredTagSummary() *wrapperspb.StringValue { @@ -15467,7 +16387,7 @@ type RequireStorageFilteredTagSummaryByIdFields struct { func (x *RequireStorageFilteredTagSummaryByIdFields) Reset() { *x = RequireStorageFilteredTagSummaryByIdFields{} - mi := &file_product_proto_msgTypes[333] + mi := &file_product_proto_msgTypes[353] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15479,7 +16399,7 @@ func (x *RequireStorageFilteredTagSummaryByIdFields) String() string { func (*RequireStorageFilteredTagSummaryByIdFields) ProtoMessage() {} func (x *RequireStorageFilteredTagSummaryByIdFields) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[333] + mi := &file_product_proto_msgTypes[353] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15492,7 +16412,7 @@ func (x *RequireStorageFilteredTagSummaryByIdFields) ProtoReflect() protoreflect // Deprecated: Use RequireStorageFilteredTagSummaryByIdFields.ProtoReflect.Descriptor instead. func (*RequireStorageFilteredTagSummaryByIdFields) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{333} + return file_product_proto_rawDescGZIP(), []int{353} } func (x *RequireStorageFilteredTagSummaryByIdFields) GetTags() []string { @@ -15514,7 +16434,7 @@ type RequireStorageMultiFilteredTagSummaryByIdRequest struct { func (x *RequireStorageMultiFilteredTagSummaryByIdRequest) Reset() { *x = RequireStorageMultiFilteredTagSummaryByIdRequest{} - mi := &file_product_proto_msgTypes[334] + mi := &file_product_proto_msgTypes[354] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15526,7 +16446,7 @@ func (x *RequireStorageMultiFilteredTagSummaryByIdRequest) String() string { func (*RequireStorageMultiFilteredTagSummaryByIdRequest) ProtoMessage() {} func (x *RequireStorageMultiFilteredTagSummaryByIdRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[334] + mi := &file_product_proto_msgTypes[354] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15539,7 +16459,7 @@ func (x *RequireStorageMultiFilteredTagSummaryByIdRequest) ProtoReflect() protor // Deprecated: Use RequireStorageMultiFilteredTagSummaryByIdRequest.ProtoReflect.Descriptor instead. func (*RequireStorageMultiFilteredTagSummaryByIdRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{334} + return file_product_proto_rawDescGZIP(), []int{354} } func (x *RequireStorageMultiFilteredTagSummaryByIdRequest) GetContext() []*RequireStorageMultiFilteredTagSummaryByIdContext { @@ -15566,7 +16486,7 @@ type RequireStorageMultiFilteredTagSummaryByIdContext struct { func (x *RequireStorageMultiFilteredTagSummaryByIdContext) Reset() { *x = RequireStorageMultiFilteredTagSummaryByIdContext{} - mi := &file_product_proto_msgTypes[335] + mi := &file_product_proto_msgTypes[355] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15578,7 +16498,7 @@ func (x *RequireStorageMultiFilteredTagSummaryByIdContext) String() string { func (*RequireStorageMultiFilteredTagSummaryByIdContext) ProtoMessage() {} func (x *RequireStorageMultiFilteredTagSummaryByIdContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[335] + mi := &file_product_proto_msgTypes[355] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15591,7 +16511,7 @@ func (x *RequireStorageMultiFilteredTagSummaryByIdContext) ProtoReflect() protor // Deprecated: Use RequireStorageMultiFilteredTagSummaryByIdContext.ProtoReflect.Descriptor instead. func (*RequireStorageMultiFilteredTagSummaryByIdContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{335} + return file_product_proto_rawDescGZIP(), []int{355} } func (x *RequireStorageMultiFilteredTagSummaryByIdContext) GetKey() *LookupStorageByIdRequestKey { @@ -15618,7 +16538,7 @@ type RequireStorageMultiFilteredTagSummaryByIdArgs struct { func (x *RequireStorageMultiFilteredTagSummaryByIdArgs) Reset() { *x = RequireStorageMultiFilteredTagSummaryByIdArgs{} - mi := &file_product_proto_msgTypes[336] + mi := &file_product_proto_msgTypes[356] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15630,7 +16550,7 @@ func (x *RequireStorageMultiFilteredTagSummaryByIdArgs) String() string { func (*RequireStorageMultiFilteredTagSummaryByIdArgs) ProtoMessage() {} func (x *RequireStorageMultiFilteredTagSummaryByIdArgs) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[336] + mi := &file_product_proto_msgTypes[356] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15643,7 +16563,7 @@ func (x *RequireStorageMultiFilteredTagSummaryByIdArgs) ProtoReflect() protorefl // Deprecated: Use RequireStorageMultiFilteredTagSummaryByIdArgs.ProtoReflect.Descriptor instead. func (*RequireStorageMultiFilteredTagSummaryByIdArgs) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{336} + return file_product_proto_rawDescGZIP(), []int{356} } func (x *RequireStorageMultiFilteredTagSummaryByIdArgs) GetPrefixes() []string { @@ -15670,7 +16590,7 @@ type RequireStorageMultiFilteredTagSummaryByIdResponse struct { func (x *RequireStorageMultiFilteredTagSummaryByIdResponse) Reset() { *x = RequireStorageMultiFilteredTagSummaryByIdResponse{} - mi := &file_product_proto_msgTypes[337] + mi := &file_product_proto_msgTypes[357] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15682,7 +16602,7 @@ func (x *RequireStorageMultiFilteredTagSummaryByIdResponse) String() string { func (*RequireStorageMultiFilteredTagSummaryByIdResponse) ProtoMessage() {} func (x *RequireStorageMultiFilteredTagSummaryByIdResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[337] + mi := &file_product_proto_msgTypes[357] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15695,7 +16615,7 @@ func (x *RequireStorageMultiFilteredTagSummaryByIdResponse) ProtoReflect() proto // Deprecated: Use RequireStorageMultiFilteredTagSummaryByIdResponse.ProtoReflect.Descriptor instead. func (*RequireStorageMultiFilteredTagSummaryByIdResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{337} + return file_product_proto_rawDescGZIP(), []int{357} } func (x *RequireStorageMultiFilteredTagSummaryByIdResponse) GetResult() []*RequireStorageMultiFilteredTagSummaryByIdResult { @@ -15714,7 +16634,7 @@ type RequireStorageMultiFilteredTagSummaryByIdResult struct { func (x *RequireStorageMultiFilteredTagSummaryByIdResult) Reset() { *x = RequireStorageMultiFilteredTagSummaryByIdResult{} - mi := &file_product_proto_msgTypes[338] + mi := &file_product_proto_msgTypes[358] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15726,7 +16646,7 @@ func (x *RequireStorageMultiFilteredTagSummaryByIdResult) String() string { func (*RequireStorageMultiFilteredTagSummaryByIdResult) ProtoMessage() {} func (x *RequireStorageMultiFilteredTagSummaryByIdResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[338] + mi := &file_product_proto_msgTypes[358] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15739,7 +16659,7 @@ func (x *RequireStorageMultiFilteredTagSummaryByIdResult) ProtoReflect() protore // Deprecated: Use RequireStorageMultiFilteredTagSummaryByIdResult.ProtoReflect.Descriptor instead. func (*RequireStorageMultiFilteredTagSummaryByIdResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{338} + return file_product_proto_rawDescGZIP(), []int{358} } func (x *RequireStorageMultiFilteredTagSummaryByIdResult) GetMultiFilteredTagSummary() *wrapperspb.StringValue { @@ -15758,7 +16678,7 @@ type RequireStorageMultiFilteredTagSummaryByIdFields struct { func (x *RequireStorageMultiFilteredTagSummaryByIdFields) Reset() { *x = RequireStorageMultiFilteredTagSummaryByIdFields{} - mi := &file_product_proto_msgTypes[339] + mi := &file_product_proto_msgTypes[359] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15770,7 +16690,7 @@ func (x *RequireStorageMultiFilteredTagSummaryByIdFields) String() string { func (*RequireStorageMultiFilteredTagSummaryByIdFields) ProtoMessage() {} func (x *RequireStorageMultiFilteredTagSummaryByIdFields) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[339] + mi := &file_product_proto_msgTypes[359] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15783,7 +16703,7 @@ func (x *RequireStorageMultiFilteredTagSummaryByIdFields) ProtoReflect() protore // Deprecated: Use RequireStorageMultiFilteredTagSummaryByIdFields.ProtoReflect.Descriptor instead. func (*RequireStorageMultiFilteredTagSummaryByIdFields) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{339} + return file_product_proto_rawDescGZIP(), []int{359} } func (x *RequireStorageMultiFilteredTagSummaryByIdFields) GetTags() []string { @@ -15805,7 +16725,7 @@ type RequireStorageNullableFilteredTagSummaryByIdRequest struct { func (x *RequireStorageNullableFilteredTagSummaryByIdRequest) Reset() { *x = RequireStorageNullableFilteredTagSummaryByIdRequest{} - mi := &file_product_proto_msgTypes[340] + mi := &file_product_proto_msgTypes[360] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15817,7 +16737,7 @@ func (x *RequireStorageNullableFilteredTagSummaryByIdRequest) String() string { func (*RequireStorageNullableFilteredTagSummaryByIdRequest) ProtoMessage() {} func (x *RequireStorageNullableFilteredTagSummaryByIdRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[340] + mi := &file_product_proto_msgTypes[360] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15830,7 +16750,7 @@ func (x *RequireStorageNullableFilteredTagSummaryByIdRequest) ProtoReflect() pro // Deprecated: Use RequireStorageNullableFilteredTagSummaryByIdRequest.ProtoReflect.Descriptor instead. func (*RequireStorageNullableFilteredTagSummaryByIdRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{340} + return file_product_proto_rawDescGZIP(), []int{360} } func (x *RequireStorageNullableFilteredTagSummaryByIdRequest) GetContext() []*RequireStorageNullableFilteredTagSummaryByIdContext { @@ -15857,7 +16777,7 @@ type RequireStorageNullableFilteredTagSummaryByIdContext struct { func (x *RequireStorageNullableFilteredTagSummaryByIdContext) Reset() { *x = RequireStorageNullableFilteredTagSummaryByIdContext{} - mi := &file_product_proto_msgTypes[341] + mi := &file_product_proto_msgTypes[361] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15869,7 +16789,7 @@ func (x *RequireStorageNullableFilteredTagSummaryByIdContext) String() string { func (*RequireStorageNullableFilteredTagSummaryByIdContext) ProtoMessage() {} func (x *RequireStorageNullableFilteredTagSummaryByIdContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[341] + mi := &file_product_proto_msgTypes[361] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15882,7 +16802,7 @@ func (x *RequireStorageNullableFilteredTagSummaryByIdContext) ProtoReflect() pro // Deprecated: Use RequireStorageNullableFilteredTagSummaryByIdContext.ProtoReflect.Descriptor instead. func (*RequireStorageNullableFilteredTagSummaryByIdContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{341} + return file_product_proto_rawDescGZIP(), []int{361} } func (x *RequireStorageNullableFilteredTagSummaryByIdContext) GetKey() *LookupStorageByIdRequestKey { @@ -15908,7 +16828,7 @@ type RequireStorageNullableFilteredTagSummaryByIdArgs struct { func (x *RequireStorageNullableFilteredTagSummaryByIdArgs) Reset() { *x = RequireStorageNullableFilteredTagSummaryByIdArgs{} - mi := &file_product_proto_msgTypes[342] + mi := &file_product_proto_msgTypes[362] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15920,7 +16840,7 @@ func (x *RequireStorageNullableFilteredTagSummaryByIdArgs) String() string { func (*RequireStorageNullableFilteredTagSummaryByIdArgs) ProtoMessage() {} func (x *RequireStorageNullableFilteredTagSummaryByIdArgs) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[342] + mi := &file_product_proto_msgTypes[362] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15933,7 +16853,7 @@ func (x *RequireStorageNullableFilteredTagSummaryByIdArgs) ProtoReflect() protor // Deprecated: Use RequireStorageNullableFilteredTagSummaryByIdArgs.ProtoReflect.Descriptor instead. func (*RequireStorageNullableFilteredTagSummaryByIdArgs) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{342} + return file_product_proto_rawDescGZIP(), []int{362} } func (x *RequireStorageNullableFilteredTagSummaryByIdArgs) GetPrefix() *wrapperspb.StringValue { @@ -15953,7 +16873,7 @@ type RequireStorageNullableFilteredTagSummaryByIdResponse struct { func (x *RequireStorageNullableFilteredTagSummaryByIdResponse) Reset() { *x = RequireStorageNullableFilteredTagSummaryByIdResponse{} - mi := &file_product_proto_msgTypes[343] + mi := &file_product_proto_msgTypes[363] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15965,7 +16885,7 @@ func (x *RequireStorageNullableFilteredTagSummaryByIdResponse) String() string { func (*RequireStorageNullableFilteredTagSummaryByIdResponse) ProtoMessage() {} func (x *RequireStorageNullableFilteredTagSummaryByIdResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[343] + mi := &file_product_proto_msgTypes[363] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15978,7 +16898,7 @@ func (x *RequireStorageNullableFilteredTagSummaryByIdResponse) ProtoReflect() pr // Deprecated: Use RequireStorageNullableFilteredTagSummaryByIdResponse.ProtoReflect.Descriptor instead. func (*RequireStorageNullableFilteredTagSummaryByIdResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{343} + return file_product_proto_rawDescGZIP(), []int{363} } func (x *RequireStorageNullableFilteredTagSummaryByIdResponse) GetResult() []*RequireStorageNullableFilteredTagSummaryByIdResult { @@ -15997,7 +16917,7 @@ type RequireStorageNullableFilteredTagSummaryByIdResult struct { func (x *RequireStorageNullableFilteredTagSummaryByIdResult) Reset() { *x = RequireStorageNullableFilteredTagSummaryByIdResult{} - mi := &file_product_proto_msgTypes[344] + mi := &file_product_proto_msgTypes[364] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16009,7 +16929,7 @@ func (x *RequireStorageNullableFilteredTagSummaryByIdResult) String() string { func (*RequireStorageNullableFilteredTagSummaryByIdResult) ProtoMessage() {} func (x *RequireStorageNullableFilteredTagSummaryByIdResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[344] + mi := &file_product_proto_msgTypes[364] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16022,7 +16942,7 @@ func (x *RequireStorageNullableFilteredTagSummaryByIdResult) ProtoReflect() prot // Deprecated: Use RequireStorageNullableFilteredTagSummaryByIdResult.ProtoReflect.Descriptor instead. func (*RequireStorageNullableFilteredTagSummaryByIdResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{344} + return file_product_proto_rawDescGZIP(), []int{364} } func (x *RequireStorageNullableFilteredTagSummaryByIdResult) GetNullableFilteredTagSummary() *wrapperspb.StringValue { @@ -16041,7 +16961,7 @@ type RequireStorageNullableFilteredTagSummaryByIdFields struct { func (x *RequireStorageNullableFilteredTagSummaryByIdFields) Reset() { *x = RequireStorageNullableFilteredTagSummaryByIdFields{} - mi := &file_product_proto_msgTypes[345] + mi := &file_product_proto_msgTypes[365] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16053,7 +16973,7 @@ func (x *RequireStorageNullableFilteredTagSummaryByIdFields) String() string { func (*RequireStorageNullableFilteredTagSummaryByIdFields) ProtoMessage() {} func (x *RequireStorageNullableFilteredTagSummaryByIdFields) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[345] + mi := &file_product_proto_msgTypes[365] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16066,7 +16986,7 @@ func (x *RequireStorageNullableFilteredTagSummaryByIdFields) ProtoReflect() prot // Deprecated: Use RequireStorageNullableFilteredTagSummaryByIdFields.ProtoReflect.Descriptor instead. func (*RequireStorageNullableFilteredTagSummaryByIdFields) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{345} + return file_product_proto_rawDescGZIP(), []int{365} } func (x *RequireStorageNullableFilteredTagSummaryByIdFields) GetTags() []string { @@ -16086,7 +17006,7 @@ type RequireWarehouseStockHealthScoreByIdRequest struct { func (x *RequireWarehouseStockHealthScoreByIdRequest) Reset() { *x = RequireWarehouseStockHealthScoreByIdRequest{} - mi := &file_product_proto_msgTypes[346] + mi := &file_product_proto_msgTypes[366] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16098,7 +17018,7 @@ func (x *RequireWarehouseStockHealthScoreByIdRequest) String() string { func (*RequireWarehouseStockHealthScoreByIdRequest) ProtoMessage() {} func (x *RequireWarehouseStockHealthScoreByIdRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[346] + mi := &file_product_proto_msgTypes[366] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16111,7 +17031,7 @@ func (x *RequireWarehouseStockHealthScoreByIdRequest) ProtoReflect() protoreflec // Deprecated: Use RequireWarehouseStockHealthScoreByIdRequest.ProtoReflect.Descriptor instead. func (*RequireWarehouseStockHealthScoreByIdRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{346} + return file_product_proto_rawDescGZIP(), []int{366} } func (x *RequireWarehouseStockHealthScoreByIdRequest) GetContext() []*RequireWarehouseStockHealthScoreByIdContext { @@ -16131,7 +17051,7 @@ type RequireWarehouseStockHealthScoreByIdContext struct { func (x *RequireWarehouseStockHealthScoreByIdContext) Reset() { *x = RequireWarehouseStockHealthScoreByIdContext{} - mi := &file_product_proto_msgTypes[347] + mi := &file_product_proto_msgTypes[367] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16143,7 +17063,7 @@ func (x *RequireWarehouseStockHealthScoreByIdContext) String() string { func (*RequireWarehouseStockHealthScoreByIdContext) ProtoMessage() {} func (x *RequireWarehouseStockHealthScoreByIdContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[347] + mi := &file_product_proto_msgTypes[367] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16156,7 +17076,7 @@ func (x *RequireWarehouseStockHealthScoreByIdContext) ProtoReflect() protoreflec // Deprecated: Use RequireWarehouseStockHealthScoreByIdContext.ProtoReflect.Descriptor instead. func (*RequireWarehouseStockHealthScoreByIdContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{347} + return file_product_proto_rawDescGZIP(), []int{367} } func (x *RequireWarehouseStockHealthScoreByIdContext) GetKey() *LookupWarehouseByIdRequestKey { @@ -16183,7 +17103,7 @@ type RequireWarehouseStockHealthScoreByIdResponse struct { func (x *RequireWarehouseStockHealthScoreByIdResponse) Reset() { *x = RequireWarehouseStockHealthScoreByIdResponse{} - mi := &file_product_proto_msgTypes[348] + mi := &file_product_proto_msgTypes[368] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16195,7 +17115,7 @@ func (x *RequireWarehouseStockHealthScoreByIdResponse) String() string { func (*RequireWarehouseStockHealthScoreByIdResponse) ProtoMessage() {} func (x *RequireWarehouseStockHealthScoreByIdResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[348] + mi := &file_product_proto_msgTypes[368] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16208,7 +17128,7 @@ func (x *RequireWarehouseStockHealthScoreByIdResponse) ProtoReflect() protorefle // Deprecated: Use RequireWarehouseStockHealthScoreByIdResponse.ProtoReflect.Descriptor instead. func (*RequireWarehouseStockHealthScoreByIdResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{348} + return file_product_proto_rawDescGZIP(), []int{368} } func (x *RequireWarehouseStockHealthScoreByIdResponse) GetResult() []*RequireWarehouseStockHealthScoreByIdResult { @@ -16227,7 +17147,7 @@ type RequireWarehouseStockHealthScoreByIdResult struct { func (x *RequireWarehouseStockHealthScoreByIdResult) Reset() { *x = RequireWarehouseStockHealthScoreByIdResult{} - mi := &file_product_proto_msgTypes[349] + mi := &file_product_proto_msgTypes[369] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16239,7 +17159,7 @@ func (x *RequireWarehouseStockHealthScoreByIdResult) String() string { func (*RequireWarehouseStockHealthScoreByIdResult) ProtoMessage() {} func (x *RequireWarehouseStockHealthScoreByIdResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[349] + mi := &file_product_proto_msgTypes[369] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16252,7 +17172,7 @@ func (x *RequireWarehouseStockHealthScoreByIdResult) ProtoReflect() protoreflect // Deprecated: Use RequireWarehouseStockHealthScoreByIdResult.ProtoReflect.Descriptor instead. func (*RequireWarehouseStockHealthScoreByIdResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{349} + return file_product_proto_rawDescGZIP(), []int{369} } func (x *RequireWarehouseStockHealthScoreByIdResult) GetStockHealthScore() float64 { @@ -16272,7 +17192,7 @@ type RequireWarehouseStockHealthScoreByIdFields struct { func (x *RequireWarehouseStockHealthScoreByIdFields) Reset() { *x = RequireWarehouseStockHealthScoreByIdFields{} - mi := &file_product_proto_msgTypes[350] + mi := &file_product_proto_msgTypes[370] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16284,7 +17204,7 @@ func (x *RequireWarehouseStockHealthScoreByIdFields) String() string { func (*RequireWarehouseStockHealthScoreByIdFields) ProtoMessage() {} func (x *RequireWarehouseStockHealthScoreByIdFields) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[350] + mi := &file_product_proto_msgTypes[370] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16297,7 +17217,7 @@ func (x *RequireWarehouseStockHealthScoreByIdFields) ProtoReflect() protoreflect // Deprecated: Use RequireWarehouseStockHealthScoreByIdFields.ProtoReflect.Descriptor instead. func (*RequireWarehouseStockHealthScoreByIdFields) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{350} + return file_product_proto_rawDescGZIP(), []int{370} } func (x *RequireWarehouseStockHealthScoreByIdFields) GetInventoryCount() int32 { @@ -16325,7 +17245,7 @@ type Product struct { func (x *Product) Reset() { *x = Product{} - mi := &file_product_proto_msgTypes[351] + mi := &file_product_proto_msgTypes[371] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16337,7 +17257,7 @@ func (x *Product) String() string { func (*Product) ProtoMessage() {} func (x *Product) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[351] + mi := &file_product_proto_msgTypes[371] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16350,7 +17270,7 @@ func (x *Product) ProtoReflect() protoreflect.Message { // Deprecated: Use Product.ProtoReflect.Descriptor instead. func (*Product) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{351} + return file_product_proto_rawDescGZIP(), []int{371} } func (x *Product) GetId() string { @@ -16385,7 +17305,7 @@ type Storage struct { func (x *Storage) Reset() { *x = Storage{} - mi := &file_product_proto_msgTypes[352] + mi := &file_product_proto_msgTypes[372] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16397,7 +17317,7 @@ func (x *Storage) String() string { func (*Storage) ProtoMessage() {} func (x *Storage) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[352] + mi := &file_product_proto_msgTypes[372] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16410,7 +17330,7 @@ func (x *Storage) ProtoReflect() protoreflect.Message { // Deprecated: Use Storage.ProtoReflect.Descriptor instead. func (*Storage) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{352} + return file_product_proto_rawDescGZIP(), []int{372} } func (x *Storage) GetId() string { @@ -16445,7 +17365,7 @@ type Warehouse struct { func (x *Warehouse) Reset() { *x = Warehouse{} - mi := &file_product_proto_msgTypes[353] + mi := &file_product_proto_msgTypes[373] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16457,7 +17377,7 @@ func (x *Warehouse) String() string { func (*Warehouse) ProtoMessage() {} func (x *Warehouse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[353] + mi := &file_product_proto_msgTypes[373] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16470,7 +17390,7 @@ func (x *Warehouse) ProtoReflect() protoreflect.Message { // Deprecated: Use Warehouse.ProtoReflect.Descriptor instead. func (*Warehouse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{353} + return file_product_proto_rawDescGZIP(), []int{373} } func (x *Warehouse) GetId() string { @@ -16504,7 +17424,7 @@ type User struct { func (x *User) Reset() { *x = User{} - mi := &file_product_proto_msgTypes[354] + mi := &file_product_proto_msgTypes[374] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16516,7 +17436,7 @@ func (x *User) String() string { func (*User) ProtoMessage() {} func (x *User) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[354] + mi := &file_product_proto_msgTypes[374] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16529,7 +17449,7 @@ func (x *User) ProtoReflect() protoreflect.Message { // Deprecated: Use User.ProtoReflect.Descriptor instead. func (*User) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{354} + return file_product_proto_rawDescGZIP(), []int{374} } func (x *User) GetId() string { @@ -16557,7 +17477,7 @@ type NestedTypeA struct { func (x *NestedTypeA) Reset() { *x = NestedTypeA{} - mi := &file_product_proto_msgTypes[355] + mi := &file_product_proto_msgTypes[375] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16569,7 +17489,7 @@ func (x *NestedTypeA) String() string { func (*NestedTypeA) ProtoMessage() {} func (x *NestedTypeA) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[355] + mi := &file_product_proto_msgTypes[375] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16582,7 +17502,7 @@ func (x *NestedTypeA) ProtoReflect() protoreflect.Message { // Deprecated: Use NestedTypeA.ProtoReflect.Descriptor instead. func (*NestedTypeA) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{355} + return file_product_proto_rawDescGZIP(), []int{375} } func (x *NestedTypeA) GetId() string { @@ -16617,7 +17537,7 @@ type RecursiveType struct { func (x *RecursiveType) Reset() { *x = RecursiveType{} - mi := &file_product_proto_msgTypes[356] + mi := &file_product_proto_msgTypes[376] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16629,7 +17549,7 @@ func (x *RecursiveType) String() string { func (*RecursiveType) ProtoMessage() {} func (x *RecursiveType) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[356] + mi := &file_product_proto_msgTypes[376] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16642,7 +17562,7 @@ func (x *RecursiveType) ProtoReflect() protoreflect.Message { // Deprecated: Use RecursiveType.ProtoReflect.Descriptor instead. func (*RecursiveType) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{356} + return file_product_proto_rawDescGZIP(), []int{376} } func (x *RecursiveType) GetId() string { @@ -16678,7 +17598,7 @@ type TypeWithMultipleFilterFields struct { func (x *TypeWithMultipleFilterFields) Reset() { *x = TypeWithMultipleFilterFields{} - mi := &file_product_proto_msgTypes[357] + mi := &file_product_proto_msgTypes[377] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16690,7 +17610,7 @@ func (x *TypeWithMultipleFilterFields) String() string { func (*TypeWithMultipleFilterFields) ProtoMessage() {} func (x *TypeWithMultipleFilterFields) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[357] + mi := &file_product_proto_msgTypes[377] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16703,7 +17623,7 @@ func (x *TypeWithMultipleFilterFields) ProtoReflect() protoreflect.Message { // Deprecated: Use TypeWithMultipleFilterFields.ProtoReflect.Descriptor instead. func (*TypeWithMultipleFilterFields) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{357} + return file_product_proto_rawDescGZIP(), []int{377} } func (x *TypeWithMultipleFilterFields) GetId() string { @@ -16744,7 +17664,7 @@ type FilterTypeInput struct { func (x *FilterTypeInput) Reset() { *x = FilterTypeInput{} - mi := &file_product_proto_msgTypes[358] + mi := &file_product_proto_msgTypes[378] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16756,7 +17676,7 @@ func (x *FilterTypeInput) String() string { func (*FilterTypeInput) ProtoMessage() {} func (x *FilterTypeInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[358] + mi := &file_product_proto_msgTypes[378] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16769,7 +17689,7 @@ func (x *FilterTypeInput) ProtoReflect() protoreflect.Message { // Deprecated: Use FilterTypeInput.ProtoReflect.Descriptor instead. func (*FilterTypeInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{358} + return file_product_proto_rawDescGZIP(), []int{378} } func (x *FilterTypeInput) GetFilterField_1() string { @@ -16795,7 +17715,7 @@ type ComplexFilterTypeInput struct { func (x *ComplexFilterTypeInput) Reset() { *x = ComplexFilterTypeInput{} - mi := &file_product_proto_msgTypes[359] + mi := &file_product_proto_msgTypes[379] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16807,7 +17727,7 @@ func (x *ComplexFilterTypeInput) String() string { func (*ComplexFilterTypeInput) ProtoMessage() {} func (x *ComplexFilterTypeInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[359] + mi := &file_product_proto_msgTypes[379] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16820,7 +17740,7 @@ func (x *ComplexFilterTypeInput) ProtoReflect() protoreflect.Message { // Deprecated: Use ComplexFilterTypeInput.ProtoReflect.Descriptor instead. func (*ComplexFilterTypeInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{359} + return file_product_proto_rawDescGZIP(), []int{379} } func (x *ComplexFilterTypeInput) GetFilter() *FilterType { @@ -16840,7 +17760,7 @@ type TypeWithComplexFilterInput struct { func (x *TypeWithComplexFilterInput) Reset() { *x = TypeWithComplexFilterInput{} - mi := &file_product_proto_msgTypes[360] + mi := &file_product_proto_msgTypes[380] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16852,7 +17772,7 @@ func (x *TypeWithComplexFilterInput) String() string { func (*TypeWithComplexFilterInput) ProtoMessage() {} func (x *TypeWithComplexFilterInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[360] + mi := &file_product_proto_msgTypes[380] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16865,7 +17785,7 @@ func (x *TypeWithComplexFilterInput) ProtoReflect() protoreflect.Message { // Deprecated: Use TypeWithComplexFilterInput.ProtoReflect.Descriptor instead. func (*TypeWithComplexFilterInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{360} + return file_product_proto_rawDescGZIP(), []int{380} } func (x *TypeWithComplexFilterInput) GetId() string { @@ -16893,7 +17813,7 @@ type OrderInput struct { func (x *OrderInput) Reset() { *x = OrderInput{} - mi := &file_product_proto_msgTypes[361] + mi := &file_product_proto_msgTypes[381] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16905,7 +17825,7 @@ func (x *OrderInput) String() string { func (*OrderInput) ProtoMessage() {} func (x *OrderInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[361] + mi := &file_product_proto_msgTypes[381] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16918,7 +17838,7 @@ func (x *OrderInput) ProtoReflect() protoreflect.Message { // Deprecated: Use OrderInput.ProtoReflect.Descriptor instead. func (*OrderInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{361} + return file_product_proto_rawDescGZIP(), []int{381} } func (x *OrderInput) GetOrderId() string { @@ -16954,7 +17874,7 @@ type Order struct { func (x *Order) Reset() { *x = Order{} - mi := &file_product_proto_msgTypes[362] + mi := &file_product_proto_msgTypes[382] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -16966,7 +17886,7 @@ func (x *Order) String() string { func (*Order) ProtoMessage() {} func (x *Order) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[362] + mi := &file_product_proto_msgTypes[382] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -16979,7 +17899,7 @@ func (x *Order) ProtoReflect() protoreflect.Message { // Deprecated: Use Order.ProtoReflect.Descriptor instead. func (*Order) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{362} + return file_product_proto_rawDescGZIP(), []int{382} } func (x *Order) GetOrderId() string { @@ -17023,7 +17943,7 @@ type Category struct { func (x *Category) Reset() { *x = Category{} - mi := &file_product_proto_msgTypes[363] + mi := &file_product_proto_msgTypes[383] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17035,7 +17955,7 @@ func (x *Category) String() string { func (*Category) ProtoMessage() {} func (x *Category) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[363] + mi := &file_product_proto_msgTypes[383] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17048,7 +17968,7 @@ func (x *Category) ProtoReflect() protoreflect.Message { // Deprecated: Use Category.ProtoReflect.Descriptor instead. func (*Category) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{363} + return file_product_proto_rawDescGZIP(), []int{383} } func (x *Category) GetId() string { @@ -17096,7 +18016,7 @@ type CategoryFilter struct { func (x *CategoryFilter) Reset() { *x = CategoryFilter{} - mi := &file_product_proto_msgTypes[364] + mi := &file_product_proto_msgTypes[384] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17108,7 +18028,7 @@ func (x *CategoryFilter) String() string { func (*CategoryFilter) ProtoMessage() {} func (x *CategoryFilter) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[364] + mi := &file_product_proto_msgTypes[384] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17121,7 +18041,7 @@ func (x *CategoryFilter) ProtoReflect() protoreflect.Message { // Deprecated: Use CategoryFilter.ProtoReflect.Descriptor instead. func (*CategoryFilter) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{364} + return file_product_proto_rawDescGZIP(), []int{384} } func (x *CategoryFilter) GetCategory() CategoryKind { @@ -17151,7 +18071,7 @@ type Animal struct { func (x *Animal) Reset() { *x = Animal{} - mi := &file_product_proto_msgTypes[365] + mi := &file_product_proto_msgTypes[385] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17163,7 +18083,7 @@ func (x *Animal) String() string { func (*Animal) ProtoMessage() {} func (x *Animal) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[365] + mi := &file_product_proto_msgTypes[385] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17176,7 +18096,7 @@ func (x *Animal) ProtoReflect() protoreflect.Message { // Deprecated: Use Animal.ProtoReflect.Descriptor instead. func (*Animal) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{365} + return file_product_proto_rawDescGZIP(), []int{385} } func (x *Animal) GetInstance() isAnimal_Instance { @@ -17230,7 +18150,7 @@ type SearchInput struct { func (x *SearchInput) Reset() { *x = SearchInput{} - mi := &file_product_proto_msgTypes[366] + mi := &file_product_proto_msgTypes[386] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17242,7 +18162,7 @@ func (x *SearchInput) String() string { func (*SearchInput) ProtoMessage() {} func (x *SearchInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[366] + mi := &file_product_proto_msgTypes[386] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17255,7 +18175,7 @@ func (x *SearchInput) ProtoReflect() protoreflect.Message { // Deprecated: Use SearchInput.ProtoReflect.Descriptor instead. func (*SearchInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{366} + return file_product_proto_rawDescGZIP(), []int{386} } func (x *SearchInput) GetQuery() string { @@ -17286,7 +18206,7 @@ type SearchResult struct { func (x *SearchResult) Reset() { *x = SearchResult{} - mi := &file_product_proto_msgTypes[367] + mi := &file_product_proto_msgTypes[387] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17298,7 +18218,7 @@ func (x *SearchResult) String() string { func (*SearchResult) ProtoMessage() {} func (x *SearchResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[367] + mi := &file_product_proto_msgTypes[387] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17311,7 +18231,7 @@ func (x *SearchResult) ProtoReflect() protoreflect.Message { // Deprecated: Use SearchResult.ProtoReflect.Descriptor instead. func (*SearchResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{367} + return file_product_proto_rawDescGZIP(), []int{387} } func (x *SearchResult) GetValue() isSearchResult_Value { @@ -17386,7 +18306,7 @@ type NullableFieldsType struct { func (x *NullableFieldsType) Reset() { *x = NullableFieldsType{} - mi := &file_product_proto_msgTypes[368] + mi := &file_product_proto_msgTypes[388] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17398,7 +18318,7 @@ func (x *NullableFieldsType) String() string { func (*NullableFieldsType) ProtoMessage() {} func (x *NullableFieldsType) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[368] + mi := &file_product_proto_msgTypes[388] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17411,7 +18331,7 @@ func (x *NullableFieldsType) ProtoReflect() protoreflect.Message { // Deprecated: Use NullableFieldsType.ProtoReflect.Descriptor instead. func (*NullableFieldsType) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{368} + return file_product_proto_rawDescGZIP(), []int{388} } func (x *NullableFieldsType) GetId() string { @@ -17481,7 +18401,7 @@ type NullableFieldsFilter struct { func (x *NullableFieldsFilter) Reset() { *x = NullableFieldsFilter{} - mi := &file_product_proto_msgTypes[369] + mi := &file_product_proto_msgTypes[389] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17493,7 +18413,7 @@ func (x *NullableFieldsFilter) String() string { func (*NullableFieldsFilter) ProtoMessage() {} func (x *NullableFieldsFilter) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[369] + mi := &file_product_proto_msgTypes[389] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17506,7 +18426,7 @@ func (x *NullableFieldsFilter) ProtoReflect() protoreflect.Message { // Deprecated: Use NullableFieldsFilter.ProtoReflect.Descriptor instead. func (*NullableFieldsFilter) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{369} + return file_product_proto_rawDescGZIP(), []int{389} } func (x *NullableFieldsFilter) GetName() *wrapperspb.StringValue { @@ -17558,7 +18478,7 @@ type BlogPost struct { func (x *BlogPost) Reset() { *x = BlogPost{} - mi := &file_product_proto_msgTypes[370] + mi := &file_product_proto_msgTypes[390] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17570,7 +18490,7 @@ func (x *BlogPost) String() string { func (*BlogPost) ProtoMessage() {} func (x *BlogPost) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[370] + mi := &file_product_proto_msgTypes[390] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17583,7 +18503,7 @@ func (x *BlogPost) ProtoReflect() protoreflect.Message { // Deprecated: Use BlogPost.ProtoReflect.Descriptor instead. func (*BlogPost) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{370} + return file_product_proto_rawDescGZIP(), []int{390} } func (x *BlogPost) GetId() string { @@ -17737,7 +18657,7 @@ type BlogPostFilter struct { func (x *BlogPostFilter) Reset() { *x = BlogPostFilter{} - mi := &file_product_proto_msgTypes[371] + mi := &file_product_proto_msgTypes[391] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17749,7 +18669,7 @@ func (x *BlogPostFilter) String() string { func (*BlogPostFilter) ProtoMessage() {} func (x *BlogPostFilter) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[371] + mi := &file_product_proto_msgTypes[391] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17762,7 +18682,7 @@ func (x *BlogPostFilter) ProtoReflect() protoreflect.Message { // Deprecated: Use BlogPostFilter.ProtoReflect.Descriptor instead. func (*BlogPostFilter) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{371} + return file_product_proto_rawDescGZIP(), []int{391} } func (x *BlogPostFilter) GetTitle() *wrapperspb.StringValue { @@ -17809,7 +18729,7 @@ type Author struct { func (x *Author) Reset() { *x = Author{} - mi := &file_product_proto_msgTypes[372] + mi := &file_product_proto_msgTypes[392] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17821,7 +18741,7 @@ func (x *Author) String() string { func (*Author) ProtoMessage() {} func (x *Author) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[372] + mi := &file_product_proto_msgTypes[392] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17834,7 +18754,7 @@ func (x *Author) ProtoReflect() protoreflect.Message { // Deprecated: Use Author.ProtoReflect.Descriptor instead. func (*Author) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{372} + return file_product_proto_rawDescGZIP(), []int{392} } func (x *Author) GetId() string { @@ -17953,7 +18873,7 @@ type AuthorFilter struct { func (x *AuthorFilter) Reset() { *x = AuthorFilter{} - mi := &file_product_proto_msgTypes[373] + mi := &file_product_proto_msgTypes[393] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -17965,7 +18885,7 @@ func (x *AuthorFilter) String() string { func (*AuthorFilter) ProtoMessage() {} func (x *AuthorFilter) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[373] + mi := &file_product_proto_msgTypes[393] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -17978,7 +18898,7 @@ func (x *AuthorFilter) ProtoReflect() protoreflect.Message { // Deprecated: Use AuthorFilter.ProtoReflect.Descriptor instead. func (*AuthorFilter) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{373} + return file_product_proto_rawDescGZIP(), []int{393} } func (x *AuthorFilter) GetName() *wrapperspb.StringValue { @@ -18013,7 +18933,7 @@ type TestContainer struct { func (x *TestContainer) Reset() { *x = TestContainer{} - mi := &file_product_proto_msgTypes[374] + mi := &file_product_proto_msgTypes[394] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -18025,7 +18945,7 @@ func (x *TestContainer) String() string { func (*TestContainer) ProtoMessage() {} func (x *TestContainer) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[374] + mi := &file_product_proto_msgTypes[394] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18038,7 +18958,7 @@ func (x *TestContainer) ProtoReflect() protoreflect.Message { // Deprecated: Use TestContainer.ProtoReflect.Descriptor instead. func (*TestContainer) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{374} + return file_product_proto_rawDescGZIP(), []int{394} } func (x *TestContainer) GetId() string { @@ -18074,7 +18994,7 @@ type ConditionsInput struct { func (x *ConditionsInput) Reset() { *x = ConditionsInput{} - mi := &file_product_proto_msgTypes[375] + mi := &file_product_proto_msgTypes[395] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -18086,7 +19006,7 @@ func (x *ConditionsInput) String() string { func (*ConditionsInput) ProtoMessage() {} func (x *ConditionsInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[375] + mi := &file_product_proto_msgTypes[395] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18099,7 +19019,7 @@ func (x *ConditionsInput) ProtoReflect() protoreflect.Message { // Deprecated: Use ConditionsInput.ProtoReflect.Descriptor instead. func (*ConditionsInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{375} + return file_product_proto_rawDescGZIP(), []int{395} } func (x *ConditionsInput) GetAnd() *ListOfConditionsInput { @@ -18141,7 +19061,7 @@ type ConditionalSearchResult struct { func (x *ConditionalSearchResult) Reset() { *x = ConditionalSearchResult{} - mi := &file_product_proto_msgTypes[376] + mi := &file_product_proto_msgTypes[396] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -18153,7 +19073,7 @@ func (x *ConditionalSearchResult) String() string { func (*ConditionalSearchResult) ProtoMessage() {} func (x *ConditionalSearchResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[376] + mi := &file_product_proto_msgTypes[396] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18166,7 +19086,7 @@ func (x *ConditionalSearchResult) ProtoReflect() protoreflect.Message { // Deprecated: Use ConditionalSearchResult.ProtoReflect.Descriptor instead. func (*ConditionalSearchResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{376} + return file_product_proto_rawDescGZIP(), []int{396} } func (x *ConditionalSearchResult) GetId() string { @@ -18199,7 +19119,7 @@ type UserInput struct { func (x *UserInput) Reset() { *x = UserInput{} - mi := &file_product_proto_msgTypes[377] + mi := &file_product_proto_msgTypes[397] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -18211,7 +19131,7 @@ func (x *UserInput) String() string { func (*UserInput) ProtoMessage() {} func (x *UserInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[377] + mi := &file_product_proto_msgTypes[397] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18224,7 +19144,7 @@ func (x *UserInput) ProtoReflect() protoreflect.Message { // Deprecated: Use UserInput.ProtoReflect.Descriptor instead. func (*UserInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{377} + return file_product_proto_rawDescGZIP(), []int{397} } func (x *UserInput) GetName() string { @@ -18244,7 +19164,7 @@ type ActionInput struct { func (x *ActionInput) Reset() { *x = ActionInput{} - mi := &file_product_proto_msgTypes[378] + mi := &file_product_proto_msgTypes[398] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -18256,7 +19176,7 @@ func (x *ActionInput) String() string { func (*ActionInput) ProtoMessage() {} func (x *ActionInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[378] + mi := &file_product_proto_msgTypes[398] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18269,7 +19189,7 @@ func (x *ActionInput) ProtoReflect() protoreflect.Message { // Deprecated: Use ActionInput.ProtoReflect.Descriptor instead. func (*ActionInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{378} + return file_product_proto_rawDescGZIP(), []int{398} } func (x *ActionInput) GetType() string { @@ -18299,7 +19219,7 @@ type ActionResult struct { func (x *ActionResult) Reset() { *x = ActionResult{} - mi := &file_product_proto_msgTypes[379] + mi := &file_product_proto_msgTypes[399] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -18311,7 +19231,7 @@ func (x *ActionResult) String() string { func (*ActionResult) ProtoMessage() {} func (x *ActionResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[379] + mi := &file_product_proto_msgTypes[399] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18324,7 +19244,7 @@ func (x *ActionResult) ProtoReflect() protoreflect.Message { // Deprecated: Use ActionResult.ProtoReflect.Descriptor instead. func (*ActionResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{379} + return file_product_proto_rawDescGZIP(), []int{399} } func (x *ActionResult) GetValue() isActionResult_Value { @@ -18383,7 +19303,7 @@ type NullableFieldsInput struct { func (x *NullableFieldsInput) Reset() { *x = NullableFieldsInput{} - mi := &file_product_proto_msgTypes[380] + mi := &file_product_proto_msgTypes[400] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -18395,7 +19315,7 @@ func (x *NullableFieldsInput) String() string { func (*NullableFieldsInput) ProtoMessage() {} func (x *NullableFieldsInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[380] + mi := &file_product_proto_msgTypes[400] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18408,7 +19328,7 @@ func (x *NullableFieldsInput) ProtoReflect() protoreflect.Message { // Deprecated: Use NullableFieldsInput.ProtoReflect.Descriptor instead. func (*NullableFieldsInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{380} + return file_product_proto_rawDescGZIP(), []int{400} } func (x *NullableFieldsInput) GetName() string { @@ -18484,7 +19404,7 @@ type BlogPostInput struct { func (x *BlogPostInput) Reset() { *x = BlogPostInput{} - mi := &file_product_proto_msgTypes[381] + mi := &file_product_proto_msgTypes[401] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -18496,7 +19416,7 @@ func (x *BlogPostInput) String() string { func (*BlogPostInput) ProtoMessage() {} func (x *BlogPostInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[381] + mi := &file_product_proto_msgTypes[401] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18509,7 +19429,7 @@ func (x *BlogPostInput) ProtoReflect() protoreflect.Message { // Deprecated: Use BlogPostInput.ProtoReflect.Descriptor instead. func (*BlogPostInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{381} + return file_product_proto_rawDescGZIP(), []int{401} } func (x *BlogPostInput) GetTitle() string { @@ -18642,7 +19562,7 @@ type AuthorInput struct { func (x *AuthorInput) Reset() { *x = AuthorInput{} - mi := &file_product_proto_msgTypes[382] + mi := &file_product_proto_msgTypes[402] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -18654,7 +19574,7 @@ func (x *AuthorInput) String() string { func (*AuthorInput) ProtoMessage() {} func (x *AuthorInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[382] + mi := &file_product_proto_msgTypes[402] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18667,7 +19587,7 @@ func (x *AuthorInput) ProtoReflect() protoreflect.Message { // Deprecated: Use AuthorInput.ProtoReflect.Descriptor instead. func (*AuthorInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{382} + return file_product_proto_rawDescGZIP(), []int{402} } func (x *AuthorInput) GetName() string { @@ -18752,7 +19672,7 @@ type ProductDetails struct { func (x *ProductDetails) Reset() { *x = ProductDetails{} - mi := &file_product_proto_msgTypes[383] + mi := &file_product_proto_msgTypes[403] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -18764,7 +19684,7 @@ func (x *ProductDetails) String() string { func (*ProductDetails) ProtoMessage() {} func (x *ProductDetails) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[383] + mi := &file_product_proto_msgTypes[403] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18777,7 +19697,7 @@ func (x *ProductDetails) ProtoReflect() protoreflect.Message { // Deprecated: Use ProductDetails.ProtoReflect.Descriptor instead. func (*ProductDetails) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{383} + return file_product_proto_rawDescGZIP(), []int{403} } func (x *ProductDetails) GetId() string { @@ -18817,7 +19737,7 @@ type RestockData struct { func (x *RestockData) Reset() { *x = RestockData{} - mi := &file_product_proto_msgTypes[384] + mi := &file_product_proto_msgTypes[404] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -18829,7 +19749,7 @@ func (x *RestockData) String() string { func (*RestockData) ProtoMessage() {} func (x *RestockData) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[384] + mi := &file_product_proto_msgTypes[404] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18842,7 +19762,7 @@ func (x *RestockData) ProtoReflect() protoreflect.Message { // Deprecated: Use RestockData.ProtoReflect.Descriptor instead. func (*RestockData) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{384} + return file_product_proto_rawDescGZIP(), []int{404} } func (x *RestockData) GetLastRestockDate() string { @@ -18863,7 +19783,7 @@ type StorageMetadata struct { func (x *StorageMetadata) Reset() { *x = StorageMetadata{} - mi := &file_product_proto_msgTypes[385] + mi := &file_product_proto_msgTypes[405] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -18875,7 +19795,7 @@ func (x *StorageMetadata) String() string { func (*StorageMetadata) ProtoMessage() {} func (x *StorageMetadata) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[385] + mi := &file_product_proto_msgTypes[405] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18888,7 +19808,7 @@ func (x *StorageMetadata) ProtoReflect() protoreflect.Message { // Deprecated: Use StorageMetadata.ProtoReflect.Descriptor instead. func (*StorageMetadata) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{385} + return file_product_proto_rawDescGZIP(), []int{405} } func (x *StorageMetadata) GetCapacity() int32 { @@ -18922,7 +19842,7 @@ type StorageCategoryInfo struct { func (x *StorageCategoryInfo) Reset() { *x = StorageCategoryInfo{} - mi := &file_product_proto_msgTypes[386] + mi := &file_product_proto_msgTypes[406] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -18934,7 +19854,7 @@ func (x *StorageCategoryInfo) String() string { func (*StorageCategoryInfo) ProtoMessage() {} func (x *StorageCategoryInfo) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[386] + mi := &file_product_proto_msgTypes[406] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -18947,7 +19867,7 @@ func (x *StorageCategoryInfo) ProtoReflect() protoreflect.Message { // Deprecated: Use StorageCategoryInfo.ProtoReflect.Descriptor instead. func (*StorageCategoryInfo) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{386} + return file_product_proto_rawDescGZIP(), []int{406} } func (x *StorageCategoryInfo) GetKind() CategoryKind { @@ -18975,7 +19895,7 @@ type NestedTypeB struct { func (x *NestedTypeB) Reset() { *x = NestedTypeB{} - mi := &file_product_proto_msgTypes[387] + mi := &file_product_proto_msgTypes[407] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -18987,7 +19907,7 @@ func (x *NestedTypeB) String() string { func (*NestedTypeB) ProtoMessage() {} func (x *NestedTypeB) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[387] + mi := &file_product_proto_msgTypes[407] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -19000,7 +19920,7 @@ func (x *NestedTypeB) ProtoReflect() protoreflect.Message { // Deprecated: Use NestedTypeB.ProtoReflect.Descriptor instead. func (*NestedTypeB) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{387} + return file_product_proto_rawDescGZIP(), []int{407} } func (x *NestedTypeB) GetId() string { @@ -19034,7 +19954,7 @@ type NestedTypeC struct { func (x *NestedTypeC) Reset() { *x = NestedTypeC{} - mi := &file_product_proto_msgTypes[388] + mi := &file_product_proto_msgTypes[408] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -19046,7 +19966,7 @@ func (x *NestedTypeC) String() string { func (*NestedTypeC) ProtoMessage() {} func (x *NestedTypeC) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[388] + mi := &file_product_proto_msgTypes[408] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -19059,7 +19979,7 @@ func (x *NestedTypeC) ProtoReflect() protoreflect.Message { // Deprecated: Use NestedTypeC.ProtoReflect.Descriptor instead. func (*NestedTypeC) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{388} + return file_product_proto_rawDescGZIP(), []int{408} } func (x *NestedTypeC) GetId() string { @@ -19088,7 +20008,7 @@ type FilterType struct { func (x *FilterType) Reset() { *x = FilterType{} - mi := &file_product_proto_msgTypes[389] + mi := &file_product_proto_msgTypes[409] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -19100,7 +20020,7 @@ func (x *FilterType) String() string { func (*FilterType) ProtoMessage() {} func (x *FilterType) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[389] + mi := &file_product_proto_msgTypes[409] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -19113,7 +20033,7 @@ func (x *FilterType) ProtoReflect() protoreflect.Message { // Deprecated: Use FilterType.ProtoReflect.Descriptor instead. func (*FilterType) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{389} + return file_product_proto_rawDescGZIP(), []int{409} } func (x *FilterType) GetName() string { @@ -19154,7 +20074,7 @@ type Pagination struct { func (x *Pagination) Reset() { *x = Pagination{} - mi := &file_product_proto_msgTypes[390] + mi := &file_product_proto_msgTypes[410] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -19166,7 +20086,7 @@ func (x *Pagination) String() string { func (*Pagination) ProtoMessage() {} func (x *Pagination) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[390] + mi := &file_product_proto_msgTypes[410] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -19179,7 +20099,7 @@ func (x *Pagination) ProtoReflect() protoreflect.Message { // Deprecated: Use Pagination.ProtoReflect.Descriptor instead. func (*Pagination) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{390} + return file_product_proto_rawDescGZIP(), []int{410} } func (x *Pagination) GetPage() int32 { @@ -19207,7 +20127,7 @@ type OrderLineInput struct { func (x *OrderLineInput) Reset() { *x = OrderLineInput{} - mi := &file_product_proto_msgTypes[391] + mi := &file_product_proto_msgTypes[411] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -19219,7 +20139,7 @@ func (x *OrderLineInput) String() string { func (*OrderLineInput) ProtoMessage() {} func (x *OrderLineInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[391] + mi := &file_product_proto_msgTypes[411] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -19232,7 +20152,7 @@ func (x *OrderLineInput) ProtoReflect() protoreflect.Message { // Deprecated: Use OrderLineInput.ProtoReflect.Descriptor instead. func (*OrderLineInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{391} + return file_product_proto_rawDescGZIP(), []int{411} } func (x *OrderLineInput) GetProductId() string { @@ -19267,7 +20187,7 @@ type OrderLine struct { func (x *OrderLine) Reset() { *x = OrderLine{} - mi := &file_product_proto_msgTypes[392] + mi := &file_product_proto_msgTypes[412] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -19279,7 +20199,7 @@ func (x *OrderLine) String() string { func (*OrderLine) ProtoMessage() {} func (x *OrderLine) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[392] + mi := &file_product_proto_msgTypes[412] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -19292,7 +20212,7 @@ func (x *OrderLine) ProtoReflect() protoreflect.Message { // Deprecated: Use OrderLine.ProtoReflect.Descriptor instead. func (*OrderLine) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{392} + return file_product_proto_rawDescGZIP(), []int{412} } func (x *OrderLine) GetProductId() string { @@ -19328,7 +20248,7 @@ type Subcategory struct { func (x *Subcategory) Reset() { *x = Subcategory{} - mi := &file_product_proto_msgTypes[393] + mi := &file_product_proto_msgTypes[413] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -19340,7 +20260,7 @@ func (x *Subcategory) String() string { func (*Subcategory) ProtoMessage() {} func (x *Subcategory) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[393] + mi := &file_product_proto_msgTypes[413] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -19353,7 +20273,7 @@ func (x *Subcategory) ProtoReflect() protoreflect.Message { // Deprecated: Use Subcategory.ProtoReflect.Descriptor instead. func (*Subcategory) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{393} + return file_product_proto_rawDescGZIP(), []int{413} } func (x *Subcategory) GetId() string { @@ -19397,7 +20317,7 @@ type CategoryMetrics struct { func (x *CategoryMetrics) Reset() { *x = CategoryMetrics{} - mi := &file_product_proto_msgTypes[394] + mi := &file_product_proto_msgTypes[414] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -19409,7 +20329,7 @@ func (x *CategoryMetrics) String() string { func (*CategoryMetrics) ProtoMessage() {} func (x *CategoryMetrics) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[394] + mi := &file_product_proto_msgTypes[414] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -19422,7 +20342,7 @@ func (x *CategoryMetrics) ProtoReflect() protoreflect.Message { // Deprecated: Use CategoryMetrics.ProtoReflect.Descriptor instead. func (*CategoryMetrics) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{394} + return file_product_proto_rawDescGZIP(), []int{414} } func (x *CategoryMetrics) GetId() string { @@ -19474,7 +20394,7 @@ type Cat struct { func (x *Cat) Reset() { *x = Cat{} - mi := &file_product_proto_msgTypes[395] + mi := &file_product_proto_msgTypes[415] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -19486,7 +20406,7 @@ func (x *Cat) String() string { func (*Cat) ProtoMessage() {} func (x *Cat) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[395] + mi := &file_product_proto_msgTypes[415] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -19499,7 +20419,7 @@ func (x *Cat) ProtoReflect() protoreflect.Message { // Deprecated: Use Cat.ProtoReflect.Descriptor instead. func (*Cat) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{395} + return file_product_proto_rawDescGZIP(), []int{415} } func (x *Cat) GetId() string { @@ -19558,7 +20478,7 @@ type Dog struct { func (x *Dog) Reset() { *x = Dog{} - mi := &file_product_proto_msgTypes[396] + mi := &file_product_proto_msgTypes[416] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -19570,7 +20490,7 @@ func (x *Dog) String() string { func (*Dog) ProtoMessage() {} func (x *Dog) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[396] + mi := &file_product_proto_msgTypes[416] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -19583,7 +20503,7 @@ func (x *Dog) ProtoReflect() protoreflect.Message { // Deprecated: Use Dog.ProtoReflect.Descriptor instead. func (*Dog) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{396} + return file_product_proto_rawDescGZIP(), []int{416} } func (x *Dog) GetId() string { @@ -19640,7 +20560,7 @@ type Owner struct { func (x *Owner) Reset() { *x = Owner{} - mi := &file_product_proto_msgTypes[397] + mi := &file_product_proto_msgTypes[417] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -19652,7 +20572,7 @@ func (x *Owner) String() string { func (*Owner) ProtoMessage() {} func (x *Owner) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[397] + mi := &file_product_proto_msgTypes[417] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -19665,7 +20585,7 @@ func (x *Owner) ProtoReflect() protoreflect.Message { // Deprecated: Use Owner.ProtoReflect.Descriptor instead. func (*Owner) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{397} + return file_product_proto_rawDescGZIP(), []int{417} } func (x *Owner) GetId() string { @@ -19707,7 +20627,7 @@ type ContactInfo struct { func (x *ContactInfo) Reset() { *x = ContactInfo{} - mi := &file_product_proto_msgTypes[398] + mi := &file_product_proto_msgTypes[418] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -19719,7 +20639,7 @@ func (x *ContactInfo) String() string { func (*ContactInfo) ProtoMessage() {} func (x *ContactInfo) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[398] + mi := &file_product_proto_msgTypes[418] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -19732,7 +20652,7 @@ func (x *ContactInfo) ProtoReflect() protoreflect.Message { // Deprecated: Use ContactInfo.ProtoReflect.Descriptor instead. func (*ContactInfo) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{398} + return file_product_proto_rawDescGZIP(), []int{418} } func (x *ContactInfo) GetEmail() string { @@ -19768,7 +20688,7 @@ type Address struct { func (x *Address) Reset() { *x = Address{} - mi := &file_product_proto_msgTypes[399] + mi := &file_product_proto_msgTypes[419] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -19780,7 +20700,7 @@ func (x *Address) String() string { func (*Address) ProtoMessage() {} func (x *Address) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[399] + mi := &file_product_proto_msgTypes[419] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -19793,7 +20713,7 @@ func (x *Address) ProtoReflect() protoreflect.Message { // Deprecated: Use Address.ProtoReflect.Descriptor instead. func (*Address) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{399} + return file_product_proto_rawDescGZIP(), []int{419} } func (x *Address) GetStreet() string { @@ -19836,7 +20756,7 @@ type CatBreed struct { func (x *CatBreed) Reset() { *x = CatBreed{} - mi := &file_product_proto_msgTypes[400] + mi := &file_product_proto_msgTypes[420] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -19848,7 +20768,7 @@ func (x *CatBreed) String() string { func (*CatBreed) ProtoMessage() {} func (x *CatBreed) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[400] + mi := &file_product_proto_msgTypes[420] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -19861,7 +20781,7 @@ func (x *CatBreed) ProtoReflect() protoreflect.Message { // Deprecated: Use CatBreed.ProtoReflect.Descriptor instead. func (*CatBreed) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{400} + return file_product_proto_rawDescGZIP(), []int{420} } func (x *CatBreed) GetId() string { @@ -19904,7 +20824,7 @@ type DogBreed struct { func (x *DogBreed) Reset() { *x = DogBreed{} - mi := &file_product_proto_msgTypes[401] + mi := &file_product_proto_msgTypes[421] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -19916,7 +20836,7 @@ func (x *DogBreed) String() string { func (*DogBreed) ProtoMessage() {} func (x *DogBreed) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[401] + mi := &file_product_proto_msgTypes[421] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -19929,7 +20849,7 @@ func (x *DogBreed) ProtoReflect() protoreflect.Message { // Deprecated: Use DogBreed.ProtoReflect.Descriptor instead. func (*DogBreed) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{401} + return file_product_proto_rawDescGZIP(), []int{421} } func (x *DogBreed) GetId() string { @@ -19971,7 +20891,7 @@ type BreedCharacteristics struct { func (x *BreedCharacteristics) Reset() { *x = BreedCharacteristics{} - mi := &file_product_proto_msgTypes[402] + mi := &file_product_proto_msgTypes[422] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -19983,7 +20903,7 @@ func (x *BreedCharacteristics) String() string { func (*BreedCharacteristics) ProtoMessage() {} func (x *BreedCharacteristics) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[402] + mi := &file_product_proto_msgTypes[422] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -19996,7 +20916,7 @@ func (x *BreedCharacteristics) ProtoReflect() protoreflect.Message { // Deprecated: Use BreedCharacteristics.ProtoReflect.Descriptor instead. func (*BreedCharacteristics) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{402} + return file_product_proto_rawDescGZIP(), []int{422} } func (x *BreedCharacteristics) GetSize() string { @@ -20033,7 +20953,7 @@ type StorageItem struct { func (x *StorageItem) Reset() { *x = StorageItem{} - mi := &file_product_proto_msgTypes[403] + mi := &file_product_proto_msgTypes[423] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -20045,7 +20965,7 @@ func (x *StorageItem) String() string { func (*StorageItem) ProtoMessage() {} func (x *StorageItem) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[403] + mi := &file_product_proto_msgTypes[423] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -20058,7 +20978,7 @@ func (x *StorageItem) ProtoReflect() protoreflect.Message { // Deprecated: Use StorageItem.ProtoReflect.Descriptor instead. func (*StorageItem) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{403} + return file_product_proto_rawDescGZIP(), []int{423} } func (x *StorageItem) GetInstance() isStorageItem_Instance { @@ -20116,7 +21036,7 @@ type PalletItem struct { func (x *PalletItem) Reset() { *x = PalletItem{} - mi := &file_product_proto_msgTypes[404] + mi := &file_product_proto_msgTypes[424] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -20128,7 +21048,7 @@ func (x *PalletItem) String() string { func (*PalletItem) ProtoMessage() {} func (x *PalletItem) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[404] + mi := &file_product_proto_msgTypes[424] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -20141,7 +21061,7 @@ func (x *PalletItem) ProtoReflect() protoreflect.Message { // Deprecated: Use PalletItem.ProtoReflect.Descriptor instead. func (*PalletItem) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{404} + return file_product_proto_rawDescGZIP(), []int{424} } func (x *PalletItem) GetId() string { @@ -20200,7 +21120,7 @@ type ContainerItem struct { func (x *ContainerItem) Reset() { *x = ContainerItem{} - mi := &file_product_proto_msgTypes[405] + mi := &file_product_proto_msgTypes[425] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -20212,7 +21132,7 @@ func (x *ContainerItem) String() string { func (*ContainerItem) ProtoMessage() {} func (x *ContainerItem) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[405] + mi := &file_product_proto_msgTypes[425] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -20225,7 +21145,7 @@ func (x *ContainerItem) ProtoReflect() protoreflect.Message { // Deprecated: Use ContainerItem.ProtoReflect.Descriptor instead. func (*ContainerItem) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{405} + return file_product_proto_rawDescGZIP(), []int{425} } func (x *ContainerItem) GetId() string { @@ -20281,7 +21201,7 @@ type ItemHandler struct { func (x *ItemHandler) Reset() { *x = ItemHandler{} - mi := &file_product_proto_msgTypes[406] + mi := &file_product_proto_msgTypes[426] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -20293,7 +21213,7 @@ func (x *ItemHandler) String() string { func (*ItemHandler) ProtoMessage() {} func (x *ItemHandler) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[406] + mi := &file_product_proto_msgTypes[426] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -20306,7 +21226,7 @@ func (x *ItemHandler) ProtoReflect() protoreflect.Message { // Deprecated: Use ItemHandler.ProtoReflect.Descriptor instead. func (*ItemHandler) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{406} + return file_product_proto_rawDescGZIP(), []int{426} } func (x *ItemHandler) GetId() string { @@ -20341,7 +21261,7 @@ type PalletSpecs struct { func (x *PalletSpecs) Reset() { *x = PalletSpecs{} - mi := &file_product_proto_msgTypes[407] + mi := &file_product_proto_msgTypes[427] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -20353,7 +21273,7 @@ func (x *PalletSpecs) String() string { func (*PalletSpecs) ProtoMessage() {} func (x *PalletSpecs) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[407] + mi := &file_product_proto_msgTypes[427] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -20366,7 +21286,7 @@ func (x *PalletSpecs) ProtoReflect() protoreflect.Message { // Deprecated: Use PalletSpecs.ProtoReflect.Descriptor instead. func (*PalletSpecs) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{407} + return file_product_proto_rawDescGZIP(), []int{427} } func (x *PalletSpecs) GetName() string { @@ -20401,7 +21321,7 @@ type ContainerSpecs struct { func (x *ContainerSpecs) Reset() { *x = ContainerSpecs{} - mi := &file_product_proto_msgTypes[408] + mi := &file_product_proto_msgTypes[428] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -20413,7 +21333,7 @@ func (x *ContainerSpecs) String() string { func (*ContainerSpecs) ProtoMessage() {} func (x *ContainerSpecs) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[408] + mi := &file_product_proto_msgTypes[428] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -20426,7 +21346,7 @@ func (x *ContainerSpecs) ProtoReflect() protoreflect.Message { // Deprecated: Use ContainerSpecs.ProtoReflect.Descriptor instead. func (*ContainerSpecs) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{408} + return file_product_proto_rawDescGZIP(), []int{428} } func (x *ContainerSpecs) GetName() string { @@ -20461,7 +21381,7 @@ type Dimensions struct { func (x *Dimensions) Reset() { *x = Dimensions{} - mi := &file_product_proto_msgTypes[409] + mi := &file_product_proto_msgTypes[429] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -20473,7 +21393,7 @@ func (x *Dimensions) String() string { func (*Dimensions) ProtoMessage() {} func (x *Dimensions) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[409] + mi := &file_product_proto_msgTypes[429] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -20486,7 +21406,7 @@ func (x *Dimensions) ProtoReflect() protoreflect.Message { // Deprecated: Use Dimensions.ProtoReflect.Descriptor instead. func (*Dimensions) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{409} + return file_product_proto_rawDescGZIP(), []int{429} } func (x *Dimensions) GetLength() float64 { @@ -20523,7 +21443,7 @@ type StorageOperationResult struct { func (x *StorageOperationResult) Reset() { *x = StorageOperationResult{} - mi := &file_product_proto_msgTypes[410] + mi := &file_product_proto_msgTypes[430] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -20535,7 +21455,7 @@ func (x *StorageOperationResult) String() string { func (*StorageOperationResult) ProtoMessage() {} func (x *StorageOperationResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[410] + mi := &file_product_proto_msgTypes[430] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -20548,7 +21468,7 @@ func (x *StorageOperationResult) ProtoReflect() protoreflect.Message { // Deprecated: Use StorageOperationResult.ProtoReflect.Descriptor instead. func (*StorageOperationResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{410} + return file_product_proto_rawDescGZIP(), []int{430} } func (x *StorageOperationResult) GetValue() isStorageOperationResult_Value { @@ -20602,7 +21522,7 @@ type StorageSuccess struct { func (x *StorageSuccess) Reset() { *x = StorageSuccess{} - mi := &file_product_proto_msgTypes[411] + mi := &file_product_proto_msgTypes[431] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -20614,7 +21534,7 @@ func (x *StorageSuccess) String() string { func (*StorageSuccess) ProtoMessage() {} func (x *StorageSuccess) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[411] + mi := &file_product_proto_msgTypes[431] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -20627,7 +21547,7 @@ func (x *StorageSuccess) ProtoReflect() protoreflect.Message { // Deprecated: Use StorageSuccess.ProtoReflect.Descriptor instead. func (*StorageSuccess) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{411} + return file_product_proto_rawDescGZIP(), []int{431} } func (x *StorageSuccess) GetMessage() string { @@ -20654,7 +21574,7 @@ type StorageFailure struct { func (x *StorageFailure) Reset() { *x = StorageFailure{} - mi := &file_product_proto_msgTypes[412] + mi := &file_product_proto_msgTypes[432] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -20666,7 +21586,7 @@ func (x *StorageFailure) String() string { func (*StorageFailure) ProtoMessage() {} func (x *StorageFailure) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[412] + mi := &file_product_proto_msgTypes[432] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -20679,7 +21599,7 @@ func (x *StorageFailure) ProtoReflect() protoreflect.Message { // Deprecated: Use StorageFailure.ProtoReflect.Descriptor instead. func (*StorageFailure) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{412} + return file_product_proto_rawDescGZIP(), []int{432} } func (x *StorageFailure) GetMessage() string { @@ -20706,7 +21626,7 @@ type SecuritySetup struct { func (x *SecuritySetup) Reset() { *x = SecuritySetup{} - mi := &file_product_proto_msgTypes[413] + mi := &file_product_proto_msgTypes[433] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -20718,7 +21638,7 @@ func (x *SecuritySetup) String() string { func (*SecuritySetup) ProtoMessage() {} func (x *SecuritySetup) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[413] + mi := &file_product_proto_msgTypes[433] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -20731,7 +21651,7 @@ func (x *SecuritySetup) ProtoReflect() protoreflect.Message { // Deprecated: Use SecuritySetup.ProtoReflect.Descriptor instead. func (*SecuritySetup) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{413} + return file_product_proto_rawDescGZIP(), []int{433} } func (x *SecuritySetup) GetSecurityLevel() string { @@ -20758,7 +21678,7 @@ type ActionSuccess struct { func (x *ActionSuccess) Reset() { *x = ActionSuccess{} - mi := &file_product_proto_msgTypes[414] + mi := &file_product_proto_msgTypes[434] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -20770,7 +21690,7 @@ func (x *ActionSuccess) String() string { func (*ActionSuccess) ProtoMessage() {} func (x *ActionSuccess) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[414] + mi := &file_product_proto_msgTypes[434] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -20783,7 +21703,7 @@ func (x *ActionSuccess) ProtoReflect() protoreflect.Message { // Deprecated: Use ActionSuccess.ProtoReflect.Descriptor instead. func (*ActionSuccess) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{414} + return file_product_proto_rawDescGZIP(), []int{434} } func (x *ActionSuccess) GetMessage() string { @@ -20810,7 +21730,7 @@ type ActionError struct { func (x *ActionError) Reset() { *x = ActionError{} - mi := &file_product_proto_msgTypes[415] + mi := &file_product_proto_msgTypes[435] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -20822,7 +21742,7 @@ func (x *ActionError) String() string { func (*ActionError) ProtoMessage() {} func (x *ActionError) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[415] + mi := &file_product_proto_msgTypes[435] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -20835,7 +21755,7 @@ func (x *ActionError) ProtoReflect() protoreflect.Message { // Deprecated: Use ActionError.ProtoReflect.Descriptor instead. func (*ActionError) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{415} + return file_product_proto_rawDescGZIP(), []int{435} } func (x *ActionError) GetMessage() string { @@ -20864,7 +21784,7 @@ type TestDetails struct { func (x *TestDetails) Reset() { *x = TestDetails{} - mi := &file_product_proto_msgTypes[416] + mi := &file_product_proto_msgTypes[436] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -20876,7 +21796,7 @@ func (x *TestDetails) String() string { func (*TestDetails) ProtoMessage() {} func (x *TestDetails) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[416] + mi := &file_product_proto_msgTypes[436] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -20889,7 +21809,7 @@ func (x *TestDetails) ProtoReflect() protoreflect.Message { // Deprecated: Use TestDetails.ProtoReflect.Descriptor instead. func (*TestDetails) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{416} + return file_product_proto_rawDescGZIP(), []int{436} } func (x *TestDetails) GetId() string { @@ -20930,7 +21850,7 @@ type CategoryInput struct { func (x *CategoryInput) Reset() { *x = CategoryInput{} - mi := &file_product_proto_msgTypes[417] + mi := &file_product_proto_msgTypes[437] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -20942,7 +21862,7 @@ func (x *CategoryInput) String() string { func (*CategoryInput) ProtoMessage() {} func (x *CategoryInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[417] + mi := &file_product_proto_msgTypes[437] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -20955,7 +21875,7 @@ func (x *CategoryInput) ProtoReflect() protoreflect.Message { // Deprecated: Use CategoryInput.ProtoReflect.Descriptor instead. func (*CategoryInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{417} + return file_product_proto_rawDescGZIP(), []int{437} } func (x *CategoryInput) GetName() string { @@ -20984,7 +21904,7 @@ type ProductCountFilter struct { func (x *ProductCountFilter) Reset() { *x = ProductCountFilter{} - mi := &file_product_proto_msgTypes[418] + mi := &file_product_proto_msgTypes[438] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -20996,7 +21916,7 @@ func (x *ProductCountFilter) String() string { func (*ProductCountFilter) ProtoMessage() {} func (x *ProductCountFilter) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[418] + mi := &file_product_proto_msgTypes[438] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -21009,7 +21929,7 @@ func (x *ProductCountFilter) ProtoReflect() protoreflect.Message { // Deprecated: Use ProductCountFilter.ProtoReflect.Descriptor instead. func (*ProductCountFilter) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{418} + return file_product_proto_rawDescGZIP(), []int{438} } func (x *ProductCountFilter) GetMinPrice() *wrapperspb.DoubleValue { @@ -21053,7 +21973,7 @@ type SubcategoryItemFilter struct { func (x *SubcategoryItemFilter) Reset() { *x = SubcategoryItemFilter{} - mi := &file_product_proto_msgTypes[419] + mi := &file_product_proto_msgTypes[439] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -21065,7 +21985,7 @@ func (x *SubcategoryItemFilter) String() string { func (*SubcategoryItemFilter) ProtoMessage() {} func (x *SubcategoryItemFilter) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[419] + mi := &file_product_proto_msgTypes[439] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -21078,7 +21998,7 @@ func (x *SubcategoryItemFilter) ProtoReflect() protoreflect.Message { // Deprecated: Use SubcategoryItemFilter.ProtoReflect.Descriptor instead. func (*SubcategoryItemFilter) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{419} + return file_product_proto_rawDescGZIP(), []int{439} } func (x *SubcategoryItemFilter) GetMinPrice() *wrapperspb.DoubleValue { @@ -21127,7 +22047,7 @@ type ShippingEstimateInput struct { func (x *ShippingEstimateInput) Reset() { *x = ShippingEstimateInput{} - mi := &file_product_proto_msgTypes[420] + mi := &file_product_proto_msgTypes[440] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -21139,7 +22059,7 @@ func (x *ShippingEstimateInput) String() string { func (*ShippingEstimateInput) ProtoMessage() {} func (x *ShippingEstimateInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[420] + mi := &file_product_proto_msgTypes[440] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -21152,7 +22072,7 @@ func (x *ShippingEstimateInput) ProtoReflect() protoreflect.Message { // Deprecated: Use ShippingEstimateInput.ProtoReflect.Descriptor instead. func (*ShippingEstimateInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{420} + return file_product_proto_rawDescGZIP(), []int{440} } func (x *ShippingEstimateInput) GetDestination() ShippingDestination { @@ -21185,7 +22105,7 @@ type ListOfAuthorFilter_List struct { func (x *ListOfAuthorFilter_List) Reset() { *x = ListOfAuthorFilter_List{} - mi := &file_product_proto_msgTypes[421] + mi := &file_product_proto_msgTypes[441] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -21197,7 +22117,7 @@ func (x *ListOfAuthorFilter_List) String() string { func (*ListOfAuthorFilter_List) ProtoMessage() {} func (x *ListOfAuthorFilter_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[421] + mi := &file_product_proto_msgTypes[441] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -21229,7 +22149,7 @@ type ListOfAuthorInput_List struct { func (x *ListOfAuthorInput_List) Reset() { *x = ListOfAuthorInput_List{} - mi := &file_product_proto_msgTypes[422] + mi := &file_product_proto_msgTypes[442] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -21241,7 +22161,7 @@ func (x *ListOfAuthorInput_List) String() string { func (*ListOfAuthorInput_List) ProtoMessage() {} func (x *ListOfAuthorInput_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[422] + mi := &file_product_proto_msgTypes[442] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -21273,7 +22193,7 @@ type ListOfBlogPost_List struct { func (x *ListOfBlogPost_List) Reset() { *x = ListOfBlogPost_List{} - mi := &file_product_proto_msgTypes[423] + mi := &file_product_proto_msgTypes[443] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -21285,7 +22205,7 @@ func (x *ListOfBlogPost_List) String() string { func (*ListOfBlogPost_List) ProtoMessage() {} func (x *ListOfBlogPost_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[423] + mi := &file_product_proto_msgTypes[443] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -21317,7 +22237,7 @@ type ListOfBlogPostFilter_List struct { func (x *ListOfBlogPostFilter_List) Reset() { *x = ListOfBlogPostFilter_List{} - mi := &file_product_proto_msgTypes[424] + mi := &file_product_proto_msgTypes[444] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -21329,7 +22249,7 @@ func (x *ListOfBlogPostFilter_List) String() string { func (*ListOfBlogPostFilter_List) ProtoMessage() {} func (x *ListOfBlogPostFilter_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[424] + mi := &file_product_proto_msgTypes[444] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -21361,7 +22281,7 @@ type ListOfBlogPostInput_List struct { func (x *ListOfBlogPostInput_List) Reset() { *x = ListOfBlogPostInput_List{} - mi := &file_product_proto_msgTypes[425] + mi := &file_product_proto_msgTypes[445] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -21373,7 +22293,7 @@ func (x *ListOfBlogPostInput_List) String() string { func (*ListOfBlogPostInput_List) ProtoMessage() {} func (x *ListOfBlogPostInput_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[425] + mi := &file_product_proto_msgTypes[445] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -21405,7 +22325,7 @@ type ListOfBoolean_List struct { func (x *ListOfBoolean_List) Reset() { *x = ListOfBoolean_List{} - mi := &file_product_proto_msgTypes[426] + mi := &file_product_proto_msgTypes[446] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -21417,7 +22337,7 @@ func (x *ListOfBoolean_List) String() string { func (*ListOfBoolean_List) ProtoMessage() {} func (x *ListOfBoolean_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[426] + mi := &file_product_proto_msgTypes[446] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -21449,7 +22369,7 @@ type ListOfCategory_List struct { func (x *ListOfCategory_List) Reset() { *x = ListOfCategory_List{} - mi := &file_product_proto_msgTypes[427] + mi := &file_product_proto_msgTypes[447] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -21461,7 +22381,7 @@ func (x *ListOfCategory_List) String() string { func (*ListOfCategory_List) ProtoMessage() {} func (x *ListOfCategory_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[427] + mi := &file_product_proto_msgTypes[447] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -21493,7 +22413,7 @@ type ListOfCategoryInput_List struct { func (x *ListOfCategoryInput_List) Reset() { *x = ListOfCategoryInput_List{} - mi := &file_product_proto_msgTypes[428] + mi := &file_product_proto_msgTypes[448] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -21505,7 +22425,7 @@ func (x *ListOfCategoryInput_List) String() string { func (*ListOfCategoryInput_List) ProtoMessage() {} func (x *ListOfCategoryInput_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[428] + mi := &file_product_proto_msgTypes[448] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -21537,7 +22457,7 @@ type ListOfConditionsInput_List struct { func (x *ListOfConditionsInput_List) Reset() { *x = ListOfConditionsInput_List{} - mi := &file_product_proto_msgTypes[429] + mi := &file_product_proto_msgTypes[449] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -21549,7 +22469,7 @@ func (x *ListOfConditionsInput_List) String() string { func (*ListOfConditionsInput_List) ProtoMessage() {} func (x *ListOfConditionsInput_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[429] + mi := &file_product_proto_msgTypes[449] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -21581,7 +22501,7 @@ type ListOfFloat_List struct { func (x *ListOfFloat_List) Reset() { *x = ListOfFloat_List{} - mi := &file_product_proto_msgTypes[430] + mi := &file_product_proto_msgTypes[450] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -21593,7 +22513,7 @@ func (x *ListOfFloat_List) String() string { func (*ListOfFloat_List) ProtoMessage() {} func (x *ListOfFloat_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[430] + mi := &file_product_proto_msgTypes[450] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -21625,7 +22545,7 @@ type ListOfListOfCategory_List struct { func (x *ListOfListOfCategory_List) Reset() { *x = ListOfListOfCategory_List{} - mi := &file_product_proto_msgTypes[431] + mi := &file_product_proto_msgTypes[451] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -21637,7 +22557,7 @@ func (x *ListOfListOfCategory_List) String() string { func (*ListOfListOfCategory_List) ProtoMessage() {} func (x *ListOfListOfCategory_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[431] + mi := &file_product_proto_msgTypes[451] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -21669,7 +22589,7 @@ type ListOfListOfCategoryInput_List struct { func (x *ListOfListOfCategoryInput_List) Reset() { *x = ListOfListOfCategoryInput_List{} - mi := &file_product_proto_msgTypes[432] + mi := &file_product_proto_msgTypes[452] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -21681,7 +22601,7 @@ func (x *ListOfListOfCategoryInput_List) String() string { func (*ListOfListOfCategoryInput_List) ProtoMessage() {} func (x *ListOfListOfCategoryInput_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[432] + mi := &file_product_proto_msgTypes[452] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -21713,7 +22633,7 @@ type ListOfListOfString_List struct { func (x *ListOfListOfString_List) Reset() { *x = ListOfListOfString_List{} - mi := &file_product_proto_msgTypes[433] + mi := &file_product_proto_msgTypes[453] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -21725,7 +22645,7 @@ func (x *ListOfListOfString_List) String() string { func (*ListOfListOfString_List) ProtoMessage() {} func (x *ListOfListOfString_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[433] + mi := &file_product_proto_msgTypes[453] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -21757,7 +22677,7 @@ type ListOfListOfUser_List struct { func (x *ListOfListOfUser_List) Reset() { *x = ListOfListOfUser_List{} - mi := &file_product_proto_msgTypes[434] + mi := &file_product_proto_msgTypes[454] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -21769,7 +22689,7 @@ func (x *ListOfListOfUser_List) String() string { func (*ListOfListOfUser_List) ProtoMessage() {} func (x *ListOfListOfUser_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[434] + mi := &file_product_proto_msgTypes[454] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -21801,7 +22721,7 @@ type ListOfListOfUserInput_List struct { func (x *ListOfListOfUserInput_List) Reset() { *x = ListOfListOfUserInput_List{} - mi := &file_product_proto_msgTypes[435] + mi := &file_product_proto_msgTypes[455] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -21813,7 +22733,7 @@ func (x *ListOfListOfUserInput_List) String() string { func (*ListOfListOfUserInput_List) ProtoMessage() {} func (x *ListOfListOfUserInput_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[435] + mi := &file_product_proto_msgTypes[455] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -21845,7 +22765,7 @@ type ListOfOrderLine_List struct { func (x *ListOfOrderLine_List) Reset() { *x = ListOfOrderLine_List{} - mi := &file_product_proto_msgTypes[436] + mi := &file_product_proto_msgTypes[456] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -21857,7 +22777,7 @@ func (x *ListOfOrderLine_List) String() string { func (*ListOfOrderLine_List) ProtoMessage() {} func (x *ListOfOrderLine_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[436] + mi := &file_product_proto_msgTypes[456] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -21889,7 +22809,7 @@ type ListOfProduct_List struct { func (x *ListOfProduct_List) Reset() { *x = ListOfProduct_List{} - mi := &file_product_proto_msgTypes[437] + mi := &file_product_proto_msgTypes[457] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -21901,7 +22821,7 @@ func (x *ListOfProduct_List) String() string { func (*ListOfProduct_List) ProtoMessage() {} func (x *ListOfProduct_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[437] + mi := &file_product_proto_msgTypes[457] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -21933,7 +22853,7 @@ type ListOfStorage_List struct { func (x *ListOfStorage_List) Reset() { *x = ListOfStorage_List{} - mi := &file_product_proto_msgTypes[438] + mi := &file_product_proto_msgTypes[458] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -21945,7 +22865,7 @@ func (x *ListOfStorage_List) String() string { func (*ListOfStorage_List) ProtoMessage() {} func (x *ListOfStorage_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[438] + mi := &file_product_proto_msgTypes[458] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -21977,7 +22897,7 @@ type ListOfString_List struct { func (x *ListOfString_List) Reset() { *x = ListOfString_List{} - mi := &file_product_proto_msgTypes[439] + mi := &file_product_proto_msgTypes[459] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -21989,7 +22909,7 @@ func (x *ListOfString_List) String() string { func (*ListOfString_List) ProtoMessage() {} func (x *ListOfString_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[439] + mi := &file_product_proto_msgTypes[459] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -22021,7 +22941,7 @@ type ListOfSubcategory_List struct { func (x *ListOfSubcategory_List) Reset() { *x = ListOfSubcategory_List{} - mi := &file_product_proto_msgTypes[440] + mi := &file_product_proto_msgTypes[460] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -22033,7 +22953,7 @@ func (x *ListOfSubcategory_List) String() string { func (*ListOfSubcategory_List) ProtoMessage() {} func (x *ListOfSubcategory_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[440] + mi := &file_product_proto_msgTypes[460] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -22065,7 +22985,7 @@ type ListOfUser_List struct { func (x *ListOfUser_List) Reset() { *x = ListOfUser_List{} - mi := &file_product_proto_msgTypes[441] + mi := &file_product_proto_msgTypes[461] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -22077,7 +22997,7 @@ func (x *ListOfUser_List) String() string { func (*ListOfUser_List) ProtoMessage() {} func (x *ListOfUser_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[441] + mi := &file_product_proto_msgTypes[461] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -22109,7 +23029,7 @@ type ListOfUserInput_List struct { func (x *ListOfUserInput_List) Reset() { *x = ListOfUserInput_List{} - mi := &file_product_proto_msgTypes[442] + mi := &file_product_proto_msgTypes[462] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -22121,7 +23041,7 @@ func (x *ListOfUserInput_List) String() string { func (*ListOfUserInput_List) ProtoMessage() {} func (x *ListOfUserInput_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[442] + mi := &file_product_proto_msgTypes[462] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -22153,7 +23073,7 @@ type RequireStorageStockHealthScoreByIdFields_RestockData struct { func (x *RequireStorageStockHealthScoreByIdFields_RestockData) Reset() { *x = RequireStorageStockHealthScoreByIdFields_RestockData{} - mi := &file_product_proto_msgTypes[443] + mi := &file_product_proto_msgTypes[463] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -22165,7 +23085,7 @@ func (x *RequireStorageStockHealthScoreByIdFields_RestockData) String() string { func (*RequireStorageStockHealthScoreByIdFields_RestockData) ProtoMessage() {} func (x *RequireStorageStockHealthScoreByIdFields_RestockData) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[443] + mi := &file_product_proto_msgTypes[463] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -22198,7 +23118,7 @@ type RequireStorageMetadataScoreByIdFields_StorageMetadata struct { func (x *RequireStorageMetadataScoreByIdFields_StorageMetadata) Reset() { *x = RequireStorageMetadataScoreByIdFields_StorageMetadata{} - mi := &file_product_proto_msgTypes[444] + mi := &file_product_proto_msgTypes[464] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -22210,7 +23130,7 @@ func (x *RequireStorageMetadataScoreByIdFields_StorageMetadata) String() string func (*RequireStorageMetadataScoreByIdFields_StorageMetadata) ProtoMessage() {} func (x *RequireStorageMetadataScoreByIdFields_StorageMetadata) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[444] + mi := &file_product_proto_msgTypes[464] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -22251,7 +23171,7 @@ type RequireStorageProcessedMetadataByIdFields_StorageMetadata struct { func (x *RequireStorageProcessedMetadataByIdFields_StorageMetadata) Reset() { *x = RequireStorageProcessedMetadataByIdFields_StorageMetadata{} - mi := &file_product_proto_msgTypes[445] + mi := &file_product_proto_msgTypes[465] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -22263,7 +23183,7 @@ func (x *RequireStorageProcessedMetadataByIdFields_StorageMetadata) String() str func (*RequireStorageProcessedMetadataByIdFields_StorageMetadata) ProtoMessage() {} func (x *RequireStorageProcessedMetadataByIdFields_StorageMetadata) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[445] + mi := &file_product_proto_msgTypes[465] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -22310,7 +23230,7 @@ type RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata struct { func (x *RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata) Reset() { *x = RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata{} - mi := &file_product_proto_msgTypes[446] + mi := &file_product_proto_msgTypes[466] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -22322,7 +23242,7 @@ func (x *RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata) Stri func (*RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata) ProtoMessage() {} func (x *RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[446] + mi := &file_product_proto_msgTypes[466] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -22362,7 +23282,7 @@ type RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata struct { func (x *RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata) Reset() { *x = RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata{} - mi := &file_product_proto_msgTypes[447] + mi := &file_product_proto_msgTypes[467] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -22374,7 +23294,7 @@ func (x *RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata) Strin func (*RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata) ProtoMessage() {} func (x *RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[447] + mi := &file_product_proto_msgTypes[467] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -22414,7 +23334,7 @@ type RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo struct { func (x *RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo) Reset() { *x = RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo{} - mi := &file_product_proto_msgTypes[448] + mi := &file_product_proto_msgTypes[468] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -22426,7 +23346,7 @@ func (x *RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo) String func (*RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo) ProtoMessage() {} func (x *RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[448] + mi := &file_product_proto_msgTypes[468] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -22466,7 +23386,7 @@ type RequireStorageItemInfoByIdFields_PalletItem struct { func (x *RequireStorageItemInfoByIdFields_PalletItem) Reset() { *x = RequireStorageItemInfoByIdFields_PalletItem{} - mi := &file_product_proto_msgTypes[449] + mi := &file_product_proto_msgTypes[469] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -22478,7 +23398,7 @@ func (x *RequireStorageItemInfoByIdFields_PalletItem) String() string { func (*RequireStorageItemInfoByIdFields_PalletItem) ProtoMessage() {} func (x *RequireStorageItemInfoByIdFields_PalletItem) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[449] + mi := &file_product_proto_msgTypes[469] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -22518,7 +23438,7 @@ type RequireStorageItemInfoByIdFields_ContainerItem struct { func (x *RequireStorageItemInfoByIdFields_ContainerItem) Reset() { *x = RequireStorageItemInfoByIdFields_ContainerItem{} - mi := &file_product_proto_msgTypes[450] + mi := &file_product_proto_msgTypes[470] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -22530,7 +23450,7 @@ func (x *RequireStorageItemInfoByIdFields_ContainerItem) String() string { func (*RequireStorageItemInfoByIdFields_ContainerItem) ProtoMessage() {} func (x *RequireStorageItemInfoByIdFields_ContainerItem) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[450] + mi := &file_product_proto_msgTypes[470] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -22573,7 +23493,7 @@ type RequireStorageItemInfoByIdFields_StorageItem struct { func (x *RequireStorageItemInfoByIdFields_StorageItem) Reset() { *x = RequireStorageItemInfoByIdFields_StorageItem{} - mi := &file_product_proto_msgTypes[451] + mi := &file_product_proto_msgTypes[471] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -22585,7 +23505,7 @@ func (x *RequireStorageItemInfoByIdFields_StorageItem) String() string { func (*RequireStorageItemInfoByIdFields_StorageItem) ProtoMessage() {} func (x *RequireStorageItemInfoByIdFields_StorageItem) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[451] + mi := &file_product_proto_msgTypes[471] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -22654,7 +23574,7 @@ type RequireStorageOperationReportByIdFields_StorageSuccess struct { func (x *RequireStorageOperationReportByIdFields_StorageSuccess) Reset() { *x = RequireStorageOperationReportByIdFields_StorageSuccess{} - mi := &file_product_proto_msgTypes[452] + mi := &file_product_proto_msgTypes[472] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -22666,7 +23586,7 @@ func (x *RequireStorageOperationReportByIdFields_StorageSuccess) String() string func (*RequireStorageOperationReportByIdFields_StorageSuccess) ProtoMessage() {} func (x *RequireStorageOperationReportByIdFields_StorageSuccess) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[452] + mi := &file_product_proto_msgTypes[472] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -22706,7 +23626,7 @@ type RequireStorageOperationReportByIdFields_StorageFailure struct { func (x *RequireStorageOperationReportByIdFields_StorageFailure) Reset() { *x = RequireStorageOperationReportByIdFields_StorageFailure{} - mi := &file_product_proto_msgTypes[453] + mi := &file_product_proto_msgTypes[473] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -22718,7 +23638,7 @@ func (x *RequireStorageOperationReportByIdFields_StorageFailure) String() string func (*RequireStorageOperationReportByIdFields_StorageFailure) ProtoMessage() {} func (x *RequireStorageOperationReportByIdFields_StorageFailure) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[453] + mi := &file_product_proto_msgTypes[473] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -22761,7 +23681,7 @@ type RequireStorageOperationReportByIdFields_StorageOperationResult struct { func (x *RequireStorageOperationReportByIdFields_StorageOperationResult) Reset() { *x = RequireStorageOperationReportByIdFields_StorageOperationResult{} - mi := &file_product_proto_msgTypes[454] + mi := &file_product_proto_msgTypes[474] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -22773,7 +23693,7 @@ func (x *RequireStorageOperationReportByIdFields_StorageOperationResult) String( func (*RequireStorageOperationReportByIdFields_StorageOperationResult) ProtoMessage() {} func (x *RequireStorageOperationReportByIdFields_StorageOperationResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[454] + mi := &file_product_proto_msgTypes[474] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -22842,7 +23762,7 @@ type RequireStorageSecuritySummaryByIdFields_SecuritySetup struct { func (x *RequireStorageSecuritySummaryByIdFields_SecuritySetup) Reset() { *x = RequireStorageSecuritySummaryByIdFields_SecuritySetup{} - mi := &file_product_proto_msgTypes[455] + mi := &file_product_proto_msgTypes[475] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -22854,7 +23774,7 @@ func (x *RequireStorageSecuritySummaryByIdFields_SecuritySetup) String() string func (*RequireStorageSecuritySummaryByIdFields_SecuritySetup) ProtoMessage() {} func (x *RequireStorageSecuritySummaryByIdFields_SecuritySetup) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[455] + mi := &file_product_proto_msgTypes[475] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -22894,7 +23814,7 @@ type RequireStorageSecuritySummaryByIdFields_SecuritySetup_PalletItem struct { func (x *RequireStorageSecuritySummaryByIdFields_SecuritySetup_PalletItem) Reset() { *x = RequireStorageSecuritySummaryByIdFields_SecuritySetup_PalletItem{} - mi := &file_product_proto_msgTypes[456] + mi := &file_product_proto_msgTypes[476] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -22906,7 +23826,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[456] + mi := &file_product_proto_msgTypes[476] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -22946,7 +23866,7 @@ type RequireStorageSecuritySummaryByIdFields_SecuritySetup_ContainerItem struct func (x *RequireStorageSecuritySummaryByIdFields_SecuritySetup_ContainerItem) Reset() { *x = RequireStorageSecuritySummaryByIdFields_SecuritySetup_ContainerItem{} - mi := &file_product_proto_msgTypes[457] + mi := &file_product_proto_msgTypes[477] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -22958,7 +23878,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[457] + mi := &file_product_proto_msgTypes[477] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -23001,7 +23921,7 @@ type RequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem struct { func (x *RequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem) Reset() { *x = RequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem{} - mi := &file_product_proto_msgTypes[458] + mi := &file_product_proto_msgTypes[478] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -23013,7 +23933,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[458] + mi := &file_product_proto_msgTypes[478] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -23081,7 +24001,7 @@ type RequireStorageItemHandlerInfoByIdFields_PalletItem struct { func (x *RequireStorageItemHandlerInfoByIdFields_PalletItem) Reset() { *x = RequireStorageItemHandlerInfoByIdFields_PalletItem{} - mi := &file_product_proto_msgTypes[459] + mi := &file_product_proto_msgTypes[479] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -23093,7 +24013,7 @@ func (x *RequireStorageItemHandlerInfoByIdFields_PalletItem) String() string { func (*RequireStorageItemHandlerInfoByIdFields_PalletItem) ProtoMessage() {} func (x *RequireStorageItemHandlerInfoByIdFields_PalletItem) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[459] + mi := &file_product_proto_msgTypes[479] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -23125,7 +24045,7 @@ type RequireStorageItemHandlerInfoByIdFields_ContainerItem struct { func (x *RequireStorageItemHandlerInfoByIdFields_ContainerItem) Reset() { *x = RequireStorageItemHandlerInfoByIdFields_ContainerItem{} - mi := &file_product_proto_msgTypes[460] + mi := &file_product_proto_msgTypes[480] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -23137,7 +24057,7 @@ func (x *RequireStorageItemHandlerInfoByIdFields_ContainerItem) String() string func (*RequireStorageItemHandlerInfoByIdFields_ContainerItem) ProtoMessage() {} func (x *RequireStorageItemHandlerInfoByIdFields_ContainerItem) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[460] + mi := &file_product_proto_msgTypes[480] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -23173,7 +24093,7 @@ type RequireStorageItemHandlerInfoByIdFields_StorageItem struct { func (x *RequireStorageItemHandlerInfoByIdFields_StorageItem) Reset() { *x = RequireStorageItemHandlerInfoByIdFields_StorageItem{} - mi := &file_product_proto_msgTypes[461] + mi := &file_product_proto_msgTypes[481] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -23185,7 +24105,7 @@ func (x *RequireStorageItemHandlerInfoByIdFields_StorageItem) String() string { func (*RequireStorageItemHandlerInfoByIdFields_StorageItem) ProtoMessage() {} func (x *RequireStorageItemHandlerInfoByIdFields_StorageItem) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[461] + mi := &file_product_proto_msgTypes[481] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -23253,7 +24173,7 @@ type RequireStorageItemHandlerInfoByIdFields_PalletItem_ItemHandler struct { func (x *RequireStorageItemHandlerInfoByIdFields_PalletItem_ItemHandler) Reset() { *x = RequireStorageItemHandlerInfoByIdFields_PalletItem_ItemHandler{} - mi := &file_product_proto_msgTypes[462] + mi := &file_product_proto_msgTypes[482] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -23265,7 +24185,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[462] + mi := &file_product_proto_msgTypes[482] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -23297,7 +24217,7 @@ type RequireStorageItemHandlerInfoByIdFields_ContainerItem_ItemHandler struct { func (x *RequireStorageItemHandlerInfoByIdFields_ContainerItem_ItemHandler) Reset() { *x = RequireStorageItemHandlerInfoByIdFields_ContainerItem_ItemHandler{} - mi := &file_product_proto_msgTypes[463] + mi := &file_product_proto_msgTypes[483] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -23309,7 +24229,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[463] + mi := &file_product_proto_msgTypes[483] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -23341,7 +24261,7 @@ type RequireStorageItemSpecsInfoByIdFields_PalletItem struct { func (x *RequireStorageItemSpecsInfoByIdFields_PalletItem) Reset() { *x = RequireStorageItemSpecsInfoByIdFields_PalletItem{} - mi := &file_product_proto_msgTypes[464] + mi := &file_product_proto_msgTypes[484] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -23353,7 +24273,7 @@ func (x *RequireStorageItemSpecsInfoByIdFields_PalletItem) String() string { func (*RequireStorageItemSpecsInfoByIdFields_PalletItem) ProtoMessage() {} func (x *RequireStorageItemSpecsInfoByIdFields_PalletItem) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[464] + mi := &file_product_proto_msgTypes[484] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -23385,7 +24305,7 @@ type RequireStorageItemSpecsInfoByIdFields_ContainerItem struct { func (x *RequireStorageItemSpecsInfoByIdFields_ContainerItem) Reset() { *x = RequireStorageItemSpecsInfoByIdFields_ContainerItem{} - mi := &file_product_proto_msgTypes[465] + mi := &file_product_proto_msgTypes[485] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -23397,7 +24317,7 @@ func (x *RequireStorageItemSpecsInfoByIdFields_ContainerItem) String() string { func (*RequireStorageItemSpecsInfoByIdFields_ContainerItem) ProtoMessage() {} func (x *RequireStorageItemSpecsInfoByIdFields_ContainerItem) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[465] + mi := &file_product_proto_msgTypes[485] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -23433,7 +24353,7 @@ type RequireStorageItemSpecsInfoByIdFields_StorageItem struct { func (x *RequireStorageItemSpecsInfoByIdFields_StorageItem) Reset() { *x = RequireStorageItemSpecsInfoByIdFields_StorageItem{} - mi := &file_product_proto_msgTypes[466] + mi := &file_product_proto_msgTypes[486] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -23445,7 +24365,7 @@ func (x *RequireStorageItemSpecsInfoByIdFields_StorageItem) String() string { func (*RequireStorageItemSpecsInfoByIdFields_StorageItem) ProtoMessage() {} func (x *RequireStorageItemSpecsInfoByIdFields_StorageItem) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[466] + mi := &file_product_proto_msgTypes[486] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -23514,7 +24434,7 @@ type RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs struct { func (x *RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs) Reset() { *x = RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs{} - mi := &file_product_proto_msgTypes[467] + mi := &file_product_proto_msgTypes[487] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -23526,7 +24446,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[467] + mi := &file_product_proto_msgTypes[487] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -23566,7 +24486,7 @@ type RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs_Dimensions str func (x *RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs_Dimensions) Reset() { *x = RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs_Dimensions{} - mi := &file_product_proto_msgTypes[468] + mi := &file_product_proto_msgTypes[488] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -23578,7 +24498,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[468] + mi := &file_product_proto_msgTypes[488] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -23618,7 +24538,7 @@ type RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs struct { func (x *RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs) Reset() { *x = RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs{} - mi := &file_product_proto_msgTypes[469] + mi := &file_product_proto_msgTypes[489] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -23630,7 +24550,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[469] + mi := &file_product_proto_msgTypes[489] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -23670,7 +24590,7 @@ type RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs_Dimensio func (x *RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs_Dimensions) Reset() { *x = RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs_Dimensions{} - mi := &file_product_proto_msgTypes[470] + mi := &file_product_proto_msgTypes[490] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -23683,7 +24603,7 @@ func (*RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs_Dimens } func (x *RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs_Dimensions) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[470] + mi := &file_product_proto_msgTypes[490] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -23722,7 +24642,7 @@ type RequireStorageDeepItemInfoByIdFields_PalletItem struct { func (x *RequireStorageDeepItemInfoByIdFields_PalletItem) Reset() { *x = RequireStorageDeepItemInfoByIdFields_PalletItem{} - mi := &file_product_proto_msgTypes[471] + mi := &file_product_proto_msgTypes[491] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -23734,7 +24654,7 @@ func (x *RequireStorageDeepItemInfoByIdFields_PalletItem) String() string { func (*RequireStorageDeepItemInfoByIdFields_PalletItem) ProtoMessage() {} func (x *RequireStorageDeepItemInfoByIdFields_PalletItem) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[471] + mi := &file_product_proto_msgTypes[491] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -23766,7 +24686,7 @@ type RequireStorageDeepItemInfoByIdFields_ContainerItem struct { func (x *RequireStorageDeepItemInfoByIdFields_ContainerItem) Reset() { *x = RequireStorageDeepItemInfoByIdFields_ContainerItem{} - mi := &file_product_proto_msgTypes[472] + mi := &file_product_proto_msgTypes[492] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -23778,7 +24698,7 @@ func (x *RequireStorageDeepItemInfoByIdFields_ContainerItem) String() string { func (*RequireStorageDeepItemInfoByIdFields_ContainerItem) ProtoMessage() {} func (x *RequireStorageDeepItemInfoByIdFields_ContainerItem) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[472] + mi := &file_product_proto_msgTypes[492] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -23814,7 +24734,7 @@ type RequireStorageDeepItemInfoByIdFields_StorageItem struct { func (x *RequireStorageDeepItemInfoByIdFields_StorageItem) Reset() { *x = RequireStorageDeepItemInfoByIdFields_StorageItem{} - mi := &file_product_proto_msgTypes[473] + mi := &file_product_proto_msgTypes[493] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -23826,7 +24746,7 @@ func (x *RequireStorageDeepItemInfoByIdFields_StorageItem) String() string { func (*RequireStorageDeepItemInfoByIdFields_StorageItem) ProtoMessage() {} func (x *RequireStorageDeepItemInfoByIdFields_StorageItem) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[473] + mi := &file_product_proto_msgTypes[493] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -23894,7 +24814,7 @@ type RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler struct { func (x *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler) Reset() { *x = RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler{} - mi := &file_product_proto_msgTypes[474] + mi := &file_product_proto_msgTypes[494] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -23906,7 +24826,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[474] + mi := &file_product_proto_msgTypes[494] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -23939,7 +24859,7 @@ type RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_ContainerItem s func (x *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_ContainerItem) Reset() { *x = RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_ContainerItem{} - mi := &file_product_proto_msgTypes[475] + mi := &file_product_proto_msgTypes[495] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -23951,7 +24871,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[475] + mi := &file_product_proto_msgTypes[495] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -23991,7 +24911,7 @@ type RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_PalletItem stru func (x *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_PalletItem) Reset() { *x = RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_PalletItem{} - mi := &file_product_proto_msgTypes[476] + mi := &file_product_proto_msgTypes[496] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -24003,7 +24923,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[476] + mi := &file_product_proto_msgTypes[496] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -24046,7 +24966,7 @@ type RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem str func (x *RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem) Reset() { *x = RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem{} - mi := &file_product_proto_msgTypes[477] + mi := &file_product_proto_msgTypes[497] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -24058,7 +24978,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[477] + mi := &file_product_proto_msgTypes[497] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -24126,7 +25046,7 @@ type RequireStorageDeepItemInfoByIdFields_ContainerItem_ItemHandler struct { func (x *RequireStorageDeepItemInfoByIdFields_ContainerItem_ItemHandler) Reset() { *x = RequireStorageDeepItemInfoByIdFields_ContainerItem_ItemHandler{} - mi := &file_product_proto_msgTypes[478] + mi := &file_product_proto_msgTypes[498] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -24138,7 +25058,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[478] + mi := &file_product_proto_msgTypes[498] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -24161,6 +25081,58 @@ func (x *RequireStorageDeepItemInfoByIdFields_ContainerItem_ItemHandler) GetName return "" } +type RequireStorageRecommendedItemByIdFields_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 *RequireStorageRecommendedItemByIdFields_StorageMetadata) Reset() { + *x = RequireStorageRecommendedItemByIdFields_StorageMetadata{} + mi := &file_product_proto_msgTypes[499] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RequireStorageRecommendedItemByIdFields_StorageMetadata) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequireStorageRecommendedItemByIdFields_StorageMetadata) ProtoMessage() {} + +func (x *RequireStorageRecommendedItemByIdFields_StorageMetadata) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[499] + 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 RequireStorageRecommendedItemByIdFields_StorageMetadata.ProtoReflect.Descriptor instead. +func (*RequireStorageRecommendedItemByIdFields_StorageMetadata) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{332, 0} +} + +func (x *RequireStorageRecommendedItemByIdFields_StorageMetadata) GetCapacity() int32 { + if x != nil { + return x.Capacity + } + return 0 +} + +func (x *RequireStorageRecommendedItemByIdFields_StorageMetadata) GetZone() string { + if x != nil { + return x.Zone + } + return "" +} + type RequireWarehouseStockHealthScoreByIdFields_RestockData struct { state protoimpl.MessageState `protogen:"open.v1"` LastRestockDate string `protobuf:"bytes,1,opt,name=last_restock_date,json=lastRestockDate,proto3" json:"last_restock_date,omitempty"` @@ -24170,7 +25142,7 @@ type RequireWarehouseStockHealthScoreByIdFields_RestockData struct { func (x *RequireWarehouseStockHealthScoreByIdFields_RestockData) Reset() { *x = RequireWarehouseStockHealthScoreByIdFields_RestockData{} - mi := &file_product_proto_msgTypes[479] + mi := &file_product_proto_msgTypes[500] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -24182,7 +25154,7 @@ func (x *RequireWarehouseStockHealthScoreByIdFields_RestockData) String() string func (*RequireWarehouseStockHealthScoreByIdFields_RestockData) ProtoMessage() {} func (x *RequireWarehouseStockHealthScoreByIdFields_RestockData) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[479] + mi := &file_product_proto_msgTypes[500] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -24195,7 +25167,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{350, 0} + return file_product_proto_rawDescGZIP(), []int{370, 0} } func (x *RequireWarehouseStockHealthScoreByIdFields_RestockData) GetLastRestockDate() string { @@ -25129,7 +26101,54 @@ const file_product_proto_rawDesc = "" + "\vpallet_item\x18\x02 \x01(\v2:.productv1.RequireStorageDeepItemInfoByIdFields.PalletItemH\x00R\n" + "palletItemB\n" + "\n" + - "\binstance\"\xd3\x01\n" + + "\binstance\"y\n" + + "(RequireStorageRecommendedItemByIdRequest\x12M\n" + + "\acontext\x18\x01 \x03(\v23.productv1.RequireStorageRecommendedItemByIdContextR\acontext\"\xb0\x01\n" + + "(RequireStorageRecommendedItemByIdContext\x128\n" + + "\x03key\x18\x01 \x01(\v2&.productv1.LookupStorageByIdRequestKeyR\x03key\x12J\n" + + "\x06fields\x18\x02 \x01(\v22.productv1.RequireStorageRecommendedItemByIdFieldsR\x06fields\"w\n" + + ")RequireStorageRecommendedItemByIdResponse\x12J\n" + + "\x06result\x18\x01 \x03(\v22.productv1.RequireStorageRecommendedItemByIdResultR\x06result\"l\n" + + "'RequireStorageRecommendedItemByIdResult\x12A\n" + + "\x10recommended_item\x18\x01 \x01(\v2\x16.productv1.StorageItemR\x0frecommendedItem\"\xcc\x01\n" + + "'RequireStorageRecommendedItemByIdFields\x12^\n" + + "\bmetadata\x18\x01 \x01(\v2B.productv1.RequireStorageRecommendedItemByIdFields.StorageMetadataR\bmetadata\x1aA\n" + + "\x0fStorageMetadata\x12\x1a\n" + + "\bcapacity\x18\x01 \x01(\x05R\bcapacity\x12\x12\n" + + "\x04zone\x18\x02 \x01(\tR\x04zone\"{\n" + + ")RequireStorageRecommendedItemsByIdRequest\x12N\n" + + "\acontext\x18\x01 \x03(\v24.productv1.RequireStorageRecommendedItemsByIdContextR\acontext\"\xb2\x01\n" + + ")RequireStorageRecommendedItemsByIdContext\x128\n" + + "\x03key\x18\x01 \x01(\v2&.productv1.LookupStorageByIdRequestKeyR\x03key\x12K\n" + + "\x06fields\x18\x02 \x01(\v23.productv1.RequireStorageRecommendedItemsByIdFieldsR\x06fields\"y\n" + + "*RequireStorageRecommendedItemsByIdResponse\x12K\n" + + "\x06result\x18\x01 \x03(\v23.productv1.RequireStorageRecommendedItemsByIdResultR\x06result\"o\n" + + "(RequireStorageRecommendedItemsByIdResult\x12C\n" + + "\x11recommended_items\x18\x01 \x03(\v2\x16.productv1.StorageItemR\x10recommendedItems\">\n" + + "(RequireStorageRecommendedItemsByIdFields\x12\x12\n" + + "\x04tags\x18\x01 \x03(\tR\x04tags\"y\n" + + "(RequireStorageLatestOperationByIdRequest\x12M\n" + + "\acontext\x18\x01 \x03(\v23.productv1.RequireStorageLatestOperationByIdContextR\acontext\"\xb0\x01\n" + + "(RequireStorageLatestOperationByIdContext\x128\n" + + "\x03key\x18\x01 \x01(\v2&.productv1.LookupStorageByIdRequestKeyR\x03key\x12J\n" + + "\x06fields\x18\x02 \x01(\v22.productv1.RequireStorageLatestOperationByIdFieldsR\x06fields\"w\n" + + ")RequireStorageLatestOperationByIdResponse\x12J\n" + + "\x06result\x18\x01 \x03(\v22.productv1.RequireStorageLatestOperationByIdResultR\x06result\"w\n" + + "'RequireStorageLatestOperationByIdResult\x12L\n" + + "\x10latest_operation\x18\x01 \x01(\v2!.productv1.StorageOperationResultR\x0flatestOperation\"e\n" + + "'RequireStorageLatestOperationByIdFields\x12:\n" + + "\fstorage_kind\x18\x01 \x01(\x0e2\x17.productv1.CategoryKindR\vstorageKind\"\x89\x01\n" + + "0RequireStorageOptionalLatestOperationByIdRequest\x12U\n" + + "\acontext\x18\x01 \x03(\v2;.productv1.RequireStorageOptionalLatestOperationByIdContextR\acontext\"\xc0\x01\n" + + "0RequireStorageOptionalLatestOperationByIdContext\x128\n" + + "\x03key\x18\x01 \x01(\v2&.productv1.LookupStorageByIdRequestKeyR\x03key\x12R\n" + + "\x06fields\x18\x02 \x01(\v2:.productv1.RequireStorageOptionalLatestOperationByIdFieldsR\x06fields\"\x87\x01\n" + + "1RequireStorageOptionalLatestOperationByIdResponse\x12R\n" + + "\x06result\x18\x01 \x03(\v2:.productv1.RequireStorageOptionalLatestOperationByIdResultR\x06result\"\x90\x01\n" + + "/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" + "+RequireStorageFilteredTagSummaryByIdRequest\x12P\n" + "\acontext\x18\x01 \x03(\v26.productv1.RequireStorageFilteredTagSummaryByIdContextR\acontext\x12R\n" + "\n" + @@ -25590,7 +26609,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\xbd]\n" + + "\"SHIPPING_DESTINATION_INTERNATIONAL\x10\x032\xa4b\n" + "\x0eProductService\x12`\n" + "\x11LookupProductById\x12#.productv1.LookupProductByIdRequest\x1a$.productv1.LookupProductByIdResponse\"\x00\x12`\n" + "\x11LookupStorageById\x12#.productv1.LookupStorageByIdRequest\x1a$.productv1.LookupStorageByIdResponse\"\x00\x12f\n" + @@ -25648,17 +26667,21 @@ const file_product_proto_rawDesc = "" + "!RequireStorageItemHandlerInfoById\x123.productv1.RequireStorageItemHandlerInfoByIdRequest\x1a4.productv1.RequireStorageItemHandlerInfoByIdResponse\"\x00\x12{\n" + "\x1aRequireStorageItemInfoById\x12,.productv1.RequireStorageItemInfoByIdRequest\x1a-.productv1.RequireStorageItemInfoByIdResponse\"\x00\x12\x8a\x01\n" + "\x1fRequireStorageItemSpecsInfoById\x121.productv1.RequireStorageItemSpecsInfoByIdRequest\x1a2.productv1.RequireStorageItemSpecsInfoByIdResponse\"\x00\x12\x84\x01\n" + - "\x1dRequireStorageKindSummaryById\x12/.productv1.RequireStorageKindSummaryByIdRequest\x1a0.productv1.RequireStorageKindSummaryByIdResponse\"\x00\x12\x8a\x01\n" + + "\x1dRequireStorageKindSummaryById\x12/.productv1.RequireStorageKindSummaryByIdRequest\x1a0.productv1.RequireStorageKindSummaryByIdResponse\"\x00\x12\x90\x01\n" + + "!RequireStorageLatestOperationById\x123.productv1.RequireStorageLatestOperationByIdRequest\x1a4.productv1.RequireStorageLatestOperationByIdResponse\"\x00\x12\x8a\x01\n" + "\x1fRequireStorageMetadataScoreById\x121.productv1.RequireStorageMetadataScoreByIdRequest\x1a2.productv1.RequireStorageMetadataScoreByIdResponse\"\x00\x12\xa8\x01\n" + ")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\xae\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" + "$RequireStorageOptionalTagSummaryById\x126.productv1.RequireStorageOptionalTagSummaryByIdRequest\x1a7.productv1.RequireStorageOptionalTagSummaryByIdResponse\"\x00\x12\x96\x01\n" + "#RequireStorageProcessedMetadataById\x125.productv1.RequireStorageProcessedMetadataByIdRequest\x1a6.productv1.RequireStorageProcessedMetadataByIdResponse\"\x00\x12\xab\x01\n" + "*RequireStorageProcessedMetadataHistoryById\x12<.productv1.RequireStorageProcessedMetadataHistoryByIdRequest\x1a=.productv1.RequireStorageProcessedMetadataHistoryByIdResponse\"\x00\x12\x8a\x01\n" + "\x1fRequireStorageProcessedTagsById\x121.productv1.RequireStorageProcessedTagsByIdRequest\x1a2.productv1.RequireStorageProcessedTagsByIdResponse\"\x00\x12\x90\x01\n" + + "!RequireStorageRecommendedItemById\x123.productv1.RequireStorageRecommendedItemByIdRequest\x1a4.productv1.RequireStorageRecommendedItemByIdResponse\"\x00\x12\x93\x01\n" + + "\"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" + @@ -25702,7 +26725,7 @@ func file_product_proto_rawDescGZIP() []byte { } var file_product_proto_enumTypes = make([]protoimpl.EnumInfo, 2) -var file_product_proto_msgTypes = make([]protoimpl.MessageInfo, 480) +var file_product_proto_msgTypes = make([]protoimpl.MessageInfo, 501) var file_product_proto_goTypes = []any{ (CategoryKind)(0), // 0: productv1.CategoryKind (ShippingDestination)(0), // 1: productv1.ShippingDestination @@ -26034,324 +27057,345 @@ var file_product_proto_goTypes = []any{ (*RequireStorageDeepItemInfoByIdResponse)(nil), // 327: productv1.RequireStorageDeepItemInfoByIdResponse (*RequireStorageDeepItemInfoByIdResult)(nil), // 328: productv1.RequireStorageDeepItemInfoByIdResult (*RequireStorageDeepItemInfoByIdFields)(nil), // 329: productv1.RequireStorageDeepItemInfoByIdFields - (*RequireStorageFilteredTagSummaryByIdRequest)(nil), // 330: productv1.RequireStorageFilteredTagSummaryByIdRequest - (*RequireStorageFilteredTagSummaryByIdContext)(nil), // 331: productv1.RequireStorageFilteredTagSummaryByIdContext - (*RequireStorageFilteredTagSummaryByIdArgs)(nil), // 332: productv1.RequireStorageFilteredTagSummaryByIdArgs - (*RequireStorageFilteredTagSummaryByIdResponse)(nil), // 333: productv1.RequireStorageFilteredTagSummaryByIdResponse - (*RequireStorageFilteredTagSummaryByIdResult)(nil), // 334: productv1.RequireStorageFilteredTagSummaryByIdResult - (*RequireStorageFilteredTagSummaryByIdFields)(nil), // 335: productv1.RequireStorageFilteredTagSummaryByIdFields - (*RequireStorageMultiFilteredTagSummaryByIdRequest)(nil), // 336: productv1.RequireStorageMultiFilteredTagSummaryByIdRequest - (*RequireStorageMultiFilteredTagSummaryByIdContext)(nil), // 337: productv1.RequireStorageMultiFilteredTagSummaryByIdContext - (*RequireStorageMultiFilteredTagSummaryByIdArgs)(nil), // 338: productv1.RequireStorageMultiFilteredTagSummaryByIdArgs - (*RequireStorageMultiFilteredTagSummaryByIdResponse)(nil), // 339: productv1.RequireStorageMultiFilteredTagSummaryByIdResponse - (*RequireStorageMultiFilteredTagSummaryByIdResult)(nil), // 340: productv1.RequireStorageMultiFilteredTagSummaryByIdResult - (*RequireStorageMultiFilteredTagSummaryByIdFields)(nil), // 341: productv1.RequireStorageMultiFilteredTagSummaryByIdFields - (*RequireStorageNullableFilteredTagSummaryByIdRequest)(nil), // 342: productv1.RequireStorageNullableFilteredTagSummaryByIdRequest - (*RequireStorageNullableFilteredTagSummaryByIdContext)(nil), // 343: productv1.RequireStorageNullableFilteredTagSummaryByIdContext - (*RequireStorageNullableFilteredTagSummaryByIdArgs)(nil), // 344: productv1.RequireStorageNullableFilteredTagSummaryByIdArgs - (*RequireStorageNullableFilteredTagSummaryByIdResponse)(nil), // 345: productv1.RequireStorageNullableFilteredTagSummaryByIdResponse - (*RequireStorageNullableFilteredTagSummaryByIdResult)(nil), // 346: productv1.RequireStorageNullableFilteredTagSummaryByIdResult - (*RequireStorageNullableFilteredTagSummaryByIdFields)(nil), // 347: productv1.RequireStorageNullableFilteredTagSummaryByIdFields - (*RequireWarehouseStockHealthScoreByIdRequest)(nil), // 348: productv1.RequireWarehouseStockHealthScoreByIdRequest - (*RequireWarehouseStockHealthScoreByIdContext)(nil), // 349: productv1.RequireWarehouseStockHealthScoreByIdContext - (*RequireWarehouseStockHealthScoreByIdResponse)(nil), // 350: productv1.RequireWarehouseStockHealthScoreByIdResponse - (*RequireWarehouseStockHealthScoreByIdResult)(nil), // 351: productv1.RequireWarehouseStockHealthScoreByIdResult - (*RequireWarehouseStockHealthScoreByIdFields)(nil), // 352: productv1.RequireWarehouseStockHealthScoreByIdFields - (*Product)(nil), // 353: productv1.Product - (*Storage)(nil), // 354: productv1.Storage - (*Warehouse)(nil), // 355: productv1.Warehouse - (*User)(nil), // 356: productv1.User - (*NestedTypeA)(nil), // 357: productv1.NestedTypeA - (*RecursiveType)(nil), // 358: productv1.RecursiveType - (*TypeWithMultipleFilterFields)(nil), // 359: productv1.TypeWithMultipleFilterFields - (*FilterTypeInput)(nil), // 360: productv1.FilterTypeInput - (*ComplexFilterTypeInput)(nil), // 361: productv1.ComplexFilterTypeInput - (*TypeWithComplexFilterInput)(nil), // 362: productv1.TypeWithComplexFilterInput - (*OrderInput)(nil), // 363: productv1.OrderInput - (*Order)(nil), // 364: productv1.Order - (*Category)(nil), // 365: productv1.Category - (*CategoryFilter)(nil), // 366: productv1.CategoryFilter - (*Animal)(nil), // 367: productv1.Animal - (*SearchInput)(nil), // 368: productv1.SearchInput - (*SearchResult)(nil), // 369: productv1.SearchResult - (*NullableFieldsType)(nil), // 370: productv1.NullableFieldsType - (*NullableFieldsFilter)(nil), // 371: productv1.NullableFieldsFilter - (*BlogPost)(nil), // 372: productv1.BlogPost - (*BlogPostFilter)(nil), // 373: productv1.BlogPostFilter - (*Author)(nil), // 374: productv1.Author - (*AuthorFilter)(nil), // 375: productv1.AuthorFilter - (*TestContainer)(nil), // 376: productv1.TestContainer - (*ConditionsInput)(nil), // 377: productv1.ConditionsInput - (*ConditionalSearchResult)(nil), // 378: productv1.ConditionalSearchResult - (*UserInput)(nil), // 379: productv1.UserInput - (*ActionInput)(nil), // 380: productv1.ActionInput - (*ActionResult)(nil), // 381: productv1.ActionResult - (*NullableFieldsInput)(nil), // 382: productv1.NullableFieldsInput - (*BlogPostInput)(nil), // 383: productv1.BlogPostInput - (*AuthorInput)(nil), // 384: productv1.AuthorInput - (*ProductDetails)(nil), // 385: productv1.ProductDetails - (*RestockData)(nil), // 386: productv1.RestockData - (*StorageMetadata)(nil), // 387: productv1.StorageMetadata - (*StorageCategoryInfo)(nil), // 388: productv1.StorageCategoryInfo - (*NestedTypeB)(nil), // 389: productv1.NestedTypeB - (*NestedTypeC)(nil), // 390: productv1.NestedTypeC - (*FilterType)(nil), // 391: productv1.FilterType - (*Pagination)(nil), // 392: productv1.Pagination - (*OrderLineInput)(nil), // 393: productv1.OrderLineInput - (*OrderLine)(nil), // 394: productv1.OrderLine - (*Subcategory)(nil), // 395: productv1.Subcategory - (*CategoryMetrics)(nil), // 396: productv1.CategoryMetrics - (*Cat)(nil), // 397: productv1.Cat - (*Dog)(nil), // 398: productv1.Dog - (*Owner)(nil), // 399: productv1.Owner - (*ContactInfo)(nil), // 400: productv1.ContactInfo - (*Address)(nil), // 401: productv1.Address - (*CatBreed)(nil), // 402: productv1.CatBreed - (*DogBreed)(nil), // 403: productv1.DogBreed - (*BreedCharacteristics)(nil), // 404: productv1.BreedCharacteristics - (*StorageItem)(nil), // 405: productv1.StorageItem - (*PalletItem)(nil), // 406: productv1.PalletItem - (*ContainerItem)(nil), // 407: productv1.ContainerItem - (*ItemHandler)(nil), // 408: productv1.ItemHandler - (*PalletSpecs)(nil), // 409: productv1.PalletSpecs - (*ContainerSpecs)(nil), // 410: productv1.ContainerSpecs - (*Dimensions)(nil), // 411: productv1.Dimensions - (*StorageOperationResult)(nil), // 412: productv1.StorageOperationResult - (*StorageSuccess)(nil), // 413: productv1.StorageSuccess - (*StorageFailure)(nil), // 414: productv1.StorageFailure - (*SecuritySetup)(nil), // 415: productv1.SecuritySetup - (*ActionSuccess)(nil), // 416: productv1.ActionSuccess - (*ActionError)(nil), // 417: productv1.ActionError - (*TestDetails)(nil), // 418: productv1.TestDetails - (*CategoryInput)(nil), // 419: productv1.CategoryInput - (*ProductCountFilter)(nil), // 420: productv1.ProductCountFilter - (*SubcategoryItemFilter)(nil), // 421: productv1.SubcategoryItemFilter - (*ShippingEstimateInput)(nil), // 422: productv1.ShippingEstimateInput - (*ListOfAuthorFilter_List)(nil), // 423: productv1.ListOfAuthorFilter.List - (*ListOfAuthorInput_List)(nil), // 424: productv1.ListOfAuthorInput.List - (*ListOfBlogPost_List)(nil), // 425: productv1.ListOfBlogPost.List - (*ListOfBlogPostFilter_List)(nil), // 426: productv1.ListOfBlogPostFilter.List - (*ListOfBlogPostInput_List)(nil), // 427: productv1.ListOfBlogPostInput.List - (*ListOfBoolean_List)(nil), // 428: productv1.ListOfBoolean.List - (*ListOfCategory_List)(nil), // 429: productv1.ListOfCategory.List - (*ListOfCategoryInput_List)(nil), // 430: productv1.ListOfCategoryInput.List - (*ListOfConditionsInput_List)(nil), // 431: productv1.ListOfConditionsInput.List - (*ListOfFloat_List)(nil), // 432: productv1.ListOfFloat.List - (*ListOfListOfCategory_List)(nil), // 433: productv1.ListOfListOfCategory.List - (*ListOfListOfCategoryInput_List)(nil), // 434: productv1.ListOfListOfCategoryInput.List - (*ListOfListOfString_List)(nil), // 435: productv1.ListOfListOfString.List - (*ListOfListOfUser_List)(nil), // 436: productv1.ListOfListOfUser.List - (*ListOfListOfUserInput_List)(nil), // 437: productv1.ListOfListOfUserInput.List - (*ListOfOrderLine_List)(nil), // 438: productv1.ListOfOrderLine.List - (*ListOfProduct_List)(nil), // 439: productv1.ListOfProduct.List - (*ListOfStorage_List)(nil), // 440: productv1.ListOfStorage.List - (*ListOfString_List)(nil), // 441: productv1.ListOfString.List - (*ListOfSubcategory_List)(nil), // 442: productv1.ListOfSubcategory.List - (*ListOfUser_List)(nil), // 443: productv1.ListOfUser.List - (*ListOfUserInput_List)(nil), // 444: productv1.ListOfUserInput.List - (*RequireStorageStockHealthScoreByIdFields_RestockData)(nil), // 445: productv1.RequireStorageStockHealthScoreByIdFields.RestockData - (*RequireStorageMetadataScoreByIdFields_StorageMetadata)(nil), // 446: productv1.RequireStorageMetadataScoreByIdFields.StorageMetadata - (*RequireStorageProcessedMetadataByIdFields_StorageMetadata)(nil), // 447: productv1.RequireStorageProcessedMetadataByIdFields.StorageMetadata - (*RequireStorageOptionalProcessedMetadataByIdFields_StorageMetadata)(nil), // 448: productv1.RequireStorageOptionalProcessedMetadataByIdFields.StorageMetadata - (*RequireStorageProcessedMetadataHistoryByIdFields_StorageMetadata)(nil), // 449: productv1.RequireStorageProcessedMetadataHistoryByIdFields.StorageMetadata - (*RequireStorageCategoryInfoSummaryByIdFields_StorageCategoryInfo)(nil), // 450: productv1.RequireStorageCategoryInfoSummaryByIdFields.StorageCategoryInfo - (*RequireStorageItemInfoByIdFields_PalletItem)(nil), // 451: productv1.RequireStorageItemInfoByIdFields.PalletItem - (*RequireStorageItemInfoByIdFields_ContainerItem)(nil), // 452: productv1.RequireStorageItemInfoByIdFields.ContainerItem - (*RequireStorageItemInfoByIdFields_StorageItem)(nil), // 453: productv1.RequireStorageItemInfoByIdFields.StorageItem - (*RequireStorageOperationReportByIdFields_StorageSuccess)(nil), // 454: productv1.RequireStorageOperationReportByIdFields.StorageSuccess - (*RequireStorageOperationReportByIdFields_StorageFailure)(nil), // 455: productv1.RequireStorageOperationReportByIdFields.StorageFailure - (*RequireStorageOperationReportByIdFields_StorageOperationResult)(nil), // 456: productv1.RequireStorageOperationReportByIdFields.StorageOperationResult - (*RequireStorageSecuritySummaryByIdFields_SecuritySetup)(nil), // 457: productv1.RequireStorageSecuritySummaryByIdFields.SecuritySetup - (*RequireStorageSecuritySummaryByIdFields_SecuritySetup_PalletItem)(nil), // 458: productv1.RequireStorageSecuritySummaryByIdFields.SecuritySetup.PalletItem - (*RequireStorageSecuritySummaryByIdFields_SecuritySetup_ContainerItem)(nil), // 459: productv1.RequireStorageSecuritySummaryByIdFields.SecuritySetup.ContainerItem - (*RequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem)(nil), // 460: productv1.RequireStorageSecuritySummaryByIdFields.SecuritySetup.StorageItem - (*RequireStorageItemHandlerInfoByIdFields_PalletItem)(nil), // 461: productv1.RequireStorageItemHandlerInfoByIdFields.PalletItem - (*RequireStorageItemHandlerInfoByIdFields_ContainerItem)(nil), // 462: productv1.RequireStorageItemHandlerInfoByIdFields.ContainerItem - (*RequireStorageItemHandlerInfoByIdFields_StorageItem)(nil), // 463: productv1.RequireStorageItemHandlerInfoByIdFields.StorageItem - (*RequireStorageItemHandlerInfoByIdFields_PalletItem_ItemHandler)(nil), // 464: productv1.RequireStorageItemHandlerInfoByIdFields.PalletItem.ItemHandler - (*RequireStorageItemHandlerInfoByIdFields_ContainerItem_ItemHandler)(nil), // 465: productv1.RequireStorageItemHandlerInfoByIdFields.ContainerItem.ItemHandler - (*RequireStorageItemSpecsInfoByIdFields_PalletItem)(nil), // 466: productv1.RequireStorageItemSpecsInfoByIdFields.PalletItem - (*RequireStorageItemSpecsInfoByIdFields_ContainerItem)(nil), // 467: productv1.RequireStorageItemSpecsInfoByIdFields.ContainerItem - (*RequireStorageItemSpecsInfoByIdFields_StorageItem)(nil), // 468: productv1.RequireStorageItemSpecsInfoByIdFields.StorageItem - (*RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs)(nil), // 469: productv1.RequireStorageItemSpecsInfoByIdFields.PalletItem.PalletSpecs - (*RequireStorageItemSpecsInfoByIdFields_PalletItem_PalletSpecs_Dimensions)(nil), // 470: productv1.RequireStorageItemSpecsInfoByIdFields.PalletItem.PalletSpecs.Dimensions - (*RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs)(nil), // 471: productv1.RequireStorageItemSpecsInfoByIdFields.ContainerItem.ContainerSpecs - (*RequireStorageItemSpecsInfoByIdFields_ContainerItem_ContainerSpecs_Dimensions)(nil), // 472: productv1.RequireStorageItemSpecsInfoByIdFields.ContainerItem.ContainerSpecs.Dimensions - (*RequireStorageDeepItemInfoByIdFields_PalletItem)(nil), // 473: productv1.RequireStorageDeepItemInfoByIdFields.PalletItem - (*RequireStorageDeepItemInfoByIdFields_ContainerItem)(nil), // 474: productv1.RequireStorageDeepItemInfoByIdFields.ContainerItem - (*RequireStorageDeepItemInfoByIdFields_StorageItem)(nil), // 475: productv1.RequireStorageDeepItemInfoByIdFields.StorageItem - (*RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler)(nil), // 476: productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.ItemHandler - (*RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_ContainerItem)(nil), // 477: productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.ItemHandler.ContainerItem - (*RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_PalletItem)(nil), // 478: productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.ItemHandler.PalletItem - (*RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem)(nil), // 479: productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.ItemHandler.StorageItem - (*RequireStorageDeepItemInfoByIdFields_ContainerItem_ItemHandler)(nil), // 480: productv1.RequireStorageDeepItemInfoByIdFields.ContainerItem.ItemHandler - (*RequireWarehouseStockHealthScoreByIdFields_RestockData)(nil), // 481: productv1.RequireWarehouseStockHealthScoreByIdFields.RestockData - (*wrapperspb.Int32Value)(nil), // 482: google.protobuf.Int32Value - (*wrapperspb.BoolValue)(nil), // 483: google.protobuf.BoolValue - (*wrapperspb.StringValue)(nil), // 484: google.protobuf.StringValue - (*wrapperspb.DoubleValue)(nil), // 485: google.protobuf.DoubleValue + (*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 } var file_product_proto_depIdxs = []int32{ - 423, // 0: productv1.ListOfAuthorFilter.list:type_name -> productv1.ListOfAuthorFilter.List - 424, // 1: productv1.ListOfAuthorInput.list:type_name -> productv1.ListOfAuthorInput.List - 425, // 2: productv1.ListOfBlogPost.list:type_name -> productv1.ListOfBlogPost.List - 426, // 3: productv1.ListOfBlogPostFilter.list:type_name -> productv1.ListOfBlogPostFilter.List - 427, // 4: productv1.ListOfBlogPostInput.list:type_name -> productv1.ListOfBlogPostInput.List - 428, // 5: productv1.ListOfBoolean.list:type_name -> productv1.ListOfBoolean.List - 429, // 6: productv1.ListOfCategory.list:type_name -> productv1.ListOfCategory.List - 430, // 7: productv1.ListOfCategoryInput.list:type_name -> productv1.ListOfCategoryInput.List - 431, // 8: productv1.ListOfConditionsInput.list:type_name -> productv1.ListOfConditionsInput.List - 432, // 9: productv1.ListOfFloat.list:type_name -> productv1.ListOfFloat.List - 433, // 10: productv1.ListOfListOfCategory.list:type_name -> productv1.ListOfListOfCategory.List - 434, // 11: productv1.ListOfListOfCategoryInput.list:type_name -> productv1.ListOfListOfCategoryInput.List - 435, // 12: productv1.ListOfListOfString.list:type_name -> productv1.ListOfListOfString.List - 436, // 13: productv1.ListOfListOfUser.list:type_name -> productv1.ListOfListOfUser.List - 437, // 14: productv1.ListOfListOfUserInput.list:type_name -> productv1.ListOfListOfUserInput.List - 438, // 15: productv1.ListOfOrderLine.list:type_name -> productv1.ListOfOrderLine.List - 439, // 16: productv1.ListOfProduct.list:type_name -> productv1.ListOfProduct.List - 440, // 17: productv1.ListOfStorage.list:type_name -> productv1.ListOfStorage.List - 441, // 18: productv1.ListOfString.list:type_name -> productv1.ListOfString.List - 442, // 19: productv1.ListOfSubcategory.list:type_name -> productv1.ListOfSubcategory.List - 443, // 20: productv1.ListOfUser.list:type_name -> productv1.ListOfUser.List - 444, // 21: productv1.ListOfUserInput.list:type_name -> productv1.ListOfUserInput.List + 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 - 353, // 23: productv1.LookupProductByIdResponse.result:type_name -> productv1.Product + 373, // 23: productv1.LookupProductByIdResponse.result:type_name -> productv1.Product 27, // 24: productv1.LookupStorageByIdRequest.keys:type_name -> productv1.LookupStorageByIdRequestKey - 354, // 25: productv1.LookupStorageByIdResponse.result:type_name -> productv1.Storage + 374, // 25: productv1.LookupStorageByIdResponse.result:type_name -> productv1.Storage 30, // 26: productv1.LookupWarehouseByIdRequest.keys:type_name -> productv1.LookupWarehouseByIdRequestKey - 355, // 27: productv1.LookupWarehouseByIdResponse.result:type_name -> productv1.Warehouse - 356, // 28: productv1.QueryUsersResponse.users:type_name -> productv1.User - 356, // 29: productv1.QueryUserResponse.user:type_name -> productv1.User - 357, // 30: productv1.QueryNestedTypeResponse.nested_type:type_name -> productv1.NestedTypeA - 358, // 31: productv1.QueryRecursiveTypeResponse.recursive_type:type_name -> productv1.RecursiveType - 359, // 32: productv1.QueryTypeFilterWithArgumentsResponse.type_filter_with_arguments:type_name -> productv1.TypeWithMultipleFilterFields - 360, // 33: productv1.QueryTypeWithMultipleFilterFieldsRequest.filter:type_name -> productv1.FilterTypeInput - 359, // 34: productv1.QueryTypeWithMultipleFilterFieldsResponse.type_with_multiple_filter_fields:type_name -> productv1.TypeWithMultipleFilterFields - 361, // 35: productv1.QueryComplexFilterTypeRequest.filter:type_name -> productv1.ComplexFilterTypeInput - 362, // 36: productv1.QueryComplexFilterTypeResponse.complex_filter_type:type_name -> productv1.TypeWithComplexFilterInput - 363, // 37: productv1.QueryCalculateTotalsRequest.orders:type_name -> productv1.OrderInput - 364, // 38: productv1.QueryCalculateTotalsResponse.calculate_totals:type_name -> productv1.Order - 365, // 39: productv1.QueryCategoriesResponse.categories:type_name -> productv1.Category - 365, // 40: productv1.QueryCategoryResponse.category:type_name -> productv1.Category + 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 - 365, // 42: productv1.QueryCategoriesByKindResponse.categories_by_kind:type_name -> productv1.Category + 385, // 42: productv1.QueryCategoriesByKindResponse.categories_by_kind:type_name -> productv1.Category 0, // 43: productv1.QueryCategoriesByKindsRequest.kinds:type_name -> productv1.CategoryKind - 365, // 44: productv1.QueryCategoriesByKindsResponse.categories_by_kinds:type_name -> productv1.Category - 366, // 45: productv1.QueryFilterCategoriesRequest.filter:type_name -> productv1.CategoryFilter - 365, // 46: productv1.QueryFilterCategoriesResponse.filter_categories:type_name -> productv1.Category - 367, // 47: productv1.QueryRandomPetResponse.random_pet:type_name -> productv1.Animal - 367, // 48: productv1.QueryAllPetsResponse.all_pets:type_name -> productv1.Animal - 368, // 49: productv1.QuerySearchRequest.input:type_name -> productv1.SearchInput - 369, // 50: productv1.QuerySearchResponse.search:type_name -> productv1.SearchResult - 369, // 51: productv1.QueryRandomSearchResultResponse.random_search_result:type_name -> productv1.SearchResult - 370, // 52: productv1.QueryNullableFieldsTypeResponse.nullable_fields_type:type_name -> productv1.NullableFieldsType - 370, // 53: productv1.QueryNullableFieldsTypeByIdResponse.nullable_fields_type_by_id:type_name -> productv1.NullableFieldsType - 371, // 54: productv1.QueryNullableFieldsTypeWithFilterRequest.filter:type_name -> productv1.NullableFieldsFilter - 370, // 55: productv1.QueryNullableFieldsTypeWithFilterResponse.nullable_fields_type_with_filter:type_name -> productv1.NullableFieldsType - 370, // 56: productv1.QueryAllNullableFieldsTypesResponse.all_nullable_fields_types:type_name -> productv1.NullableFieldsType - 372, // 57: productv1.QueryBlogPostResponse.blog_post:type_name -> productv1.BlogPost - 372, // 58: productv1.QueryBlogPostByIdResponse.blog_post_by_id:type_name -> productv1.BlogPost - 373, // 59: productv1.QueryBlogPostsWithFilterRequest.filter:type_name -> productv1.BlogPostFilter - 372, // 60: productv1.QueryBlogPostsWithFilterResponse.blog_posts_with_filter:type_name -> productv1.BlogPost - 372, // 61: productv1.QueryAllBlogPostsResponse.all_blog_posts:type_name -> productv1.BlogPost - 374, // 62: productv1.QueryAuthorResponse.author:type_name -> productv1.Author - 374, // 63: productv1.QueryAuthorByIdResponse.author_by_id:type_name -> productv1.Author - 375, // 64: productv1.QueryAuthorsWithFilterRequest.filter:type_name -> productv1.AuthorFilter - 374, // 65: productv1.QueryAuthorsWithFilterResponse.authors_with_filter:type_name -> productv1.Author - 374, // 66: productv1.QueryAllAuthorsResponse.all_authors:type_name -> productv1.Author + 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 - 374, // 68: productv1.QueryBulkSearchAuthorsResponse.bulk_search_authors:type_name -> productv1.Author + 394, // 68: productv1.QueryBulkSearchAuthorsResponse.bulk_search_authors:type_name -> productv1.Author 5, // 69: productv1.QueryBulkSearchBlogPostsRequest.filters:type_name -> productv1.ListOfBlogPostFilter - 372, // 70: productv1.QueryBulkSearchBlogPostsResponse.bulk_search_blog_posts:type_name -> productv1.BlogPost - 376, // 71: productv1.QueryTestContainerResponse.test_container:type_name -> productv1.TestContainer - 376, // 72: productv1.QueryTestContainersResponse.test_containers:type_name -> productv1.TestContainer - 377, // 73: productv1.QueryConditionalSearchRequest.conditions:type_name -> productv1.ConditionsInput - 378, // 74: productv1.QueryConditionalSearchResponse.conditional_search:type_name -> productv1.ConditionalSearchResult - 379, // 75: productv1.MutationCreateUserRequest.input:type_name -> productv1.UserInput - 356, // 76: productv1.MutationCreateUserResponse.create_user:type_name -> productv1.User - 380, // 77: productv1.MutationPerformActionRequest.input:type_name -> productv1.ActionInput - 381, // 78: productv1.MutationPerformActionResponse.perform_action:type_name -> productv1.ActionResult - 382, // 79: productv1.MutationCreateNullableFieldsTypeRequest.input:type_name -> productv1.NullableFieldsInput - 370, // 80: productv1.MutationCreateNullableFieldsTypeResponse.create_nullable_fields_type:type_name -> productv1.NullableFieldsType - 382, // 81: productv1.MutationUpdateNullableFieldsTypeRequest.input:type_name -> productv1.NullableFieldsInput - 370, // 82: productv1.MutationUpdateNullableFieldsTypeResponse.update_nullable_fields_type:type_name -> productv1.NullableFieldsType - 383, // 83: productv1.MutationCreateBlogPostRequest.input:type_name -> productv1.BlogPostInput - 372, // 84: productv1.MutationCreateBlogPostResponse.create_blog_post:type_name -> productv1.BlogPost - 383, // 85: productv1.MutationUpdateBlogPostRequest.input:type_name -> productv1.BlogPostInput - 372, // 86: productv1.MutationUpdateBlogPostResponse.update_blog_post:type_name -> productv1.BlogPost - 384, // 87: productv1.MutationCreateAuthorRequest.input:type_name -> productv1.AuthorInput - 374, // 88: productv1.MutationCreateAuthorResponse.create_author:type_name -> productv1.Author - 384, // 89: productv1.MutationUpdateAuthorRequest.input:type_name -> productv1.AuthorInput - 374, // 90: productv1.MutationUpdateAuthorResponse.update_author:type_name -> productv1.Author + 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 - 374, // 92: productv1.MutationBulkCreateAuthorsResponse.bulk_create_authors:type_name -> productv1.Author + 394, // 92: productv1.MutationBulkCreateAuthorsResponse.bulk_create_authors:type_name -> productv1.Author 3, // 93: productv1.MutationBulkUpdateAuthorsRequest.authors:type_name -> productv1.ListOfAuthorInput - 374, // 94: productv1.MutationBulkUpdateAuthorsResponse.bulk_update_authors:type_name -> productv1.Author + 394, // 94: productv1.MutationBulkUpdateAuthorsResponse.bulk_update_authors:type_name -> productv1.Author 6, // 95: productv1.MutationBulkCreateBlogPostsRequest.blog_posts:type_name -> productv1.ListOfBlogPostInput - 372, // 96: productv1.MutationBulkCreateBlogPostsResponse.bulk_create_blog_posts:type_name -> productv1.BlogPost + 392, // 96: productv1.MutationBulkCreateBlogPostsResponse.bulk_create_blog_posts:type_name -> productv1.BlogPost 6, // 97: productv1.MutationBulkUpdateBlogPostsRequest.blog_posts:type_name -> productv1.ListOfBlogPostInput - 372, // 98: productv1.MutationBulkUpdateBlogPostsResponse.bulk_update_blog_posts:type_name -> productv1.BlogPost - 422, // 99: productv1.ResolveProductShippingEstimateArgs.input:type_name -> productv1.ShippingEstimateInput + 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 - 365, // 105: productv1.ResolveProductRecommendedCategoryResult.recommended_category:type_name -> productv1.Category + 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 - 367, // 109: productv1.ResolveProductMascotRecommendationResult.mascot_recommendation:type_name -> productv1.Animal + 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 - 381, // 113: productv1.ResolveProductStockStatusResult.stock_status:type_name -> productv1.ActionResult + 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 - 385, // 117: productv1.ResolveProductProductDetailsResult.product_details:type_name -> productv1.ProductDetails + 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 - 381, // 121: productv1.ResolveStorageStorageStatusResult.storage_status:type_name -> productv1.ActionResult + 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 - 354, // 125: productv1.ResolveStorageLinkedStoragesResult.linked_storages:type_name -> productv1.Storage + 374, // 125: productv1.ResolveStorageLinkedStoragesResult.linked_storages:type_name -> productv1.Storage 158, // 126: productv1.ResolveStorageLinkedStoragesResponse.result:type_name -> productv1.ResolveStorageLinkedStoragesResult - 482, // 127: productv1.ResolveStorageNearbyStoragesArgs.radius:type_name -> google.protobuf.Int32Value + 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 - 420, // 132: productv1.ResolveCategoryProductCountArgs.filters:type_name -> productv1.ProductCountFilter + 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 - 482, // 136: productv1.ResolveCategoryPopularityScoreArgs.threshold:type_name -> google.protobuf.Int32Value + 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 - 482, // 139: productv1.ResolveCategoryPopularityScoreResult.popularity_score:type_name -> google.protobuf.Int32Value + 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 - 396, // 143: productv1.ResolveCategoryCategoryMetricsResult.category_metrics:type_name -> productv1.CategoryMetrics + 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 - 367, // 148: productv1.ResolveCategoryMascotResult.mascot:type_name -> productv1.Animal + 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 - 381, // 152: productv1.ResolveCategoryCategoryStatusResult.category_status:type_name -> productv1.ActionResult + 401, // 152: productv1.ResolveCategoryCategoryStatusResult.category_status:type_name -> productv1.ActionResult 188, // 153: productv1.ResolveCategoryCategoryStatusResponse.result:type_name -> productv1.ResolveCategoryCategoryStatusResult - 483, // 154: productv1.ResolveCategoryChildCategoriesArgs.include:type_name -> google.protobuf.BoolValue + 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 - 365, // 157: productv1.ResolveCategoryChildCategoriesResult.child_categories:type_name -> productv1.Category + 385, // 157: productv1.ResolveCategoryChildCategoriesResult.child_categories:type_name -> productv1.Category 193, // 158: productv1.ResolveCategoryChildCategoriesResponse.result:type_name -> productv1.ResolveCategoryChildCategoriesResult - 483, // 159: productv1.ResolveCategoryOptionalCategoriesArgs.include:type_name -> google.protobuf.BoolValue + 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 @@ -26359,41 +27403,41 @@ var file_product_proto_depIdxs = []int32{ 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 - 395, // 167: productv1.ResolveCategoryTopSubcategoryResult.top_subcategory:type_name -> productv1.Subcategory + 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 - 395, // 170: productv1.ResolveCategoryActiveSubcategoriesResult.active_subcategories:type_name -> productv1.Subcategory + 415, // 170: productv1.ResolveCategoryActiveSubcategoriesResult.active_subcategories:type_name -> productv1.Subcategory 210, // 171: productv1.ResolveCategoryActiveSubcategoriesResponse.result:type_name -> productv1.ResolveCategoryActiveSubcategoriesResult - 421, // 172: productv1.ResolveSubcategoryItemCountArgs.filters:type_name -> productv1.SubcategoryItemFilter + 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 - 365, // 178: productv1.ResolveSubcategoryFeaturedCategoryResult.featured_category:type_name -> productv1.Category + 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 - 365, // 181: productv1.ResolveSubcategoryParentCategoryResult.parent_category:type_name -> productv1.Category + 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 - 483, // 186: productv1.ResolveCategoryMetricsRelatedCategoryArgs.include:type_name -> google.protobuf.BoolValue + 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 - 365, // 189: productv1.ResolveCategoryMetricsRelatedCategoryResult.related_category:type_name -> productv1.Category + 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 - 418, // 195: productv1.ResolveTestContainerDetailsResult.details:type_name -> productv1.TestDetails + 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 - 445, // 201: productv1.RequireStorageStockHealthScoreByIdFields.restock_data:type_name -> productv1.RequireStorageStockHealthScoreByIdFields.RestockData + 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 @@ -26402,25 +27446,25 @@ var file_product_proto_depIdxs = []int32{ 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 - 484, // 210: productv1.RequireStorageOptionalTagSummaryByIdResult.optional_tag_summary:type_name -> google.protobuf.StringValue + 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 - 446, // 216: productv1.RequireStorageMetadataScoreByIdFields.metadata:type_name -> productv1.RequireStorageMetadataScoreByIdFields.StorageMetadata + 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 - 387, // 221: productv1.RequireStorageProcessedMetadataByIdResult.processed_metadata:type_name -> productv1.StorageMetadata - 447, // 222: productv1.RequireStorageProcessedMetadataByIdFields.metadata:type_name -> productv1.RequireStorageProcessedMetadataByIdFields.StorageMetadata + 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 - 387, // 227: productv1.RequireStorageOptionalProcessedMetadataByIdResult.optional_processed_metadata:type_name -> productv1.StorageMetadata - 448, // 228: productv1.RequireStorageOptionalProcessedMetadataByIdFields.metadata:type_name -> productv1.RequireStorageOptionalProcessedMetadataByIdFields.StorageMetadata + 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 @@ -26435,8 +27479,8 @@ var file_product_proto_depIdxs = []int32{ 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 - 387, // 243: productv1.RequireStorageProcessedMetadataHistoryByIdResult.processed_metadata_history:type_name -> productv1.StorageMetadata - 449, // 244: productv1.RequireStorageProcessedMetadataHistoryByIdFields.metadata_history:type_name -> productv1.RequireStorageProcessedMetadataHistoryByIdFields.StorageMetadata + 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 @@ -26446,426 +27490,457 @@ var file_product_proto_depIdxs = []int32{ 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 - 450, // 254: productv1.RequireStorageCategoryInfoSummaryByIdFields.category_info:type_name -> productv1.RequireStorageCategoryInfoSummaryByIdFields.StorageCategoryInfo + 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 - 453, // 259: productv1.RequireStorageItemInfoByIdFields.primary_item:type_name -> productv1.RequireStorageItemInfoByIdFields.StorageItem + 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 - 456, // 264: productv1.RequireStorageOperationReportByIdFields.last_storage_operation:type_name -> productv1.RequireStorageOperationReportByIdFields.StorageOperationResult + 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 - 457, // 269: productv1.RequireStorageSecuritySummaryByIdFields.security_setup:type_name -> productv1.RequireStorageSecuritySummaryByIdFields.SecuritySetup + 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 - 463, // 274: productv1.RequireStorageItemHandlerInfoByIdFields.primary_item:type_name -> productv1.RequireStorageItemHandlerInfoByIdFields.StorageItem + 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 - 468, // 279: productv1.RequireStorageItemSpecsInfoByIdFields.primary_item:type_name -> productv1.RequireStorageItemSpecsInfoByIdFields.StorageItem + 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 - 475, // 284: productv1.RequireStorageDeepItemInfoByIdFields.primary_item:type_name -> productv1.RequireStorageDeepItemInfoByIdFields.StorageItem - 331, // 285: productv1.RequireStorageFilteredTagSummaryByIdRequest.context:type_name -> productv1.RequireStorageFilteredTagSummaryByIdContext - 332, // 286: productv1.RequireStorageFilteredTagSummaryByIdRequest.field_args:type_name -> productv1.RequireStorageFilteredTagSummaryByIdArgs - 27, // 287: productv1.RequireStorageFilteredTagSummaryByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey - 335, // 288: productv1.RequireStorageFilteredTagSummaryByIdContext.fields:type_name -> productv1.RequireStorageFilteredTagSummaryByIdFields - 334, // 289: productv1.RequireStorageFilteredTagSummaryByIdResponse.result:type_name -> productv1.RequireStorageFilteredTagSummaryByIdResult - 484, // 290: productv1.RequireStorageFilteredTagSummaryByIdResult.filtered_tag_summary:type_name -> google.protobuf.StringValue - 337, // 291: productv1.RequireStorageMultiFilteredTagSummaryByIdRequest.context:type_name -> productv1.RequireStorageMultiFilteredTagSummaryByIdContext - 338, // 292: productv1.RequireStorageMultiFilteredTagSummaryByIdRequest.field_args:type_name -> productv1.RequireStorageMultiFilteredTagSummaryByIdArgs - 27, // 293: productv1.RequireStorageMultiFilteredTagSummaryByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey - 341, // 294: productv1.RequireStorageMultiFilteredTagSummaryByIdContext.fields:type_name -> productv1.RequireStorageMultiFilteredTagSummaryByIdFields - 340, // 295: productv1.RequireStorageMultiFilteredTagSummaryByIdResponse.result:type_name -> productv1.RequireStorageMultiFilteredTagSummaryByIdResult - 484, // 296: productv1.RequireStorageMultiFilteredTagSummaryByIdResult.multi_filtered_tag_summary:type_name -> google.protobuf.StringValue - 343, // 297: productv1.RequireStorageNullableFilteredTagSummaryByIdRequest.context:type_name -> productv1.RequireStorageNullableFilteredTagSummaryByIdContext - 344, // 298: productv1.RequireStorageNullableFilteredTagSummaryByIdRequest.field_args:type_name -> productv1.RequireStorageNullableFilteredTagSummaryByIdArgs - 27, // 299: productv1.RequireStorageNullableFilteredTagSummaryByIdContext.key:type_name -> productv1.LookupStorageByIdRequestKey - 347, // 300: productv1.RequireStorageNullableFilteredTagSummaryByIdContext.fields:type_name -> productv1.RequireStorageNullableFilteredTagSummaryByIdFields - 484, // 301: productv1.RequireStorageNullableFilteredTagSummaryByIdArgs.prefix:type_name -> google.protobuf.StringValue - 346, // 302: productv1.RequireStorageNullableFilteredTagSummaryByIdResponse.result:type_name -> productv1.RequireStorageNullableFilteredTagSummaryByIdResult - 484, // 303: productv1.RequireStorageNullableFilteredTagSummaryByIdResult.nullable_filtered_tag_summary:type_name -> google.protobuf.StringValue - 349, // 304: productv1.RequireWarehouseStockHealthScoreByIdRequest.context:type_name -> productv1.RequireWarehouseStockHealthScoreByIdContext - 30, // 305: productv1.RequireWarehouseStockHealthScoreByIdContext.key:type_name -> productv1.LookupWarehouseByIdRequestKey - 352, // 306: productv1.RequireWarehouseStockHealthScoreByIdContext.fields:type_name -> productv1.RequireWarehouseStockHealthScoreByIdFields - 351, // 307: productv1.RequireWarehouseStockHealthScoreByIdResponse.result:type_name -> productv1.RequireWarehouseStockHealthScoreByIdResult - 481, // 308: productv1.RequireWarehouseStockHealthScoreByIdFields.restock_data:type_name -> productv1.RequireWarehouseStockHealthScoreByIdFields.RestockData - 389, // 309: productv1.NestedTypeA.b:type_name -> productv1.NestedTypeB - 358, // 310: productv1.RecursiveType.recursive_type:type_name -> productv1.RecursiveType - 391, // 311: productv1.ComplexFilterTypeInput.filter:type_name -> productv1.FilterType - 393, // 312: productv1.OrderInput.lines:type_name -> productv1.OrderLineInput - 17, // 313: productv1.Order.order_lines:type_name -> productv1.ListOfOrderLine - 0, // 314: productv1.Category.kind:type_name -> productv1.CategoryKind - 21, // 315: productv1.Category.subcategories:type_name -> productv1.ListOfSubcategory - 396, // 316: productv1.Category.null_metrics:type_name -> productv1.CategoryMetrics - 0, // 317: productv1.CategoryFilter.category:type_name -> productv1.CategoryKind - 392, // 318: productv1.CategoryFilter.pagination:type_name -> productv1.Pagination - 397, // 319: productv1.Animal.cat:type_name -> productv1.Cat - 398, // 320: productv1.Animal.dog:type_name -> productv1.Dog - 482, // 321: productv1.SearchInput.limit:type_name -> google.protobuf.Int32Value - 353, // 322: productv1.SearchResult.product:type_name -> productv1.Product - 356, // 323: productv1.SearchResult.user:type_name -> productv1.User - 365, // 324: productv1.SearchResult.category:type_name -> productv1.Category - 484, // 325: productv1.NullableFieldsType.optional_string:type_name -> google.protobuf.StringValue - 482, // 326: productv1.NullableFieldsType.optional_int:type_name -> google.protobuf.Int32Value - 485, // 327: productv1.NullableFieldsType.optional_float:type_name -> google.protobuf.DoubleValue - 483, // 328: productv1.NullableFieldsType.optional_boolean:type_name -> google.protobuf.BoolValue - 484, // 329: productv1.NullableFieldsFilter.name:type_name -> google.protobuf.StringValue - 484, // 330: productv1.NullableFieldsFilter.optional_string:type_name -> google.protobuf.StringValue - 483, // 331: productv1.NullableFieldsFilter.include_nulls:type_name -> google.protobuf.BoolValue - 20, // 332: productv1.BlogPost.optional_tags:type_name -> productv1.ListOfString - 20, // 333: productv1.BlogPost.keywords:type_name -> productv1.ListOfString - 11, // 334: productv1.BlogPost.ratings:type_name -> productv1.ListOfFloat - 7, // 335: productv1.BlogPost.is_published:type_name -> productv1.ListOfBoolean - 14, // 336: productv1.BlogPost.tag_groups:type_name -> productv1.ListOfListOfString - 14, // 337: productv1.BlogPost.related_topics:type_name -> productv1.ListOfListOfString - 14, // 338: productv1.BlogPost.comment_threads:type_name -> productv1.ListOfListOfString - 14, // 339: productv1.BlogPost.suggestions:type_name -> productv1.ListOfListOfString - 365, // 340: productv1.BlogPost.related_categories:type_name -> productv1.Category - 356, // 341: productv1.BlogPost.contributors:type_name -> productv1.User - 18, // 342: productv1.BlogPost.mentioned_products:type_name -> productv1.ListOfProduct - 22, // 343: productv1.BlogPost.mentioned_users:type_name -> productv1.ListOfUser - 12, // 344: productv1.BlogPost.category_groups:type_name -> productv1.ListOfListOfCategory - 15, // 345: productv1.BlogPost.contributor_teams:type_name -> productv1.ListOfListOfUser - 484, // 346: productv1.BlogPostFilter.title:type_name -> google.protobuf.StringValue - 483, // 347: productv1.BlogPostFilter.has_categories:type_name -> google.protobuf.BoolValue - 482, // 348: productv1.BlogPostFilter.min_tags:type_name -> google.protobuf.Int32Value - 484, // 349: productv1.Author.email:type_name -> google.protobuf.StringValue - 20, // 350: productv1.Author.social_links:type_name -> productv1.ListOfString - 14, // 351: productv1.Author.teams_by_project:type_name -> productv1.ListOfListOfString - 14, // 352: productv1.Author.collaborations:type_name -> productv1.ListOfListOfString - 4, // 353: productv1.Author.written_posts:type_name -> productv1.ListOfBlogPost - 365, // 354: productv1.Author.favorite_categories:type_name -> productv1.Category - 22, // 355: productv1.Author.related_authors:type_name -> productv1.ListOfUser - 18, // 356: productv1.Author.product_reviews:type_name -> productv1.ListOfProduct - 15, // 357: productv1.Author.author_groups:type_name -> productv1.ListOfListOfUser - 12, // 358: productv1.Author.category_preferences:type_name -> productv1.ListOfListOfCategory - 15, // 359: productv1.Author.project_teams:type_name -> productv1.ListOfListOfUser - 484, // 360: productv1.AuthorFilter.name:type_name -> google.protobuf.StringValue - 483, // 361: productv1.AuthorFilter.has_teams:type_name -> google.protobuf.BoolValue - 482, // 362: productv1.AuthorFilter.skill_count:type_name -> google.protobuf.Int32Value - 484, // 363: productv1.TestContainer.description:type_name -> google.protobuf.StringValue - 10, // 364: productv1.ConditionsInput.and:type_name -> productv1.ListOfConditionsInput - 10, // 365: productv1.ConditionsInput.or:type_name -> productv1.ListOfConditionsInput - 484, // 366: productv1.ConditionsInput.key:type_name -> google.protobuf.StringValue - 484, // 367: productv1.ConditionsInput.value:type_name -> google.protobuf.StringValue - 416, // 368: productv1.ActionResult.action_success:type_name -> productv1.ActionSuccess - 417, // 369: productv1.ActionResult.action_error:type_name -> productv1.ActionError - 484, // 370: productv1.NullableFieldsInput.optional_string:type_name -> google.protobuf.StringValue - 482, // 371: productv1.NullableFieldsInput.optional_int:type_name -> google.protobuf.Int32Value - 485, // 372: productv1.NullableFieldsInput.optional_float:type_name -> google.protobuf.DoubleValue - 483, // 373: productv1.NullableFieldsInput.optional_boolean:type_name -> google.protobuf.BoolValue - 20, // 374: productv1.BlogPostInput.optional_tags:type_name -> productv1.ListOfString - 20, // 375: productv1.BlogPostInput.keywords:type_name -> productv1.ListOfString - 11, // 376: productv1.BlogPostInput.ratings:type_name -> productv1.ListOfFloat - 7, // 377: productv1.BlogPostInput.is_published:type_name -> productv1.ListOfBoolean - 14, // 378: productv1.BlogPostInput.tag_groups:type_name -> productv1.ListOfListOfString - 14, // 379: productv1.BlogPostInput.related_topics:type_name -> productv1.ListOfListOfString - 14, // 380: productv1.BlogPostInput.comment_threads:type_name -> productv1.ListOfListOfString - 14, // 381: productv1.BlogPostInput.suggestions:type_name -> productv1.ListOfListOfString - 9, // 382: productv1.BlogPostInput.related_categories:type_name -> productv1.ListOfCategoryInput - 23, // 383: productv1.BlogPostInput.contributors:type_name -> productv1.ListOfUserInput - 13, // 384: productv1.BlogPostInput.category_groups:type_name -> productv1.ListOfListOfCategoryInput - 484, // 385: productv1.AuthorInput.email:type_name -> google.protobuf.StringValue - 20, // 386: productv1.AuthorInput.social_links:type_name -> productv1.ListOfString - 14, // 387: productv1.AuthorInput.teams_by_project:type_name -> productv1.ListOfListOfString - 14, // 388: productv1.AuthorInput.collaborations:type_name -> productv1.ListOfListOfString - 419, // 389: productv1.AuthorInput.favorite_categories:type_name -> productv1.CategoryInput - 16, // 390: productv1.AuthorInput.author_groups:type_name -> productv1.ListOfListOfUserInput - 16, // 391: productv1.AuthorInput.project_teams:type_name -> productv1.ListOfListOfUserInput - 381, // 392: productv1.ProductDetails.review_summary:type_name -> productv1.ActionResult - 367, // 393: productv1.ProductDetails.recommended_pet:type_name -> productv1.Animal - 0, // 394: productv1.StorageCategoryInfo.kind:type_name -> productv1.CategoryKind - 390, // 395: productv1.NestedTypeB.c:type_name -> productv1.NestedTypeC - 392, // 396: productv1.FilterType.pagination:type_name -> productv1.Pagination - 20, // 397: productv1.OrderLineInput.modifiers:type_name -> productv1.ListOfString - 20, // 398: productv1.OrderLine.modifiers:type_name -> productv1.ListOfString - 484, // 399: productv1.Subcategory.description:type_name -> google.protobuf.StringValue - 399, // 400: productv1.Cat.owner:type_name -> productv1.Owner - 402, // 401: productv1.Cat.breed:type_name -> productv1.CatBreed - 399, // 402: productv1.Dog.owner:type_name -> productv1.Owner - 403, // 403: productv1.Dog.breed:type_name -> productv1.DogBreed - 400, // 404: productv1.Owner.contact:type_name -> productv1.ContactInfo - 367, // 405: productv1.Owner.pet:type_name -> productv1.Animal - 401, // 406: productv1.ContactInfo.address:type_name -> productv1.Address - 404, // 407: productv1.CatBreed.characteristics:type_name -> productv1.BreedCharacteristics - 404, // 408: productv1.DogBreed.characteristics:type_name -> productv1.BreedCharacteristics - 406, // 409: productv1.StorageItem.pallet_item:type_name -> productv1.PalletItem - 407, // 410: productv1.StorageItem.container_item:type_name -> productv1.ContainerItem - 408, // 411: productv1.PalletItem.handler:type_name -> productv1.ItemHandler - 409, // 412: productv1.PalletItem.specs:type_name -> productv1.PalletSpecs - 408, // 413: productv1.ContainerItem.handler:type_name -> productv1.ItemHandler - 410, // 414: productv1.ContainerItem.specs:type_name -> productv1.ContainerSpecs - 405, // 415: productv1.ItemHandler.assigned_item:type_name -> productv1.StorageItem - 411, // 416: productv1.PalletSpecs.dimensions:type_name -> productv1.Dimensions - 411, // 417: productv1.ContainerSpecs.dimensions:type_name -> productv1.Dimensions - 413, // 418: productv1.StorageOperationResult.storage_success:type_name -> productv1.StorageSuccess - 414, // 419: productv1.StorageOperationResult.storage_failure:type_name -> productv1.StorageFailure - 405, // 420: productv1.SecuritySetup.primary_item:type_name -> productv1.StorageItem - 367, // 421: productv1.TestDetails.pet:type_name -> productv1.Animal - 381, // 422: productv1.TestDetails.status:type_name -> productv1.ActionResult - 0, // 423: productv1.CategoryInput.kind:type_name -> productv1.CategoryKind - 485, // 424: productv1.ProductCountFilter.min_price:type_name -> google.protobuf.DoubleValue - 485, // 425: productv1.ProductCountFilter.max_price:type_name -> google.protobuf.DoubleValue - 483, // 426: productv1.ProductCountFilter.in_stock:type_name -> google.protobuf.BoolValue - 484, // 427: productv1.ProductCountFilter.search_term:type_name -> google.protobuf.StringValue - 485, // 428: productv1.SubcategoryItemFilter.min_price:type_name -> google.protobuf.DoubleValue - 485, // 429: productv1.SubcategoryItemFilter.max_price:type_name -> google.protobuf.DoubleValue - 483, // 430: productv1.SubcategoryItemFilter.in_stock:type_name -> google.protobuf.BoolValue - 483, // 431: productv1.SubcategoryItemFilter.is_active:type_name -> google.protobuf.BoolValue - 484, // 432: productv1.SubcategoryItemFilter.search_term:type_name -> google.protobuf.StringValue - 1, // 433: productv1.ShippingEstimateInput.destination:type_name -> productv1.ShippingDestination - 483, // 434: productv1.ShippingEstimateInput.expedited:type_name -> google.protobuf.BoolValue - 375, // 435: productv1.ListOfAuthorFilter.List.items:type_name -> productv1.AuthorFilter - 384, // 436: productv1.ListOfAuthorInput.List.items:type_name -> productv1.AuthorInput - 372, // 437: productv1.ListOfBlogPost.List.items:type_name -> productv1.BlogPost - 373, // 438: productv1.ListOfBlogPostFilter.List.items:type_name -> productv1.BlogPostFilter - 383, // 439: productv1.ListOfBlogPostInput.List.items:type_name -> productv1.BlogPostInput - 365, // 440: productv1.ListOfCategory.List.items:type_name -> productv1.Category - 419, // 441: productv1.ListOfCategoryInput.List.items:type_name -> productv1.CategoryInput - 377, // 442: productv1.ListOfConditionsInput.List.items:type_name -> productv1.ConditionsInput - 8, // 443: productv1.ListOfListOfCategory.List.items:type_name -> productv1.ListOfCategory - 9, // 444: productv1.ListOfListOfCategoryInput.List.items:type_name -> productv1.ListOfCategoryInput - 20, // 445: productv1.ListOfListOfString.List.items:type_name -> productv1.ListOfString - 22, // 446: productv1.ListOfListOfUser.List.items:type_name -> productv1.ListOfUser - 23, // 447: productv1.ListOfListOfUserInput.List.items:type_name -> productv1.ListOfUserInput - 394, // 448: productv1.ListOfOrderLine.List.items:type_name -> productv1.OrderLine - 353, // 449: productv1.ListOfProduct.List.items:type_name -> productv1.Product - 354, // 450: productv1.ListOfStorage.List.items:type_name -> productv1.Storage - 395, // 451: productv1.ListOfSubcategory.List.items:type_name -> productv1.Subcategory - 356, // 452: productv1.ListOfUser.List.items:type_name -> productv1.User - 379, // 453: productv1.ListOfUserInput.List.items:type_name -> productv1.UserInput - 0, // 454: productv1.RequireStorageCategoryInfoSummaryByIdFields.StorageCategoryInfo.kind:type_name -> productv1.CategoryKind - 452, // 455: productv1.RequireStorageItemInfoByIdFields.StorageItem.container_item:type_name -> productv1.RequireStorageItemInfoByIdFields.ContainerItem - 451, // 456: productv1.RequireStorageItemInfoByIdFields.StorageItem.pallet_item:type_name -> productv1.RequireStorageItemInfoByIdFields.PalletItem - 455, // 457: productv1.RequireStorageOperationReportByIdFields.StorageOperationResult.storage_failure:type_name -> productv1.RequireStorageOperationReportByIdFields.StorageFailure - 454, // 458: productv1.RequireStorageOperationReportByIdFields.StorageOperationResult.storage_success:type_name -> productv1.RequireStorageOperationReportByIdFields.StorageSuccess - 460, // 459: productv1.RequireStorageSecuritySummaryByIdFields.SecuritySetup.primary_item:type_name -> productv1.RequireStorageSecuritySummaryByIdFields.SecuritySetup.StorageItem - 459, // 460: productv1.RequireStorageSecuritySummaryByIdFields.SecuritySetup.StorageItem.container_item:type_name -> productv1.RequireStorageSecuritySummaryByIdFields.SecuritySetup.ContainerItem - 458, // 461: productv1.RequireStorageSecuritySummaryByIdFields.SecuritySetup.StorageItem.pallet_item:type_name -> productv1.RequireStorageSecuritySummaryByIdFields.SecuritySetup.PalletItem - 464, // 462: productv1.RequireStorageItemHandlerInfoByIdFields.PalletItem.handler:type_name -> productv1.RequireStorageItemHandlerInfoByIdFields.PalletItem.ItemHandler - 465, // 463: productv1.RequireStorageItemHandlerInfoByIdFields.ContainerItem.handler:type_name -> productv1.RequireStorageItemHandlerInfoByIdFields.ContainerItem.ItemHandler - 462, // 464: productv1.RequireStorageItemHandlerInfoByIdFields.StorageItem.container_item:type_name -> productv1.RequireStorageItemHandlerInfoByIdFields.ContainerItem - 461, // 465: productv1.RequireStorageItemHandlerInfoByIdFields.StorageItem.pallet_item:type_name -> productv1.RequireStorageItemHandlerInfoByIdFields.PalletItem - 469, // 466: productv1.RequireStorageItemSpecsInfoByIdFields.PalletItem.specs:type_name -> productv1.RequireStorageItemSpecsInfoByIdFields.PalletItem.PalletSpecs - 471, // 467: productv1.RequireStorageItemSpecsInfoByIdFields.ContainerItem.specs:type_name -> productv1.RequireStorageItemSpecsInfoByIdFields.ContainerItem.ContainerSpecs - 467, // 468: productv1.RequireStorageItemSpecsInfoByIdFields.StorageItem.container_item:type_name -> productv1.RequireStorageItemSpecsInfoByIdFields.ContainerItem - 466, // 469: productv1.RequireStorageItemSpecsInfoByIdFields.StorageItem.pallet_item:type_name -> productv1.RequireStorageItemSpecsInfoByIdFields.PalletItem - 470, // 470: productv1.RequireStorageItemSpecsInfoByIdFields.PalletItem.PalletSpecs.dimensions:type_name -> productv1.RequireStorageItemSpecsInfoByIdFields.PalletItem.PalletSpecs.Dimensions - 472, // 471: productv1.RequireStorageItemSpecsInfoByIdFields.ContainerItem.ContainerSpecs.dimensions:type_name -> productv1.RequireStorageItemSpecsInfoByIdFields.ContainerItem.ContainerSpecs.Dimensions - 476, // 472: productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.handler:type_name -> productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.ItemHandler - 480, // 473: productv1.RequireStorageDeepItemInfoByIdFields.ContainerItem.handler:type_name -> productv1.RequireStorageDeepItemInfoByIdFields.ContainerItem.ItemHandler - 474, // 474: productv1.RequireStorageDeepItemInfoByIdFields.StorageItem.container_item:type_name -> productv1.RequireStorageDeepItemInfoByIdFields.ContainerItem - 473, // 475: productv1.RequireStorageDeepItemInfoByIdFields.StorageItem.pallet_item:type_name -> productv1.RequireStorageDeepItemInfoByIdFields.PalletItem - 479, // 476: productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.ItemHandler.assigned_item:type_name -> productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.ItemHandler.StorageItem - 477, // 477: productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.ItemHandler.StorageItem.container_item:type_name -> productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.ItemHandler.ContainerItem - 478, // 478: productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.ItemHandler.StorageItem.pallet_item:type_name -> productv1.RequireStorageDeepItemInfoByIdFields.PalletItem.ItemHandler.PalletItem - 25, // 479: productv1.ProductService.LookupProductById:input_type -> productv1.LookupProductByIdRequest - 28, // 480: productv1.ProductService.LookupStorageById:input_type -> productv1.LookupStorageByIdRequest - 31, // 481: productv1.ProductService.LookupWarehouseById:input_type -> productv1.LookupWarehouseByIdRequest - 117, // 482: productv1.ProductService.MutationBulkCreateAuthors:input_type -> productv1.MutationBulkCreateAuthorsRequest - 121, // 483: productv1.ProductService.MutationBulkCreateBlogPosts:input_type -> productv1.MutationBulkCreateBlogPostsRequest - 119, // 484: productv1.ProductService.MutationBulkUpdateAuthors:input_type -> productv1.MutationBulkUpdateAuthorsRequest - 123, // 485: productv1.ProductService.MutationBulkUpdateBlogPosts:input_type -> productv1.MutationBulkUpdateBlogPostsRequest - 113, // 486: productv1.ProductService.MutationCreateAuthor:input_type -> productv1.MutationCreateAuthorRequest - 109, // 487: productv1.ProductService.MutationCreateBlogPost:input_type -> productv1.MutationCreateBlogPostRequest - 105, // 488: productv1.ProductService.MutationCreateNullableFieldsType:input_type -> productv1.MutationCreateNullableFieldsTypeRequest - 101, // 489: productv1.ProductService.MutationCreateUser:input_type -> productv1.MutationCreateUserRequest - 103, // 490: productv1.ProductService.MutationPerformAction:input_type -> productv1.MutationPerformActionRequest - 115, // 491: productv1.ProductService.MutationUpdateAuthor:input_type -> productv1.MutationUpdateAuthorRequest - 111, // 492: productv1.ProductService.MutationUpdateBlogPost:input_type -> productv1.MutationUpdateBlogPostRequest - 107, // 493: productv1.ProductService.MutationUpdateNullableFieldsType:input_type -> productv1.MutationUpdateNullableFieldsTypeRequest - 89, // 494: productv1.ProductService.QueryAllAuthors:input_type -> productv1.QueryAllAuthorsRequest - 81, // 495: productv1.ProductService.QueryAllBlogPosts:input_type -> productv1.QueryAllBlogPostsRequest - 73, // 496: productv1.ProductService.QueryAllNullableFieldsTypes:input_type -> productv1.QueryAllNullableFieldsTypesRequest - 61, // 497: productv1.ProductService.QueryAllPets:input_type -> productv1.QueryAllPetsRequest - 83, // 498: productv1.ProductService.QueryAuthor:input_type -> productv1.QueryAuthorRequest - 85, // 499: productv1.ProductService.QueryAuthorById:input_type -> productv1.QueryAuthorByIdRequest - 87, // 500: productv1.ProductService.QueryAuthorsWithFilter:input_type -> productv1.QueryAuthorsWithFilterRequest - 75, // 501: productv1.ProductService.QueryBlogPost:input_type -> productv1.QueryBlogPostRequest - 77, // 502: productv1.ProductService.QueryBlogPostById:input_type -> productv1.QueryBlogPostByIdRequest - 79, // 503: productv1.ProductService.QueryBlogPostsWithFilter:input_type -> productv1.QueryBlogPostsWithFilterRequest - 91, // 504: productv1.ProductService.QueryBulkSearchAuthors:input_type -> productv1.QueryBulkSearchAuthorsRequest - 93, // 505: productv1.ProductService.QueryBulkSearchBlogPosts:input_type -> productv1.QueryBulkSearchBlogPostsRequest - 47, // 506: productv1.ProductService.QueryCalculateTotals:input_type -> productv1.QueryCalculateTotalsRequest - 49, // 507: productv1.ProductService.QueryCategories:input_type -> productv1.QueryCategoriesRequest - 53, // 508: productv1.ProductService.QueryCategoriesByKind:input_type -> productv1.QueryCategoriesByKindRequest - 55, // 509: productv1.ProductService.QueryCategoriesByKinds:input_type -> productv1.QueryCategoriesByKindsRequest - 51, // 510: productv1.ProductService.QueryCategory:input_type -> productv1.QueryCategoryRequest - 45, // 511: productv1.ProductService.QueryComplexFilterType:input_type -> productv1.QueryComplexFilterTypeRequest - 99, // 512: productv1.ProductService.QueryConditionalSearch:input_type -> productv1.QueryConditionalSearchRequest - 57, // 513: productv1.ProductService.QueryFilterCategories:input_type -> productv1.QueryFilterCategoriesRequest - 37, // 514: productv1.ProductService.QueryNestedType:input_type -> productv1.QueryNestedTypeRequest - 67, // 515: productv1.ProductService.QueryNullableFieldsType:input_type -> productv1.QueryNullableFieldsTypeRequest - 69, // 516: productv1.ProductService.QueryNullableFieldsTypeById:input_type -> productv1.QueryNullableFieldsTypeByIdRequest - 71, // 517: productv1.ProductService.QueryNullableFieldsTypeWithFilter:input_type -> productv1.QueryNullableFieldsTypeWithFilterRequest - 59, // 518: productv1.ProductService.QueryRandomPet:input_type -> productv1.QueryRandomPetRequest - 65, // 519: productv1.ProductService.QueryRandomSearchResult:input_type -> productv1.QueryRandomSearchResultRequest - 39, // 520: productv1.ProductService.QueryRecursiveType:input_type -> productv1.QueryRecursiveTypeRequest - 63, // 521: productv1.ProductService.QuerySearch:input_type -> productv1.QuerySearchRequest - 95, // 522: productv1.ProductService.QueryTestContainer:input_type -> productv1.QueryTestContainerRequest - 97, // 523: productv1.ProductService.QueryTestContainers:input_type -> productv1.QueryTestContainersRequest - 41, // 524: productv1.ProductService.QueryTypeFilterWithArguments:input_type -> productv1.QueryTypeFilterWithArgumentsRequest - 43, // 525: productv1.ProductService.QueryTypeWithMultipleFilterFields:input_type -> productv1.QueryTypeWithMultipleFilterFieldsRequest - 35, // 526: productv1.ProductService.QueryUser:input_type -> productv1.QueryUserRequest - 33, // 527: productv1.ProductService.QueryUsers:input_type -> productv1.QueryUsersRequest - 295, // 528: productv1.ProductService.RequireStorageCategoryInfoSummaryById:input_type -> productv1.RequireStorageCategoryInfoSummaryByIdRequest - 325, // 529: productv1.ProductService.RequireStorageDeepItemInfoById:input_type -> productv1.RequireStorageDeepItemInfoByIdRequest - 330, // 530: productv1.ProductService.RequireStorageFilteredTagSummaryById:input_type -> productv1.RequireStorageFilteredTagSummaryByIdRequest - 315, // 531: productv1.ProductService.RequireStorageItemHandlerInfoById:input_type -> productv1.RequireStorageItemHandlerInfoByIdRequest - 300, // 532: productv1.ProductService.RequireStorageItemInfoById:input_type -> productv1.RequireStorageItemInfoByIdRequest - 320, // 533: productv1.ProductService.RequireStorageItemSpecsInfoById:input_type -> productv1.RequireStorageItemSpecsInfoByIdRequest - 290, // 534: productv1.ProductService.RequireStorageKindSummaryById:input_type -> productv1.RequireStorageKindSummaryByIdRequest - 260, // 535: productv1.ProductService.RequireStorageMetadataScoreById:input_type -> productv1.RequireStorageMetadataScoreByIdRequest - 336, // 536: productv1.ProductService.RequireStorageMultiFilteredTagSummaryById:input_type -> productv1.RequireStorageMultiFilteredTagSummaryByIdRequest - 342, // 537: productv1.ProductService.RequireStorageNullableFilteredTagSummaryById:input_type -> productv1.RequireStorageNullableFilteredTagSummaryByIdRequest - 305, // 538: productv1.ProductService.RequireStorageOperationReportById:input_type -> productv1.RequireStorageOperationReportByIdRequest - 270, // 539: productv1.ProductService.RequireStorageOptionalProcessedMetadataById:input_type -> productv1.RequireStorageOptionalProcessedMetadataByIdRequest - 280, // 540: productv1.ProductService.RequireStorageOptionalProcessedTagsById:input_type -> productv1.RequireStorageOptionalProcessedTagsByIdRequest - 255, // 541: productv1.ProductService.RequireStorageOptionalTagSummaryById:input_type -> productv1.RequireStorageOptionalTagSummaryByIdRequest - 265, // 542: productv1.ProductService.RequireStorageProcessedMetadataById:input_type -> productv1.RequireStorageProcessedMetadataByIdRequest - 285, // 543: productv1.ProductService.RequireStorageProcessedMetadataHistoryById:input_type -> productv1.RequireStorageProcessedMetadataHistoryByIdRequest - 275, // 544: productv1.ProductService.RequireStorageProcessedTagsById:input_type -> productv1.RequireStorageProcessedTagsByIdRequest - 310, // 545: productv1.ProductService.RequireStorageSecuritySummaryById:input_type -> productv1.RequireStorageSecuritySummaryByIdRequest - 245, // 546: productv1.ProductService.RequireStorageStockHealthScoreById:input_type -> productv1.RequireStorageStockHealthScoreByIdRequest - 250, // 547: productv1.ProductService.RequireStorageTagSummaryById:input_type -> productv1.RequireStorageTagSummaryByIdRequest - 348, // 548: productv1.ProductService.RequireWarehouseStockHealthScoreById:input_type -> productv1.RequireWarehouseStockHealthScoreByIdRequest - 209, // 549: productv1.ProductService.ResolveCategoryActiveSubcategories:input_type -> productv1.ResolveCategoryActiveSubcategoriesRequest - 177, // 550: productv1.ProductService.ResolveCategoryCategoryMetrics:input_type -> productv1.ResolveCategoryCategoryMetricsRequest - 187, // 551: productv1.ProductService.ResolveCategoryCategoryStatus:input_type -> productv1.ResolveCategoryCategoryStatusRequest - 192, // 552: productv1.ProductService.ResolveCategoryChildCategories:input_type -> productv1.ResolveCategoryChildCategoriesRequest - 182, // 553: productv1.ProductService.ResolveCategoryMascot:input_type -> productv1.ResolveCategoryMascotRequest - 237, // 554: productv1.ProductService.ResolveCategoryMetricsAverageScore:input_type -> productv1.ResolveCategoryMetricsAverageScoreRequest - 228, // 555: productv1.ProductService.ResolveCategoryMetricsNormalizedScore:input_type -> productv1.ResolveCategoryMetricsNormalizedScoreRequest - 233, // 556: productv1.ProductService.ResolveCategoryMetricsRelatedCategory:input_type -> productv1.ResolveCategoryMetricsRelatedCategoryRequest - 197, // 557: productv1.ProductService.ResolveCategoryOptionalCategories:input_type -> productv1.ResolveCategoryOptionalCategoriesRequest - 172, // 558: productv1.ProductService.ResolveCategoryPopularityScore:input_type -> productv1.ResolveCategoryPopularityScoreRequest - 167, // 559: productv1.ProductService.ResolveCategoryProductCount:input_type -> productv1.ResolveCategoryProductCountRequest - 205, // 560: productv1.ProductService.ResolveCategoryTopSubcategory:input_type -> productv1.ResolveCategoryTopSubcategoryRequest - 201, // 561: productv1.ProductService.ResolveCategoryTotalProducts:input_type -> productv1.ResolveCategoryTotalProductsRequest - 137, // 562: productv1.ProductService.ResolveProductMascotRecommendation:input_type -> productv1.ResolveProductMascotRecommendationRequest - 147, // 563: productv1.ProductService.ResolveProductProductDetails:input_type -> productv1.ResolveProductProductDetailsRequest - 132, // 564: productv1.ProductService.ResolveProductRecommendedCategory:input_type -> productv1.ResolveProductRecommendedCategoryRequest - 127, // 565: productv1.ProductService.ResolveProductShippingEstimate:input_type -> productv1.ResolveProductShippingEstimateRequest - 142, // 566: productv1.ProductService.ResolveProductStockStatus:input_type -> productv1.ResolveProductStockStatusRequest - 157, // 567: productv1.ProductService.ResolveStorageLinkedStorages:input_type -> productv1.ResolveStorageLinkedStoragesRequest - 162, // 568: productv1.ProductService.ResolveStorageNearbyStorages:input_type -> productv1.ResolveStorageNearbyStoragesRequest - 152, // 569: productv1.ProductService.ResolveStorageStorageStatus:input_type -> productv1.ResolveStorageStorageStatusRequest - 219, // 570: productv1.ProductService.ResolveSubcategoryFeaturedCategory:input_type -> productv1.ResolveSubcategoryFeaturedCategoryRequest - 214, // 571: productv1.ProductService.ResolveSubcategoryItemCount:input_type -> productv1.ResolveSubcategoryItemCountRequest - 223, // 572: productv1.ProductService.ResolveSubcategoryParentCategory:input_type -> productv1.ResolveSubcategoryParentCategoryRequest - 242, // 573: productv1.ProductService.ResolveTestContainerDetails:input_type -> productv1.ResolveTestContainerDetailsRequest - 26, // 574: productv1.ProductService.LookupProductById:output_type -> productv1.LookupProductByIdResponse - 29, // 575: productv1.ProductService.LookupStorageById:output_type -> productv1.LookupStorageByIdResponse - 32, // 576: productv1.ProductService.LookupWarehouseById:output_type -> productv1.LookupWarehouseByIdResponse - 118, // 577: productv1.ProductService.MutationBulkCreateAuthors:output_type -> productv1.MutationBulkCreateAuthorsResponse - 122, // 578: productv1.ProductService.MutationBulkCreateBlogPosts:output_type -> productv1.MutationBulkCreateBlogPostsResponse - 120, // 579: productv1.ProductService.MutationBulkUpdateAuthors:output_type -> productv1.MutationBulkUpdateAuthorsResponse - 124, // 580: productv1.ProductService.MutationBulkUpdateBlogPosts:output_type -> productv1.MutationBulkUpdateBlogPostsResponse - 114, // 581: productv1.ProductService.MutationCreateAuthor:output_type -> productv1.MutationCreateAuthorResponse - 110, // 582: productv1.ProductService.MutationCreateBlogPost:output_type -> productv1.MutationCreateBlogPostResponse - 106, // 583: productv1.ProductService.MutationCreateNullableFieldsType:output_type -> productv1.MutationCreateNullableFieldsTypeResponse - 102, // 584: productv1.ProductService.MutationCreateUser:output_type -> productv1.MutationCreateUserResponse - 104, // 585: productv1.ProductService.MutationPerformAction:output_type -> productv1.MutationPerformActionResponse - 116, // 586: productv1.ProductService.MutationUpdateAuthor:output_type -> productv1.MutationUpdateAuthorResponse - 112, // 587: productv1.ProductService.MutationUpdateBlogPost:output_type -> productv1.MutationUpdateBlogPostResponse - 108, // 588: productv1.ProductService.MutationUpdateNullableFieldsType:output_type -> productv1.MutationUpdateNullableFieldsTypeResponse - 90, // 589: productv1.ProductService.QueryAllAuthors:output_type -> productv1.QueryAllAuthorsResponse - 82, // 590: productv1.ProductService.QueryAllBlogPosts:output_type -> productv1.QueryAllBlogPostsResponse - 74, // 591: productv1.ProductService.QueryAllNullableFieldsTypes:output_type -> productv1.QueryAllNullableFieldsTypesResponse - 62, // 592: productv1.ProductService.QueryAllPets:output_type -> productv1.QueryAllPetsResponse - 84, // 593: productv1.ProductService.QueryAuthor:output_type -> productv1.QueryAuthorResponse - 86, // 594: productv1.ProductService.QueryAuthorById:output_type -> productv1.QueryAuthorByIdResponse - 88, // 595: productv1.ProductService.QueryAuthorsWithFilter:output_type -> productv1.QueryAuthorsWithFilterResponse - 76, // 596: productv1.ProductService.QueryBlogPost:output_type -> productv1.QueryBlogPostResponse - 78, // 597: productv1.ProductService.QueryBlogPostById:output_type -> productv1.QueryBlogPostByIdResponse - 80, // 598: productv1.ProductService.QueryBlogPostsWithFilter:output_type -> productv1.QueryBlogPostsWithFilterResponse - 92, // 599: productv1.ProductService.QueryBulkSearchAuthors:output_type -> productv1.QueryBulkSearchAuthorsResponse - 94, // 600: productv1.ProductService.QueryBulkSearchBlogPosts:output_type -> productv1.QueryBulkSearchBlogPostsResponse - 48, // 601: productv1.ProductService.QueryCalculateTotals:output_type -> productv1.QueryCalculateTotalsResponse - 50, // 602: productv1.ProductService.QueryCategories:output_type -> productv1.QueryCategoriesResponse - 54, // 603: productv1.ProductService.QueryCategoriesByKind:output_type -> productv1.QueryCategoriesByKindResponse - 56, // 604: productv1.ProductService.QueryCategoriesByKinds:output_type -> productv1.QueryCategoriesByKindsResponse - 52, // 605: productv1.ProductService.QueryCategory:output_type -> productv1.QueryCategoryResponse - 46, // 606: productv1.ProductService.QueryComplexFilterType:output_type -> productv1.QueryComplexFilterTypeResponse - 100, // 607: productv1.ProductService.QueryConditionalSearch:output_type -> productv1.QueryConditionalSearchResponse - 58, // 608: productv1.ProductService.QueryFilterCategories:output_type -> productv1.QueryFilterCategoriesResponse - 38, // 609: productv1.ProductService.QueryNestedType:output_type -> productv1.QueryNestedTypeResponse - 68, // 610: productv1.ProductService.QueryNullableFieldsType:output_type -> productv1.QueryNullableFieldsTypeResponse - 70, // 611: productv1.ProductService.QueryNullableFieldsTypeById:output_type -> productv1.QueryNullableFieldsTypeByIdResponse - 72, // 612: productv1.ProductService.QueryNullableFieldsTypeWithFilter:output_type -> productv1.QueryNullableFieldsTypeWithFilterResponse - 60, // 613: productv1.ProductService.QueryRandomPet:output_type -> productv1.QueryRandomPetResponse - 66, // 614: productv1.ProductService.QueryRandomSearchResult:output_type -> productv1.QueryRandomSearchResultResponse - 40, // 615: productv1.ProductService.QueryRecursiveType:output_type -> productv1.QueryRecursiveTypeResponse - 64, // 616: productv1.ProductService.QuerySearch:output_type -> productv1.QuerySearchResponse - 96, // 617: productv1.ProductService.QueryTestContainer:output_type -> productv1.QueryTestContainerResponse - 98, // 618: productv1.ProductService.QueryTestContainers:output_type -> productv1.QueryTestContainersResponse - 42, // 619: productv1.ProductService.QueryTypeFilterWithArguments:output_type -> productv1.QueryTypeFilterWithArgumentsResponse - 44, // 620: productv1.ProductService.QueryTypeWithMultipleFilterFields:output_type -> productv1.QueryTypeWithMultipleFilterFieldsResponse - 36, // 621: productv1.ProductService.QueryUser:output_type -> productv1.QueryUserResponse - 34, // 622: productv1.ProductService.QueryUsers:output_type -> productv1.QueryUsersResponse - 297, // 623: productv1.ProductService.RequireStorageCategoryInfoSummaryById:output_type -> productv1.RequireStorageCategoryInfoSummaryByIdResponse - 327, // 624: productv1.ProductService.RequireStorageDeepItemInfoById:output_type -> productv1.RequireStorageDeepItemInfoByIdResponse - 333, // 625: productv1.ProductService.RequireStorageFilteredTagSummaryById:output_type -> productv1.RequireStorageFilteredTagSummaryByIdResponse - 317, // 626: productv1.ProductService.RequireStorageItemHandlerInfoById:output_type -> productv1.RequireStorageItemHandlerInfoByIdResponse - 302, // 627: productv1.ProductService.RequireStorageItemInfoById:output_type -> productv1.RequireStorageItemInfoByIdResponse - 322, // 628: productv1.ProductService.RequireStorageItemSpecsInfoById:output_type -> productv1.RequireStorageItemSpecsInfoByIdResponse - 292, // 629: productv1.ProductService.RequireStorageKindSummaryById:output_type -> productv1.RequireStorageKindSummaryByIdResponse - 262, // 630: productv1.ProductService.RequireStorageMetadataScoreById:output_type -> productv1.RequireStorageMetadataScoreByIdResponse - 339, // 631: productv1.ProductService.RequireStorageMultiFilteredTagSummaryById:output_type -> productv1.RequireStorageMultiFilteredTagSummaryByIdResponse - 345, // 632: productv1.ProductService.RequireStorageNullableFilteredTagSummaryById:output_type -> productv1.RequireStorageNullableFilteredTagSummaryByIdResponse - 307, // 633: productv1.ProductService.RequireStorageOperationReportById:output_type -> productv1.RequireStorageOperationReportByIdResponse - 272, // 634: productv1.ProductService.RequireStorageOptionalProcessedMetadataById:output_type -> productv1.RequireStorageOptionalProcessedMetadataByIdResponse - 282, // 635: productv1.ProductService.RequireStorageOptionalProcessedTagsById:output_type -> productv1.RequireStorageOptionalProcessedTagsByIdResponse - 257, // 636: productv1.ProductService.RequireStorageOptionalTagSummaryById:output_type -> productv1.RequireStorageOptionalTagSummaryByIdResponse - 267, // 637: productv1.ProductService.RequireStorageProcessedMetadataById:output_type -> productv1.RequireStorageProcessedMetadataByIdResponse - 287, // 638: productv1.ProductService.RequireStorageProcessedMetadataHistoryById:output_type -> productv1.RequireStorageProcessedMetadataHistoryByIdResponse - 277, // 639: productv1.ProductService.RequireStorageProcessedTagsById:output_type -> productv1.RequireStorageProcessedTagsByIdResponse - 312, // 640: productv1.ProductService.RequireStorageSecuritySummaryById:output_type -> productv1.RequireStorageSecuritySummaryByIdResponse - 247, // 641: productv1.ProductService.RequireStorageStockHealthScoreById:output_type -> productv1.RequireStorageStockHealthScoreByIdResponse - 252, // 642: productv1.ProductService.RequireStorageTagSummaryById:output_type -> productv1.RequireStorageTagSummaryByIdResponse - 350, // 643: productv1.ProductService.RequireWarehouseStockHealthScoreById:output_type -> productv1.RequireWarehouseStockHealthScoreByIdResponse - 211, // 644: productv1.ProductService.ResolveCategoryActiveSubcategories:output_type -> productv1.ResolveCategoryActiveSubcategoriesResponse - 179, // 645: productv1.ProductService.ResolveCategoryCategoryMetrics:output_type -> productv1.ResolveCategoryCategoryMetricsResponse - 189, // 646: productv1.ProductService.ResolveCategoryCategoryStatus:output_type -> productv1.ResolveCategoryCategoryStatusResponse - 194, // 647: productv1.ProductService.ResolveCategoryChildCategories:output_type -> productv1.ResolveCategoryChildCategoriesResponse - 184, // 648: productv1.ProductService.ResolveCategoryMascot:output_type -> productv1.ResolveCategoryMascotResponse - 239, // 649: productv1.ProductService.ResolveCategoryMetricsAverageScore:output_type -> productv1.ResolveCategoryMetricsAverageScoreResponse - 230, // 650: productv1.ProductService.ResolveCategoryMetricsNormalizedScore:output_type -> productv1.ResolveCategoryMetricsNormalizedScoreResponse - 235, // 651: productv1.ProductService.ResolveCategoryMetricsRelatedCategory:output_type -> productv1.ResolveCategoryMetricsRelatedCategoryResponse - 199, // 652: productv1.ProductService.ResolveCategoryOptionalCategories:output_type -> productv1.ResolveCategoryOptionalCategoriesResponse - 174, // 653: productv1.ProductService.ResolveCategoryPopularityScore:output_type -> productv1.ResolveCategoryPopularityScoreResponse - 169, // 654: productv1.ProductService.ResolveCategoryProductCount:output_type -> productv1.ResolveCategoryProductCountResponse - 207, // 655: productv1.ProductService.ResolveCategoryTopSubcategory:output_type -> productv1.ResolveCategoryTopSubcategoryResponse - 203, // 656: productv1.ProductService.ResolveCategoryTotalProducts:output_type -> productv1.ResolveCategoryTotalProductsResponse - 139, // 657: productv1.ProductService.ResolveProductMascotRecommendation:output_type -> productv1.ResolveProductMascotRecommendationResponse - 149, // 658: productv1.ProductService.ResolveProductProductDetails:output_type -> productv1.ResolveProductProductDetailsResponse - 134, // 659: productv1.ProductService.ResolveProductRecommendedCategory:output_type -> productv1.ResolveProductRecommendedCategoryResponse - 129, // 660: productv1.ProductService.ResolveProductShippingEstimate:output_type -> productv1.ResolveProductShippingEstimateResponse - 144, // 661: productv1.ProductService.ResolveProductStockStatus:output_type -> productv1.ResolveProductStockStatusResponse - 159, // 662: productv1.ProductService.ResolveStorageLinkedStorages:output_type -> productv1.ResolveStorageLinkedStoragesResponse - 164, // 663: productv1.ProductService.ResolveStorageNearbyStorages:output_type -> productv1.ResolveStorageNearbyStoragesResponse - 154, // 664: productv1.ProductService.ResolveStorageStorageStatus:output_type -> productv1.ResolveStorageStorageStatusResponse - 221, // 665: productv1.ProductService.ResolveSubcategoryFeaturedCategory:output_type -> productv1.ResolveSubcategoryFeaturedCategoryResponse - 216, // 666: productv1.ProductService.ResolveSubcategoryItemCount:output_type -> productv1.ResolveSubcategoryItemCountResponse - 225, // 667: productv1.ProductService.ResolveSubcategoryParentCategory:output_type -> productv1.ResolveSubcategoryParentCategoryResponse - 244, // 668: productv1.ProductService.ResolveTestContainerDetails:output_type -> productv1.ResolveTestContainerDetailsResponse - 574, // [574:669] is the sub-list for method output_type - 479, // [479:574] is the sub-list for method input_type - 479, // [479:479] is the sub-list for extension type_name - 479, // [479:479] is the sub-list for extension extendee - 0, // [0:479] is the sub-list for field type_name + 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 } func init() { file_product_proto_init() } @@ -26873,52 +27948,52 @@ func file_product_proto_init() { if File_product_proto != nil { return } - file_product_proto_msgTypes[365].OneofWrappers = []any{ + file_product_proto_msgTypes[385].OneofWrappers = []any{ (*Animal_Cat)(nil), (*Animal_Dog)(nil), } - file_product_proto_msgTypes[367].OneofWrappers = []any{ + file_product_proto_msgTypes[387].OneofWrappers = []any{ (*SearchResult_Product)(nil), (*SearchResult_User)(nil), (*SearchResult_Category)(nil), } - file_product_proto_msgTypes[379].OneofWrappers = []any{ + file_product_proto_msgTypes[399].OneofWrappers = []any{ (*ActionResult_ActionSuccess)(nil), (*ActionResult_ActionError)(nil), } - file_product_proto_msgTypes[403].OneofWrappers = []any{ + file_product_proto_msgTypes[423].OneofWrappers = []any{ (*StorageItem_PalletItem)(nil), (*StorageItem_ContainerItem)(nil), } - file_product_proto_msgTypes[410].OneofWrappers = []any{ + file_product_proto_msgTypes[430].OneofWrappers = []any{ (*StorageOperationResult_StorageSuccess)(nil), (*StorageOperationResult_StorageFailure)(nil), } - file_product_proto_msgTypes[451].OneofWrappers = []any{ + file_product_proto_msgTypes[471].OneofWrappers = []any{ (*RequireStorageItemInfoByIdFields_StorageItem_ContainerItem)(nil), (*RequireStorageItemInfoByIdFields_StorageItem_PalletItem)(nil), } - file_product_proto_msgTypes[454].OneofWrappers = []any{ + file_product_proto_msgTypes[474].OneofWrappers = []any{ (*RequireStorageOperationReportByIdFields_StorageOperationResult_StorageFailure)(nil), (*RequireStorageOperationReportByIdFields_StorageOperationResult_StorageSuccess)(nil), } - file_product_proto_msgTypes[458].OneofWrappers = []any{ + file_product_proto_msgTypes[478].OneofWrappers = []any{ (*RequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem_ContainerItem)(nil), (*RequireStorageSecuritySummaryByIdFields_SecuritySetup_StorageItem_PalletItem)(nil), } - file_product_proto_msgTypes[461].OneofWrappers = []any{ + file_product_proto_msgTypes[481].OneofWrappers = []any{ (*RequireStorageItemHandlerInfoByIdFields_StorageItem_ContainerItem)(nil), (*RequireStorageItemHandlerInfoByIdFields_StorageItem_PalletItem)(nil), } - file_product_proto_msgTypes[466].OneofWrappers = []any{ + file_product_proto_msgTypes[486].OneofWrappers = []any{ (*RequireStorageItemSpecsInfoByIdFields_StorageItem_ContainerItem)(nil), (*RequireStorageItemSpecsInfoByIdFields_StorageItem_PalletItem)(nil), } - file_product_proto_msgTypes[473].OneofWrappers = []any{ + file_product_proto_msgTypes[493].OneofWrappers = []any{ (*RequireStorageDeepItemInfoByIdFields_StorageItem_ContainerItem)(nil), (*RequireStorageDeepItemInfoByIdFields_StorageItem_PalletItem)(nil), } - file_product_proto_msgTypes[477].OneofWrappers = []any{ + file_product_proto_msgTypes[497].OneofWrappers = []any{ (*RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem_ContainerItem)(nil), (*RequireStorageDeepItemInfoByIdFields_PalletItem_ItemHandler_StorageItem_PalletItem)(nil), } @@ -26928,7 +28003,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: 480, + NumMessages: 501, 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 b87c967a62..54928947db 100644 --- a/v2/pkg/grpctest/productv1/product_grpc.pb.go +++ b/v2/pkg/grpctest/productv1/product_grpc.pb.go @@ -1,7 +1,7 @@ // Code generated by protoc-gen-go-grpc. DO NOT EDIT. // versions: -// - protoc-gen-go-grpc v1.6.1 -// - protoc v7.34.0 +// - protoc-gen-go-grpc v1.6.2 +// - protoc (unknown) // source: product.proto package productv1 @@ -75,16 +75,20 @@ const ( 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" @@ -181,16 +185,20 @@ type ProductServiceClient interface { RequireStorageItemInfoById(ctx context.Context, in *RequireStorageItemInfoByIdRequest, opts ...grpc.CallOption) (*RequireStorageItemInfoByIdResponse, error) RequireStorageItemSpecsInfoById(ctx context.Context, in *RequireStorageItemSpecsInfoByIdRequest, opts ...grpc.CallOption) (*RequireStorageItemSpecsInfoByIdResponse, error) RequireStorageKindSummaryById(ctx context.Context, in *RequireStorageKindSummaryByIdRequest, opts ...grpc.CallOption) (*RequireStorageKindSummaryByIdResponse, error) + RequireStorageLatestOperationById(ctx context.Context, in *RequireStorageLatestOperationByIdRequest, opts ...grpc.CallOption) (*RequireStorageLatestOperationByIdResponse, error) RequireStorageMetadataScoreById(ctx context.Context, in *RequireStorageMetadataScoreByIdRequest, opts ...grpc.CallOption) (*RequireStorageMetadataScoreByIdResponse, error) RequireStorageMultiFilteredTagSummaryById(ctx context.Context, in *RequireStorageMultiFilteredTagSummaryByIdRequest, opts ...grpc.CallOption) (*RequireStorageMultiFilteredTagSummaryByIdResponse, error) 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) RequireStorageOptionalProcessedMetadataById(ctx context.Context, in *RequireStorageOptionalProcessedMetadataByIdRequest, opts ...grpc.CallOption) (*RequireStorageOptionalProcessedMetadataByIdResponse, error) RequireStorageOptionalProcessedTagsById(ctx context.Context, in *RequireStorageOptionalProcessedTagsByIdRequest, opts ...grpc.CallOption) (*RequireStorageOptionalProcessedTagsByIdResponse, error) RequireStorageOptionalTagSummaryById(ctx context.Context, in *RequireStorageOptionalTagSummaryByIdRequest, opts ...grpc.CallOption) (*RequireStorageOptionalTagSummaryByIdResponse, error) RequireStorageProcessedMetadataById(ctx context.Context, in *RequireStorageProcessedMetadataByIdRequest, opts ...grpc.CallOption) (*RequireStorageProcessedMetadataByIdResponse, error) RequireStorageProcessedMetadataHistoryById(ctx context.Context, in *RequireStorageProcessedMetadataHistoryByIdRequest, opts ...grpc.CallOption) (*RequireStorageProcessedMetadataHistoryByIdResponse, error) RequireStorageProcessedTagsById(ctx context.Context, in *RequireStorageProcessedTagsByIdRequest, opts ...grpc.CallOption) (*RequireStorageProcessedTagsByIdResponse, error) + RequireStorageRecommendedItemById(ctx context.Context, in *RequireStorageRecommendedItemByIdRequest, opts ...grpc.CallOption) (*RequireStorageRecommendedItemByIdResponse, error) + RequireStorageRecommendedItemsById(ctx context.Context, in *RequireStorageRecommendedItemsByIdRequest, opts ...grpc.CallOption) (*RequireStorageRecommendedItemsByIdResponse, error) RequireStorageSecuritySummaryById(ctx context.Context, in *RequireStorageSecuritySummaryByIdRequest, opts ...grpc.CallOption) (*RequireStorageSecuritySummaryByIdResponse, error) RequireStorageStockHealthScoreById(ctx context.Context, in *RequireStorageStockHealthScoreByIdRequest, opts ...grpc.CallOption) (*RequireStorageStockHealthScoreByIdResponse, error) RequireStorageTagSummaryById(ctx context.Context, in *RequireStorageTagSummaryByIdRequest, opts ...grpc.CallOption) (*RequireStorageTagSummaryByIdResponse, error) @@ -790,6 +798,16 @@ func (c *productServiceClient) RequireStorageKindSummaryById(ctx context.Context return out, nil } +func (c *productServiceClient) RequireStorageLatestOperationById(ctx context.Context, in *RequireStorageLatestOperationByIdRequest, opts ...grpc.CallOption) (*RequireStorageLatestOperationByIdResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(RequireStorageLatestOperationByIdResponse) + err := c.cc.Invoke(ctx, ProductService_RequireStorageLatestOperationById_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *productServiceClient) RequireStorageMetadataScoreById(ctx context.Context, in *RequireStorageMetadataScoreByIdRequest, opts ...grpc.CallOption) (*RequireStorageMetadataScoreByIdResponse, error) { cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(RequireStorageMetadataScoreByIdResponse) @@ -830,6 +848,16 @@ func (c *productServiceClient) RequireStorageOperationReportById(ctx context.Con return out, nil } +func (c *productServiceClient) RequireStorageOptionalLatestOperationById(ctx context.Context, in *RequireStorageOptionalLatestOperationByIdRequest, opts ...grpc.CallOption) (*RequireStorageOptionalLatestOperationByIdResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(RequireStorageOptionalLatestOperationByIdResponse) + err := c.cc.Invoke(ctx, ProductService_RequireStorageOptionalLatestOperationById_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) @@ -890,6 +918,26 @@ func (c *productServiceClient) RequireStorageProcessedTagsById(ctx context.Conte return out, nil } +func (c *productServiceClient) RequireStorageRecommendedItemById(ctx context.Context, in *RequireStorageRecommendedItemByIdRequest, opts ...grpc.CallOption) (*RequireStorageRecommendedItemByIdResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(RequireStorageRecommendedItemByIdResponse) + err := c.cc.Invoke(ctx, ProductService_RequireStorageRecommendedItemById_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *productServiceClient) RequireStorageRecommendedItemsById(ctx context.Context, in *RequireStorageRecommendedItemsByIdRequest, opts ...grpc.CallOption) (*RequireStorageRecommendedItemsByIdResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(RequireStorageRecommendedItemsByIdResponse) + err := c.cc.Invoke(ctx, ProductService_RequireStorageRecommendedItemsById_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *productServiceClient) RequireStorageSecuritySummaryById(ctx context.Context, in *RequireStorageSecuritySummaryByIdRequest, opts ...grpc.CallOption) (*RequireStorageSecuritySummaryByIdResponse, error) { cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(RequireStorageSecuritySummaryByIdResponse) @@ -1245,16 +1293,20 @@ type ProductServiceServer interface { RequireStorageItemInfoById(context.Context, *RequireStorageItemInfoByIdRequest) (*RequireStorageItemInfoByIdResponse, error) RequireStorageItemSpecsInfoById(context.Context, *RequireStorageItemSpecsInfoByIdRequest) (*RequireStorageItemSpecsInfoByIdResponse, error) RequireStorageKindSummaryById(context.Context, *RequireStorageKindSummaryByIdRequest) (*RequireStorageKindSummaryByIdResponse, error) + RequireStorageLatestOperationById(context.Context, *RequireStorageLatestOperationByIdRequest) (*RequireStorageLatestOperationByIdResponse, error) RequireStorageMetadataScoreById(context.Context, *RequireStorageMetadataScoreByIdRequest) (*RequireStorageMetadataScoreByIdResponse, error) RequireStorageMultiFilteredTagSummaryById(context.Context, *RequireStorageMultiFilteredTagSummaryByIdRequest) (*RequireStorageMultiFilteredTagSummaryByIdResponse, error) RequireStorageNullableFilteredTagSummaryById(context.Context, *RequireStorageNullableFilteredTagSummaryByIdRequest) (*RequireStorageNullableFilteredTagSummaryByIdResponse, error) RequireStorageOperationReportById(context.Context, *RequireStorageOperationReportByIdRequest) (*RequireStorageOperationReportByIdResponse, error) + RequireStorageOptionalLatestOperationById(context.Context, *RequireStorageOptionalLatestOperationByIdRequest) (*RequireStorageOptionalLatestOperationByIdResponse, error) RequireStorageOptionalProcessedMetadataById(context.Context, *RequireStorageOptionalProcessedMetadataByIdRequest) (*RequireStorageOptionalProcessedMetadataByIdResponse, error) RequireStorageOptionalProcessedTagsById(context.Context, *RequireStorageOptionalProcessedTagsByIdRequest) (*RequireStorageOptionalProcessedTagsByIdResponse, error) RequireStorageOptionalTagSummaryById(context.Context, *RequireStorageOptionalTagSummaryByIdRequest) (*RequireStorageOptionalTagSummaryByIdResponse, error) RequireStorageProcessedMetadataById(context.Context, *RequireStorageProcessedMetadataByIdRequest) (*RequireStorageProcessedMetadataByIdResponse, error) RequireStorageProcessedMetadataHistoryById(context.Context, *RequireStorageProcessedMetadataHistoryByIdRequest) (*RequireStorageProcessedMetadataHistoryByIdResponse, error) RequireStorageProcessedTagsById(context.Context, *RequireStorageProcessedTagsByIdRequest) (*RequireStorageProcessedTagsByIdResponse, error) + RequireStorageRecommendedItemById(context.Context, *RequireStorageRecommendedItemByIdRequest) (*RequireStorageRecommendedItemByIdResponse, error) + RequireStorageRecommendedItemsById(context.Context, *RequireStorageRecommendedItemsByIdRequest) (*RequireStorageRecommendedItemsByIdResponse, error) RequireStorageSecuritySummaryById(context.Context, *RequireStorageSecuritySummaryByIdRequest) (*RequireStorageSecuritySummaryByIdResponse, error) RequireStorageStockHealthScoreById(context.Context, *RequireStorageStockHealthScoreByIdRequest) (*RequireStorageStockHealthScoreByIdResponse, error) RequireStorageTagSummaryById(context.Context, *RequireStorageTagSummaryByIdRequest) (*RequireStorageTagSummaryByIdResponse, error) @@ -1462,6 +1514,9 @@ func (UnimplementedProductServiceServer) RequireStorageItemSpecsInfoById(context func (UnimplementedProductServiceServer) RequireStorageKindSummaryById(context.Context, *RequireStorageKindSummaryByIdRequest) (*RequireStorageKindSummaryByIdResponse, error) { return nil, status.Error(codes.Unimplemented, "method RequireStorageKindSummaryById not implemented") } +func (UnimplementedProductServiceServer) RequireStorageLatestOperationById(context.Context, *RequireStorageLatestOperationByIdRequest) (*RequireStorageLatestOperationByIdResponse, error) { + return nil, status.Error(codes.Unimplemented, "method RequireStorageLatestOperationById not implemented") +} func (UnimplementedProductServiceServer) RequireStorageMetadataScoreById(context.Context, *RequireStorageMetadataScoreByIdRequest) (*RequireStorageMetadataScoreByIdResponse, error) { return nil, status.Error(codes.Unimplemented, "method RequireStorageMetadataScoreById not implemented") } @@ -1474,6 +1529,9 @@ func (UnimplementedProductServiceServer) RequireStorageNullableFilteredTagSummar func (UnimplementedProductServiceServer) RequireStorageOperationReportById(context.Context, *RequireStorageOperationReportByIdRequest) (*RequireStorageOperationReportByIdResponse, error) { return nil, status.Error(codes.Unimplemented, "method RequireStorageOperationReportById not implemented") } +func (UnimplementedProductServiceServer) RequireStorageOptionalLatestOperationById(context.Context, *RequireStorageOptionalLatestOperationByIdRequest) (*RequireStorageOptionalLatestOperationByIdResponse, error) { + return nil, status.Error(codes.Unimplemented, "method RequireStorageOptionalLatestOperationById not implemented") +} func (UnimplementedProductServiceServer) RequireStorageOptionalProcessedMetadataById(context.Context, *RequireStorageOptionalProcessedMetadataByIdRequest) (*RequireStorageOptionalProcessedMetadataByIdResponse, error) { return nil, status.Error(codes.Unimplemented, "method RequireStorageOptionalProcessedMetadataById not implemented") } @@ -1492,6 +1550,12 @@ func (UnimplementedProductServiceServer) RequireStorageProcessedMetadataHistoryB func (UnimplementedProductServiceServer) RequireStorageProcessedTagsById(context.Context, *RequireStorageProcessedTagsByIdRequest) (*RequireStorageProcessedTagsByIdResponse, error) { return nil, status.Error(codes.Unimplemented, "method RequireStorageProcessedTagsById not implemented") } +func (UnimplementedProductServiceServer) RequireStorageRecommendedItemById(context.Context, *RequireStorageRecommendedItemByIdRequest) (*RequireStorageRecommendedItemByIdResponse, error) { + return nil, status.Error(codes.Unimplemented, "method RequireStorageRecommendedItemById not implemented") +} +func (UnimplementedProductServiceServer) RequireStorageRecommendedItemsById(context.Context, *RequireStorageRecommendedItemsByIdRequest) (*RequireStorageRecommendedItemsByIdResponse, error) { + return nil, status.Error(codes.Unimplemented, "method RequireStorageRecommendedItemsById not implemented") +} func (UnimplementedProductServiceServer) RequireStorageSecuritySummaryById(context.Context, *RequireStorageSecuritySummaryByIdRequest) (*RequireStorageSecuritySummaryByIdResponse, error) { return nil, status.Error(codes.Unimplemented, "method RequireStorageSecuritySummaryById not implemented") } @@ -2608,6 +2672,24 @@ func _ProductService_RequireStorageKindSummaryById_Handler(srv interface{}, ctx return interceptor(ctx, in, info, handler) } +func _ProductService_RequireStorageLatestOperationById_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(RequireStorageLatestOperationByIdRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProductServiceServer).RequireStorageLatestOperationById(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ProductService_RequireStorageLatestOperationById_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProductServiceServer).RequireStorageLatestOperationById(ctx, req.(*RequireStorageLatestOperationByIdRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _ProductService_RequireStorageMetadataScoreById_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(RequireStorageMetadataScoreByIdRequest) if err := dec(in); err != nil { @@ -2680,6 +2762,24 @@ func _ProductService_RequireStorageOperationReportById_Handler(srv interface{}, return interceptor(ctx, in, info, handler) } +func _ProductService_RequireStorageOptionalLatestOperationById_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(RequireStorageOptionalLatestOperationByIdRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProductServiceServer).RequireStorageOptionalLatestOperationById(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ProductService_RequireStorageOptionalLatestOperationById_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProductServiceServer).RequireStorageOptionalLatestOperationById(ctx, req.(*RequireStorageOptionalLatestOperationByIdRequest)) + } + 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 { @@ -2788,6 +2888,42 @@ func _ProductService_RequireStorageProcessedTagsById_Handler(srv interface{}, ct return interceptor(ctx, in, info, handler) } +func _ProductService_RequireStorageRecommendedItemById_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(RequireStorageRecommendedItemByIdRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProductServiceServer).RequireStorageRecommendedItemById(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ProductService_RequireStorageRecommendedItemById_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProductServiceServer).RequireStorageRecommendedItemById(ctx, req.(*RequireStorageRecommendedItemByIdRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _ProductService_RequireStorageRecommendedItemsById_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(RequireStorageRecommendedItemsByIdRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProductServiceServer).RequireStorageRecommendedItemsById(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ProductService_RequireStorageRecommendedItemsById_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProductServiceServer).RequireStorageRecommendedItemsById(ctx, req.(*RequireStorageRecommendedItemsByIdRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _ProductService_RequireStorageSecuritySummaryById_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(RequireStorageSecuritySummaryByIdRequest) if err := dec(in); err != nil { @@ -3541,6 +3677,10 @@ var ProductService_ServiceDesc = grpc.ServiceDesc{ MethodName: "RequireStorageKindSummaryById", Handler: _ProductService_RequireStorageKindSummaryById_Handler, }, + { + MethodName: "RequireStorageLatestOperationById", + Handler: _ProductService_RequireStorageLatestOperationById_Handler, + }, { MethodName: "RequireStorageMetadataScoreById", Handler: _ProductService_RequireStorageMetadataScoreById_Handler, @@ -3557,6 +3697,10 @@ var ProductService_ServiceDesc = grpc.ServiceDesc{ MethodName: "RequireStorageOperationReportById", Handler: _ProductService_RequireStorageOperationReportById_Handler, }, + { + MethodName: "RequireStorageOptionalLatestOperationById", + Handler: _ProductService_RequireStorageOptionalLatestOperationById_Handler, + }, { MethodName: "RequireStorageOptionalProcessedMetadataById", Handler: _ProductService_RequireStorageOptionalProcessedMetadataById_Handler, @@ -3581,6 +3725,14 @@ var ProductService_ServiceDesc = grpc.ServiceDesc{ MethodName: "RequireStorageProcessedTagsById", Handler: _ProductService_RequireStorageProcessedTagsById_Handler, }, + { + MethodName: "RequireStorageRecommendedItemById", + Handler: _ProductService_RequireStorageRecommendedItemById_Handler, + }, + { + MethodName: "RequireStorageRecommendedItemsById", + Handler: _ProductService_RequireStorageRecommendedItemsById_Handler, + }, { MethodName: "RequireStorageSecuritySummaryById", Handler: _ProductService_RequireStorageSecuritySummaryById_Handler, diff --git a/v2/pkg/grpctest/productv1/productv1connect/product.connect.go b/v2/pkg/grpctest/productv1/productv1connect/product.connect.go index 752a267a30..54f29f277f 100644 --- a/v2/pkg/grpctest/productv1/productv1connect/product.connect.go +++ b/v2/pkg/grpctest/productv1/productv1connect/product.connect.go @@ -201,6 +201,9 @@ const ( // ProductServiceRequireStorageKindSummaryByIdProcedure is the fully-qualified name of the // ProductService's RequireStorageKindSummaryById RPC. ProductServiceRequireStorageKindSummaryByIdProcedure = "/productv1.ProductService/RequireStorageKindSummaryById" + // ProductServiceRequireStorageLatestOperationByIdProcedure is the fully-qualified name of the + // ProductService's RequireStorageLatestOperationById RPC. + ProductServiceRequireStorageLatestOperationByIdProcedure = "/productv1.ProductService/RequireStorageLatestOperationById" // ProductServiceRequireStorageMetadataScoreByIdProcedure is the fully-qualified name of the // ProductService's RequireStorageMetadataScoreById RPC. ProductServiceRequireStorageMetadataScoreByIdProcedure = "/productv1.ProductService/RequireStorageMetadataScoreById" @@ -213,6 +216,9 @@ const ( // ProductServiceRequireStorageOperationReportByIdProcedure is the fully-qualified name of the // ProductService's RequireStorageOperationReportById RPC. ProductServiceRequireStorageOperationReportByIdProcedure = "/productv1.ProductService/RequireStorageOperationReportById" + // ProductServiceRequireStorageOptionalLatestOperationByIdProcedure is the fully-qualified name of + // the ProductService's RequireStorageOptionalLatestOperationById RPC. + ProductServiceRequireStorageOptionalLatestOperationByIdProcedure = "/productv1.ProductService/RequireStorageOptionalLatestOperationById" // ProductServiceRequireStorageOptionalProcessedMetadataByIdProcedure is the fully-qualified name of // the ProductService's RequireStorageOptionalProcessedMetadataById RPC. ProductServiceRequireStorageOptionalProcessedMetadataByIdProcedure = "/productv1.ProductService/RequireStorageOptionalProcessedMetadataById" @@ -231,6 +237,12 @@ const ( // ProductServiceRequireStorageProcessedTagsByIdProcedure is the fully-qualified name of the // ProductService's RequireStorageProcessedTagsById RPC. ProductServiceRequireStorageProcessedTagsByIdProcedure = "/productv1.ProductService/RequireStorageProcessedTagsById" + // ProductServiceRequireStorageRecommendedItemByIdProcedure is the fully-qualified name of the + // ProductService's RequireStorageRecommendedItemById RPC. + ProductServiceRequireStorageRecommendedItemByIdProcedure = "/productv1.ProductService/RequireStorageRecommendedItemById" + // ProductServiceRequireStorageRecommendedItemsByIdProcedure is the fully-qualified name of the + // ProductService's RequireStorageRecommendedItemsById RPC. + ProductServiceRequireStorageRecommendedItemsByIdProcedure = "/productv1.ProductService/RequireStorageRecommendedItemsById" // ProductServiceRequireStorageSecuritySummaryByIdProcedure is the fully-qualified name of the // ProductService's RequireStorageSecuritySummaryById RPC. ProductServiceRequireStorageSecuritySummaryByIdProcedure = "/productv1.ProductService/RequireStorageSecuritySummaryById" @@ -381,16 +393,20 @@ type ProductServiceClient interface { RequireStorageItemInfoById(context.Context, *connect.Request[productv1.RequireStorageItemInfoByIdRequest]) (*connect.Response[productv1.RequireStorageItemInfoByIdResponse], error) RequireStorageItemSpecsInfoById(context.Context, *connect.Request[productv1.RequireStorageItemSpecsInfoByIdRequest]) (*connect.Response[productv1.RequireStorageItemSpecsInfoByIdResponse], error) RequireStorageKindSummaryById(context.Context, *connect.Request[productv1.RequireStorageKindSummaryByIdRequest]) (*connect.Response[productv1.RequireStorageKindSummaryByIdResponse], error) + RequireStorageLatestOperationById(context.Context, *connect.Request[productv1.RequireStorageLatestOperationByIdRequest]) (*connect.Response[productv1.RequireStorageLatestOperationByIdResponse], error) RequireStorageMetadataScoreById(context.Context, *connect.Request[productv1.RequireStorageMetadataScoreByIdRequest]) (*connect.Response[productv1.RequireStorageMetadataScoreByIdResponse], error) RequireStorageMultiFilteredTagSummaryById(context.Context, *connect.Request[productv1.RequireStorageMultiFilteredTagSummaryByIdRequest]) (*connect.Response[productv1.RequireStorageMultiFilteredTagSummaryByIdResponse], error) 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) RequireStorageOptionalProcessedMetadataById(context.Context, *connect.Request[productv1.RequireStorageOptionalProcessedMetadataByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalProcessedMetadataByIdResponse], error) RequireStorageOptionalProcessedTagsById(context.Context, *connect.Request[productv1.RequireStorageOptionalProcessedTagsByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalProcessedTagsByIdResponse], 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) RequireStorageProcessedTagsById(context.Context, *connect.Request[productv1.RequireStorageProcessedTagsByIdRequest]) (*connect.Response[productv1.RequireStorageProcessedTagsByIdResponse], error) + RequireStorageRecommendedItemById(context.Context, *connect.Request[productv1.RequireStorageRecommendedItemByIdRequest]) (*connect.Response[productv1.RequireStorageRecommendedItemByIdResponse], error) + RequireStorageRecommendedItemsById(context.Context, *connect.Request[productv1.RequireStorageRecommendedItemsByIdRequest]) (*connect.Response[productv1.RequireStorageRecommendedItemsByIdResponse], error) 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) @@ -769,6 +785,12 @@ func NewProductServiceClient(httpClient connect.HTTPClient, baseURL string, opts connect.WithSchema(productServiceMethods.ByName("RequireStorageKindSummaryById")), connect.WithClientOptions(opts...), ), + requireStorageLatestOperationById: connect.NewClient[productv1.RequireStorageLatestOperationByIdRequest, productv1.RequireStorageLatestOperationByIdResponse]( + httpClient, + baseURL+ProductServiceRequireStorageLatestOperationByIdProcedure, + connect.WithSchema(productServiceMethods.ByName("RequireStorageLatestOperationById")), + connect.WithClientOptions(opts...), + ), requireStorageMetadataScoreById: connect.NewClient[productv1.RequireStorageMetadataScoreByIdRequest, productv1.RequireStorageMetadataScoreByIdResponse]( httpClient, baseURL+ProductServiceRequireStorageMetadataScoreByIdProcedure, @@ -793,6 +815,12 @@ func NewProductServiceClient(httpClient connect.HTTPClient, baseURL string, opts connect.WithSchema(productServiceMethods.ByName("RequireStorageOperationReportById")), connect.WithClientOptions(opts...), ), + requireStorageOptionalLatestOperationById: connect.NewClient[productv1.RequireStorageOptionalLatestOperationByIdRequest, productv1.RequireStorageOptionalLatestOperationByIdResponse]( + httpClient, + baseURL+ProductServiceRequireStorageOptionalLatestOperationByIdProcedure, + connect.WithSchema(productServiceMethods.ByName("RequireStorageOptionalLatestOperationById")), + connect.WithClientOptions(opts...), + ), requireStorageOptionalProcessedMetadataById: connect.NewClient[productv1.RequireStorageOptionalProcessedMetadataByIdRequest, productv1.RequireStorageOptionalProcessedMetadataByIdResponse]( httpClient, baseURL+ProductServiceRequireStorageOptionalProcessedMetadataByIdProcedure, @@ -829,6 +857,18 @@ func NewProductServiceClient(httpClient connect.HTTPClient, baseURL string, opts connect.WithSchema(productServiceMethods.ByName("RequireStorageProcessedTagsById")), connect.WithClientOptions(opts...), ), + requireStorageRecommendedItemById: connect.NewClient[productv1.RequireStorageRecommendedItemByIdRequest, productv1.RequireStorageRecommendedItemByIdResponse]( + httpClient, + baseURL+ProductServiceRequireStorageRecommendedItemByIdProcedure, + connect.WithSchema(productServiceMethods.ByName("RequireStorageRecommendedItemById")), + connect.WithClientOptions(opts...), + ), + requireStorageRecommendedItemsById: connect.NewClient[productv1.RequireStorageRecommendedItemsByIdRequest, productv1.RequireStorageRecommendedItemsByIdResponse]( + httpClient, + baseURL+ProductServiceRequireStorageRecommendedItemsByIdProcedure, + connect.WithSchema(productServiceMethods.ByName("RequireStorageRecommendedItemsById")), + connect.WithClientOptions(opts...), + ), requireStorageSecuritySummaryById: connect.NewClient[productv1.RequireStorageSecuritySummaryByIdRequest, productv1.RequireStorageSecuritySummaryByIdResponse]( httpClient, baseURL+ProductServiceRequireStorageSecuritySummaryByIdProcedure, @@ -1064,16 +1104,20 @@ type productServiceClient struct { 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] @@ -1390,6 +1434,12 @@ func (c *productServiceClient) RequireStorageKindSummaryById(ctx context.Context return c.requireStorageKindSummaryById.CallUnary(ctx, req) } +// RequireStorageLatestOperationById calls +// productv1.ProductService.RequireStorageLatestOperationById. +func (c *productServiceClient) RequireStorageLatestOperationById(ctx context.Context, req *connect.Request[productv1.RequireStorageLatestOperationByIdRequest]) (*connect.Response[productv1.RequireStorageLatestOperationByIdResponse], error) { + return c.requireStorageLatestOperationById.CallUnary(ctx, req) +} + // RequireStorageMetadataScoreById calls productv1.ProductService.RequireStorageMetadataScoreById. func (c *productServiceClient) RequireStorageMetadataScoreById(ctx context.Context, req *connect.Request[productv1.RequireStorageMetadataScoreByIdRequest]) (*connect.Response[productv1.RequireStorageMetadataScoreByIdResponse], error) { return c.requireStorageMetadataScoreById.CallUnary(ctx, req) @@ -1413,6 +1463,12 @@ func (c *productServiceClient) RequireStorageOperationReportById(ctx context.Con return c.requireStorageOperationReportById.CallUnary(ctx, req) } +// RequireStorageOptionalLatestOperationById calls +// productv1.ProductService.RequireStorageOptionalLatestOperationById. +func (c *productServiceClient) RequireStorageOptionalLatestOperationById(ctx context.Context, req *connect.Request[productv1.RequireStorageOptionalLatestOperationByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalLatestOperationByIdResponse], error) { + return c.requireStorageOptionalLatestOperationById.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) { @@ -1448,6 +1504,18 @@ func (c *productServiceClient) RequireStorageProcessedTagsById(ctx context.Conte return c.requireStorageProcessedTagsById.CallUnary(ctx, req) } +// RequireStorageRecommendedItemById calls +// productv1.ProductService.RequireStorageRecommendedItemById. +func (c *productServiceClient) RequireStorageRecommendedItemById(ctx context.Context, req *connect.Request[productv1.RequireStorageRecommendedItemByIdRequest]) (*connect.Response[productv1.RequireStorageRecommendedItemByIdResponse], error) { + return c.requireStorageRecommendedItemById.CallUnary(ctx, req) +} + +// RequireStorageRecommendedItemsById calls +// productv1.ProductService.RequireStorageRecommendedItemsById. +func (c *productServiceClient) RequireStorageRecommendedItemsById(ctx context.Context, req *connect.Request[productv1.RequireStorageRecommendedItemsByIdRequest]) (*connect.Response[productv1.RequireStorageRecommendedItemsByIdResponse], error) { + return c.requireStorageRecommendedItemsById.CallUnary(ctx, req) +} + // RequireStorageSecuritySummaryById calls // productv1.ProductService.RequireStorageSecuritySummaryById. func (c *productServiceClient) RequireStorageSecuritySummaryById(ctx context.Context, req *connect.Request[productv1.RequireStorageSecuritySummaryByIdRequest]) (*connect.Response[productv1.RequireStorageSecuritySummaryByIdResponse], error) { @@ -1665,16 +1733,20 @@ type ProductServiceHandler interface { RequireStorageItemInfoById(context.Context, *connect.Request[productv1.RequireStorageItemInfoByIdRequest]) (*connect.Response[productv1.RequireStorageItemInfoByIdResponse], error) RequireStorageItemSpecsInfoById(context.Context, *connect.Request[productv1.RequireStorageItemSpecsInfoByIdRequest]) (*connect.Response[productv1.RequireStorageItemSpecsInfoByIdResponse], error) RequireStorageKindSummaryById(context.Context, *connect.Request[productv1.RequireStorageKindSummaryByIdRequest]) (*connect.Response[productv1.RequireStorageKindSummaryByIdResponse], error) + RequireStorageLatestOperationById(context.Context, *connect.Request[productv1.RequireStorageLatestOperationByIdRequest]) (*connect.Response[productv1.RequireStorageLatestOperationByIdResponse], error) RequireStorageMetadataScoreById(context.Context, *connect.Request[productv1.RequireStorageMetadataScoreByIdRequest]) (*connect.Response[productv1.RequireStorageMetadataScoreByIdResponse], error) RequireStorageMultiFilteredTagSummaryById(context.Context, *connect.Request[productv1.RequireStorageMultiFilteredTagSummaryByIdRequest]) (*connect.Response[productv1.RequireStorageMultiFilteredTagSummaryByIdResponse], error) 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) RequireStorageOptionalProcessedMetadataById(context.Context, *connect.Request[productv1.RequireStorageOptionalProcessedMetadataByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalProcessedMetadataByIdResponse], error) RequireStorageOptionalProcessedTagsById(context.Context, *connect.Request[productv1.RequireStorageOptionalProcessedTagsByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalProcessedTagsByIdResponse], 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) RequireStorageProcessedTagsById(context.Context, *connect.Request[productv1.RequireStorageProcessedTagsByIdRequest]) (*connect.Response[productv1.RequireStorageProcessedTagsByIdResponse], error) + RequireStorageRecommendedItemById(context.Context, *connect.Request[productv1.RequireStorageRecommendedItemByIdRequest]) (*connect.Response[productv1.RequireStorageRecommendedItemByIdResponse], error) + RequireStorageRecommendedItemsById(context.Context, *connect.Request[productv1.RequireStorageRecommendedItemsByIdRequest]) (*connect.Response[productv1.RequireStorageRecommendedItemsByIdResponse], error) 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) @@ -2049,6 +2121,12 @@ func NewProductServiceHandler(svc ProductServiceHandler, opts ...connect.Handler connect.WithSchema(productServiceMethods.ByName("RequireStorageKindSummaryById")), connect.WithHandlerOptions(opts...), ) + productServiceRequireStorageLatestOperationByIdHandler := connect.NewUnaryHandler( + ProductServiceRequireStorageLatestOperationByIdProcedure, + svc.RequireStorageLatestOperationById, + connect.WithSchema(productServiceMethods.ByName("RequireStorageLatestOperationById")), + connect.WithHandlerOptions(opts...), + ) productServiceRequireStorageMetadataScoreByIdHandler := connect.NewUnaryHandler( ProductServiceRequireStorageMetadataScoreByIdProcedure, svc.RequireStorageMetadataScoreById, @@ -2073,6 +2151,12 @@ func NewProductServiceHandler(svc ProductServiceHandler, opts ...connect.Handler connect.WithSchema(productServiceMethods.ByName("RequireStorageOperationReportById")), connect.WithHandlerOptions(opts...), ) + productServiceRequireStorageOptionalLatestOperationByIdHandler := connect.NewUnaryHandler( + ProductServiceRequireStorageOptionalLatestOperationByIdProcedure, + svc.RequireStorageOptionalLatestOperationById, + connect.WithSchema(productServiceMethods.ByName("RequireStorageOptionalLatestOperationById")), + connect.WithHandlerOptions(opts...), + ) productServiceRequireStorageOptionalProcessedMetadataByIdHandler := connect.NewUnaryHandler( ProductServiceRequireStorageOptionalProcessedMetadataByIdProcedure, svc.RequireStorageOptionalProcessedMetadataById, @@ -2109,6 +2193,18 @@ func NewProductServiceHandler(svc ProductServiceHandler, opts ...connect.Handler connect.WithSchema(productServiceMethods.ByName("RequireStorageProcessedTagsById")), connect.WithHandlerOptions(opts...), ) + productServiceRequireStorageRecommendedItemByIdHandler := connect.NewUnaryHandler( + ProductServiceRequireStorageRecommendedItemByIdProcedure, + svc.RequireStorageRecommendedItemById, + connect.WithSchema(productServiceMethods.ByName("RequireStorageRecommendedItemById")), + connect.WithHandlerOptions(opts...), + ) + productServiceRequireStorageRecommendedItemsByIdHandler := connect.NewUnaryHandler( + ProductServiceRequireStorageRecommendedItemsByIdProcedure, + svc.RequireStorageRecommendedItemsById, + connect.WithSchema(productServiceMethods.ByName("RequireStorageRecommendedItemsById")), + connect.WithHandlerOptions(opts...), + ) productServiceRequireStorageSecuritySummaryByIdHandler := connect.NewUnaryHandler( ProductServiceRequireStorageSecuritySummaryByIdProcedure, svc.RequireStorageSecuritySummaryById, @@ -2397,6 +2493,8 @@ func NewProductServiceHandler(svc ProductServiceHandler, opts ...connect.Handler productServiceRequireStorageItemSpecsInfoByIdHandler.ServeHTTP(w, r) case ProductServiceRequireStorageKindSummaryByIdProcedure: productServiceRequireStorageKindSummaryByIdHandler.ServeHTTP(w, r) + case ProductServiceRequireStorageLatestOperationByIdProcedure: + productServiceRequireStorageLatestOperationByIdHandler.ServeHTTP(w, r) case ProductServiceRequireStorageMetadataScoreByIdProcedure: productServiceRequireStorageMetadataScoreByIdHandler.ServeHTTP(w, r) case ProductServiceRequireStorageMultiFilteredTagSummaryByIdProcedure: @@ -2405,6 +2503,8 @@ func NewProductServiceHandler(svc ProductServiceHandler, opts ...connect.Handler productServiceRequireStorageNullableFilteredTagSummaryByIdHandler.ServeHTTP(w, r) case ProductServiceRequireStorageOperationReportByIdProcedure: productServiceRequireStorageOperationReportByIdHandler.ServeHTTP(w, r) + case ProductServiceRequireStorageOptionalLatestOperationByIdProcedure: + productServiceRequireStorageOptionalLatestOperationByIdHandler.ServeHTTP(w, r) case ProductServiceRequireStorageOptionalProcessedMetadataByIdProcedure: productServiceRequireStorageOptionalProcessedMetadataByIdHandler.ServeHTTP(w, r) case ProductServiceRequireStorageOptionalProcessedTagsByIdProcedure: @@ -2417,6 +2517,10 @@ func NewProductServiceHandler(svc ProductServiceHandler, opts ...connect.Handler productServiceRequireStorageProcessedMetadataHistoryByIdHandler.ServeHTTP(w, r) case ProductServiceRequireStorageProcessedTagsByIdProcedure: productServiceRequireStorageProcessedTagsByIdHandler.ServeHTTP(w, r) + case ProductServiceRequireStorageRecommendedItemByIdProcedure: + productServiceRequireStorageRecommendedItemByIdHandler.ServeHTTP(w, r) + case ProductServiceRequireStorageRecommendedItemsByIdProcedure: + productServiceRequireStorageRecommendedItemsByIdHandler.ServeHTTP(w, r) case ProductServiceRequireStorageSecuritySummaryByIdProcedure: productServiceRequireStorageSecuritySummaryByIdHandler.ServeHTTP(w, r) case ProductServiceRequireStorageStockHealthScoreByIdProcedure: @@ -2708,6 +2812,10 @@ func (UnimplementedProductServiceHandler) RequireStorageKindSummaryById(context. return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.RequireStorageKindSummaryById is not implemented")) } +func (UnimplementedProductServiceHandler) RequireStorageLatestOperationById(context.Context, *connect.Request[productv1.RequireStorageLatestOperationByIdRequest]) (*connect.Response[productv1.RequireStorageLatestOperationByIdResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.RequireStorageLatestOperationById is not implemented")) +} + func (UnimplementedProductServiceHandler) RequireStorageMetadataScoreById(context.Context, *connect.Request[productv1.RequireStorageMetadataScoreByIdRequest]) (*connect.Response[productv1.RequireStorageMetadataScoreByIdResponse], error) { return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.RequireStorageMetadataScoreById is not implemented")) } @@ -2724,6 +2832,10 @@ func (UnimplementedProductServiceHandler) RequireStorageOperationReportById(cont return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.RequireStorageOperationReportById is not implemented")) } +func (UnimplementedProductServiceHandler) RequireStorageOptionalLatestOperationById(context.Context, *connect.Request[productv1.RequireStorageOptionalLatestOperationByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalLatestOperationByIdResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.RequireStorageOptionalLatestOperationById 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")) } @@ -2748,6 +2860,14 @@ func (UnimplementedProductServiceHandler) RequireStorageProcessedTagsById(contex return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.RequireStorageProcessedTagsById is not implemented")) } +func (UnimplementedProductServiceHandler) RequireStorageRecommendedItemById(context.Context, *connect.Request[productv1.RequireStorageRecommendedItemByIdRequest]) (*connect.Response[productv1.RequireStorageRecommendedItemByIdResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.RequireStorageRecommendedItemById is not implemented")) +} + +func (UnimplementedProductServiceHandler) RequireStorageRecommendedItemsById(context.Context, *connect.Request[productv1.RequireStorageRecommendedItemsByIdRequest]) (*connect.Response[productv1.RequireStorageRecommendedItemsByIdResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.RequireStorageRecommendedItemsById is not implemented")) +} + func (UnimplementedProductServiceHandler) RequireStorageSecuritySummaryById(context.Context, *connect.Request[productv1.RequireStorageSecuritySummaryByIdRequest]) (*connect.Response[productv1.RequireStorageSecuritySummaryByIdResponse], error) { return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.RequireStorageSecuritySummaryById is not implemented")) } diff --git a/v2/pkg/grpctest/schema.go b/v2/pkg/grpctest/schema.go index 7e6be659cd..b02ad699e3 100644 --- a/v2/pkg/grpctest/schema.go +++ b/v2/pkg/grpctest/schema.go @@ -779,6 +779,26 @@ func GetDataSourceMetadata() *plan.DataSourceMetadata { FieldName: "deepItemInfo", SelectionSet: "primaryItem { ... on PalletItem { __typename handler { assignedItem { ... on ContainerItem { __typename name containerSize } ... on PalletItem { __typename name palletCount } } } } ... on ContainerItem { __typename handler { name } } }", }, + { + TypeName: "Storage", + FieldName: "recommendedItem", + SelectionSet: "metadata { capacity zone }", + }, + { + TypeName: "Storage", + FieldName: "recommendedItems", + SelectionSet: "tags", + }, + { + TypeName: "Storage", + FieldName: "latestOperation", + SelectionSet: "storageKind", + }, + { + TypeName: "Storage", + FieldName: "optionalLatestOperation", + SelectionSet: "optionalTags", + }, { TypeName: "Storage", FieldName: "filteredTagSummary", @@ -894,6 +914,10 @@ func GetDataSourceMetadata() *plan.DataSourceMetadata { "itemHandlerInfo", "itemSpecsInfo", "deepItemInfo", + "recommendedItem", + "recommendedItems", + "latestOperation", + "optionalLatestOperation", "storageStatus", "linkedStorages", "nearbyStorages", @@ -975,6 +999,10 @@ func GetDataSourceMetadata() *plan.DataSourceMetadata { "itemHandlerInfo", "itemSpecsInfo", "deepItemInfo", + "recommendedItem", + "recommendedItems", + "latestOperation", + "optionalLatestOperation", "storageStatus", "linkedStorages", "nearbyStorages", diff --git a/v2/pkg/grpctest/testdata/products.graphqls b/v2/pkg/grpctest/testdata/products.graphqls index 6092e57b0a..42cc3944eb 100644 --- a/v2/pkg/grpctest/testdata/products.graphqls +++ b/v2/pkg/grpctest/testdata/products.graphqls @@ -76,6 +76,16 @@ type Storage @key(fields: "id") { # Pattern 6: Nested abstract through concrete intermediary (handler → assignedItem) deepItemInfo: String! @requires(fields: "primaryItem { ... on PalletItem { __typename handler { assignedItem { ... on ContainerItem { __typename name containerSize } ... on PalletItem { __typename name palletCount } } } } ... on ContainerItem { __typename handler { name } } }") + # @requires fields returning abstract types + # Pattern 7: interface return type + recommendedItem: StorageItem! @requires(fields: "metadata { capacity zone }") + # Pattern 8: list of interface return type + recommendedItems: [StorageItem!]! @requires(fields: "tags") + # Pattern 9: union return type + latestOperation: StorageOperationResult! @requires(fields: "storageKind") + # Pattern 10: nullable union return type + optionalLatestOperation: StorageOperationResult @requires(fields: "optionalTags") + # @connect_fieldResolver fields storageStatus(checkHealth: Boolean!): ActionResult! @connect__fieldResolver(context: "id name") linkedStorages(depth: Int!): [Storage!]! @connect__fieldResolver(context: "id name location")