api.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: api.proto

package api

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	math "math"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package

type ClientRequestType struct {
	Vendor               string   `protobuf:"bytes,1,opt,name=vendor,proto3" json:"vendor,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ClientRequestType) Reset()         { *m = ClientRequestType{} }
func (m *ClientRequestType) String() string { return proto.CompactTextString(m) }
func (*ClientRequestType) ProtoMessage()    {}
func (*ClientRequestType) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{0}
}

func (m *ClientRequestType) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ClientRequestType.Unmarshal(m, b)
}
func (m *ClientRequestType) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ClientRequestType.Marshal(b, m, deterministic)
}
func (m *ClientRequestType) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ClientRequestType.Merge(m, src)
}
func (m *ClientRequestType) XXX_Size() int {
	return xxx_messageInfo_ClientRequestType.Size(m)
}
func (m *ClientRequestType) XXX_DiscardUnknown() {
	xxx_messageInfo_ClientRequestType.DiscardUnknown(m)
}

var xxx_messageInfo_ClientRequestType proto.InternalMessageInfo

func (m *ClientRequestType) GetVendor() string {
	if m != nil {
		return m.Vendor
	}
	return ""
}

type ClientResponseType struct {
	ProductType          string   `protobuf:"bytes,1,opt,name=productType,proto3" json:"productType,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ClientResponseType) Reset()         { *m = ClientResponseType{} }
func (m *ClientResponseType) String() string { return proto.CompactTextString(m) }
func (*ClientResponseType) ProtoMessage()    {}
func (*ClientResponseType) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{1}
}

func (m *ClientResponseType) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ClientResponseType.Unmarshal(m, b)
}
func (m *ClientResponseType) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ClientResponseType.Marshal(b, m, deterministic)
}
func (m *ClientResponseType) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ClientResponseType.Merge(m, src)
}
func (m *ClientResponseType) XXX_Size() int {
	return xxx_messageInfo_ClientResponseType.Size(m)
}
func (m *ClientResponseType) XXX_DiscardUnknown() {
	xxx_messageInfo_ClientResponseType.DiscardUnknown(m)
}

var xxx_messageInfo_ClientResponseType proto.InternalMessageInfo

func (m *ClientResponseType) GetProductType() string {
	if m != nil {
		return m.ProductType
	}
	return ""
}

type ClientRequestProds struct {
	Vendor               string   `protobuf:"bytes,1,opt,name=vendor,proto3" json:"vendor,omitempty"`
	ProductType          string   `protobuf:"bytes,2,opt,name=productType,proto3" json:"productType,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ClientRequestProds) Reset()         { *m = ClientRequestProds{} }
func (m *ClientRequestProds) String() string { return proto.CompactTextString(m) }
func (*ClientRequestProds) ProtoMessage()    {}
func (*ClientRequestProds) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{2}
}

func (m *ClientRequestProds) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ClientRequestProds.Unmarshal(m, b)
}
func (m *ClientRequestProds) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ClientRequestProds.Marshal(b, m, deterministic)
}
func (m *ClientRequestProds) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ClientRequestProds.Merge(m, src)
}
func (m *ClientRequestProds) XXX_Size() int {
	return xxx_messageInfo_ClientRequestProds.Size(m)
}
func (m *ClientRequestProds) XXX_DiscardUnknown() {
	xxx_messageInfo_ClientRequestProds.DiscardUnknown(m)
}

var xxx_messageInfo_ClientRequestProds proto.InternalMessageInfo

func (m *ClientRequestProds) GetVendor() string {
	if m != nil {
		return m.Vendor
	}
	return ""
}

func (m *ClientRequestProds) GetProductType() string {
	if m != nil {
		return m.ProductType
	}
	return ""
}

type ClientResponseProds struct {
	Product              *ProdsPrep `protobuf:"bytes,1,opt,name=product,proto3" json:"product,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *ClientResponseProds) Reset()         { *m = ClientResponseProds{} }
func (m *ClientResponseProds) String() string { return proto.CompactTextString(m) }
func (*ClientResponseProds) ProtoMessage()    {}
func (*ClientResponseProds) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{3}
}

func (m *ClientResponseProds) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ClientResponseProds.Unmarshal(m, b)
}
func (m *ClientResponseProds) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ClientResponseProds.Marshal(b, m, deterministic)
}
func (m *ClientResponseProds) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ClientResponseProds.Merge(m, src)
}
func (m *ClientResponseProds) XXX_Size() int {
	return xxx_messageInfo_ClientResponseProds.Size(m)
}
func (m *ClientResponseProds) XXX_DiscardUnknown() {
	xxx_messageInfo_ClientResponseProds.DiscardUnknown(m)
}

var xxx_messageInfo_ClientResponseProds proto.InternalMessageInfo

func (m *ClientResponseProds) GetProduct() *ProdsPrep {
	if m != nil {
		return m.Product
	}
	return nil
}

type ProdsPrep struct {
	Title                string   `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"`
	Url                  string   `protobuf:"bytes,2,opt,name=url,proto3" json:"url,omitempty"`
	ShortUrl             string   `protobuf:"bytes,3,opt,name=shortUrl,proto3" json:"shortUrl,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ProdsPrep) Reset()         { *m = ProdsPrep{} }
func (m *ProdsPrep) String() string { return proto.CompactTextString(m) }
func (*ProdsPrep) ProtoMessage()    {}
func (*ProdsPrep) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{4}
}

func (m *ProdsPrep) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ProdsPrep.Unmarshal(m, b)
}
func (m *ProdsPrep) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ProdsPrep.Marshal(b, m, deterministic)
}
func (m *ProdsPrep) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ProdsPrep.Merge(m, src)
}
func (m *ProdsPrep) XXX_Size() int {
	return xxx_messageInfo_ProdsPrep.Size(m)
}
func (m *ProdsPrep) XXX_DiscardUnknown() {
	xxx_messageInfo_ProdsPrep.DiscardUnknown(m)
}

var xxx_messageInfo_ProdsPrep proto.InternalMessageInfo

func (m *ProdsPrep) GetTitle() string {
	if m != nil {
		return m.Title
	}
	return ""
}

func (m *ProdsPrep) GetUrl() string {
	if m != nil {
		return m.Url
	}
	return ""
}

func (m *ProdsPrep) GetShortUrl() string {
	if m != nil {
		return m.ShortUrl
	}
	return ""
}

type StorageRequest struct {
	Vendor               string   `protobuf:"bytes,1,opt,name=vendor,proto3" json:"vendor,omitempty"`
	ProductType          string   `protobuf:"bytes,2,opt,name=productType,proto3" json:"productType,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *StorageRequest) Reset()         { *m = StorageRequest{} }
func (m *StorageRequest) String() string { return proto.CompactTextString(m) }
func (*StorageRequest) ProtoMessage()    {}
func (*StorageRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{5}
}

func (m *StorageRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StorageRequest.Unmarshal(m, b)
}
func (m *StorageRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StorageRequest.Marshal(b, m, deterministic)
}
func (m *StorageRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StorageRequest.Merge(m, src)
}
func (m *StorageRequest) XXX_Size() int {
	return xxx_messageInfo_StorageRequest.Size(m)
}
func (m *StorageRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_StorageRequest.DiscardUnknown(m)
}

var xxx_messageInfo_StorageRequest proto.InternalMessageInfo

func (m *StorageRequest) GetVendor() string {
	if m != nil {
		return m.Vendor
	}
	return ""
}

func (m *StorageRequest) GetProductType() string {
	if m != nil {
		return m.ProductType
	}
	return ""
}

type StorageResponse struct {
	ProdDetail           []*Product `protobuf:"bytes,1,rep,name=prodDetail,proto3" json:"prodDetail,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *StorageResponse) Reset()         { *m = StorageResponse{} }
func (m *StorageResponse) String() string { return proto.CompactTextString(m) }
func (*StorageResponse) ProtoMessage()    {}
func (*StorageResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{6}
}

func (m *StorageResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StorageResponse.Unmarshal(m, b)
}
func (m *StorageResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StorageResponse.Marshal(b, m, deterministic)
}
func (m *StorageResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StorageResponse.Merge(m, src)
}
func (m *StorageResponse) XXX_Size() int {
	return xxx_messageInfo_StorageResponse.Size(m)
}
func (m *StorageResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_StorageResponse.DiscardUnknown(m)
}

var xxx_messageInfo_StorageResponse proto.InternalMessageInfo

func (m *StorageResponse) GetProdDetail() []*Product {
	if m != nil {
		return m.ProdDetail
	}
	return nil
}

type Product struct {
	Title                string   `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"`
	Url                  string   `protobuf:"bytes,2,opt,name=url,proto3" json:"url,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Product) Reset()         { *m = Product{} }
func (m *Product) String() string { return proto.CompactTextString(m) }
func (*Product) ProtoMessage()    {}
func (*Product) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{7}
}

func (m *Product) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Product.Unmarshal(m, b)
}
func (m *Product) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Product.Marshal(b, m, deterministic)
}
func (m *Product) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Product.Merge(m, src)
}
func (m *Product) XXX_Size() int {
	return xxx_messageInfo_Product.Size(m)
}
func (m *Product) XXX_DiscardUnknown() {
	xxx_messageInfo_Product.DiscardUnknown(m)
}

var xxx_messageInfo_Product proto.InternalMessageInfo

func (m *Product) GetTitle() string {
	if m != nil {
		return m.Title
	}
	return ""
}

func (m *Product) GetUrl() string {
	if m != nil {
		return m.Url
	}
	return ""
}

func init() {
	proto.RegisterType((*ClientRequestType)(nil), "api.ClientRequestType")
	proto.RegisterType((*ClientResponseType)(nil), "api.ClientResponseType")
	proto.RegisterType((*ClientRequestProds)(nil), "api.ClientRequestProds")
	proto.RegisterType((*ClientResponseProds)(nil), "api.ClientResponseProds")
	proto.RegisterType((*ProdsPrep)(nil), "api.ProdsPrep")
	proto.RegisterType((*StorageRequest)(nil), "api.StorageRequest")
	proto.RegisterType((*StorageResponse)(nil), "api.StorageResponse")
	proto.RegisterType((*Product)(nil), "api.Product")
}

func init() { proto.RegisterFile("api.proto", fileDescriptor_00212fb1f9d3bf1c) }

var fileDescriptor_00212fb1f9d3bf1c = []byte{
	// 401 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x93, 0xcf, 0x6a, 0xdb, 0x40,
	0x10, 0xc6, 0x91, 0x45, 0xed, 0x7a, 0x64, 0x54, 0x77, 0x6d, 0x6c, 0x21, 0x7a, 0x30, 0x7b, 0x32,
	0xb4, 0xd8, 0xad, 0x0a, 0xbd, 0xf4, 0x90, 0x43, 0x02, 0x81, 0x40, 0x12, 0x23, 0x27, 0x81, 0x1c,
	0x72, 0x50, 0xec, 0xc5, 0x59, 0x10, 0xda, 0xcd, 0xee, 0xca, 0x90, 0x6b, 0x5e, 0x21, 0x0f, 0x95,
	0x07, 0xc8, 0x2b, 0xe4, 0x41, 0x82, 0x46, 0x7f, 0x6c, 0xc5, 0x09, 0x04, 0x72, 0xd3, 0x7e, 0x33,
	0xf3, 0x9b, 0xf9, 0x76, 0x47, 0xd0, 0x8e, 0x24, 0x9f, 0x48, 0x25, 0x8c, 0x20, 0x76, 0x24, 0xb9,
	0xff, 0x63, 0x25, 0xc4, 0x2a, 0x66, 0xd3, 0x48, 0xf2, 0x69, 0x94, 0x24, 0xc2, 0x44, 0x86, 0x8b,
	0x44, 0xe7, 0x29, 0xf4, 0x27, 0x7c, 0xdf, 0x8f, 0x39, 0x4b, 0x4c, 0xc8, 0x6e, 0x53, 0xa6, 0xcd,
	0xd9, 0x9d, 0x64, 0x64, 0x00, 0xcd, 0x35, 0x4b, 0x96, 0x42, 0x79, 0xd6, 0xc8, 0x1a, 0xb7, 0xc3,
	0xe2, 0x44, 0xff, 0x01, 0x29, 0x93, 0xb5, 0x14, 0x89, 0x66, 0x98, 0x3d, 0x02, 0x47, 0x2a, 0xb1,
	0x4c, 0x17, 0x58, 0x5c, 0x94, 0x6c, 0x4b, 0xf4, 0x64, 0x53, 0x87, 0x4d, 0x66, 0x4a, 0x2c, 0xf5,
	0x7b, 0x5d, 0x5e, 0xf3, 0x1a, 0xbb, 0xbc, 0x3d, 0xe8, 0xd5, 0xe7, 0xc8, 0x81, 0x63, 0x68, 0x15,
	0x59, 0x48, 0x74, 0x02, 0x77, 0x92, 0xdd, 0x05, 0x06, 0x67, 0x8a, 0xc9, 0xb0, 0x0c, 0xd3, 0x53,
	0x68, 0x57, 0x2a, 0xe9, 0xc3, 0x17, 0xc3, 0x4d, 0x5c, 0x4e, 0x9e, 0x1f, 0x48, 0x17, 0xec, 0x54,
	0xc5, 0x45, 0xf7, 0xec, 0x93, 0xf8, 0xf0, 0x55, 0xdf, 0x08, 0x65, 0xce, 0x55, 0xec, 0xd9, 0x28,
	0x57, 0x67, 0x7a, 0x04, 0xee, 0xdc, 0x08, 0x15, 0xad, 0x58, 0x61, 0xf1, 0x53, 0xee, 0xbe, 0x55,
	0xac, 0xdc, 0x1e, 0xf9, 0x05, 0x90, 0x65, 0x1c, 0x30, 0x13, 0xf1, 0xd8, 0xb3, 0x46, 0xf6, 0xd8,
	0x09, 0x3a, 0x95, 0xb9, 0x74, 0x61, 0xc2, 0xad, 0x38, 0xfd, 0x03, 0xad, 0x42, 0xfe, 0xa8, 0xb7,
	0xe0, 0xd1, 0x02, 0x27, 0xab, 0x99, 0x33, 0xb5, 0xe6, 0x0b, 0x46, 0xae, 0x80, 0x1c, 0x32, 0x73,
	0x81, 0x23, 0x67, 0x7a, 0x36, 0x98, 0x26, 0x03, 0x6c, 0xb9, 0xb3, 0x2f, 0xfe, 0xb0, 0xa6, 0x6f,
	0x56, 0x83, 0x0e, 0xee, 0x9f, 0x9e, 0x1f, 0x1a, 0x5d, 0xe2, 0xe2, 0xf6, 0x65, 0x23, 0x1a, 0x04,
	0x5d, 0x82, 0x5b, 0xc3, 0x6b, 0x32, 0xdc, 0x45, 0x63, 0xc0, 0xf7, 0xde, 0x60, 0x63, 0x84, 0x12,
	0x84, 0x77, 0x08, 0x54, 0x70, 0xfd, 0xdb, 0x0a, 0x8e, 0xab, 0x97, 0x28, 0xbd, 0xfc, 0xc7, 0x66,
	0x58, 0x93, 0x5f, 0x10, 0xe9, 0x21, 0xb3, 0xfe, 0x60, 0x7e, 0xbf, 0x2e, 0xe6, 0x9d, 0xae, 0x9b,
	0xf8, 0x9b, 0xfc, 0x7d, 0x09, 0x00, 0x00, 0xff, 0xff, 0xdd, 0x99, 0x48, 0x81, 0x56, 0x03, 0x00,
	0x00,
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// ProdServiceClient is the client API for ProdService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ProdServiceClient interface {
	GetVendorProdTypes(ctx context.Context, in *ClientRequestType, opts ...grpc.CallOption) (*ClientResponseType, error)
	GetVendorProds(ctx context.Context, in *ClientRequestProds, opts ...grpc.CallOption) (ProdService_GetVendorProdsClient, error)
}

type prodServiceClient struct {
	cc *grpc.ClientConn
}

func NewProdServiceClient(cc *grpc.ClientConn) ProdServiceClient {
	return &prodServiceClient{cc}
}

func (c *prodServiceClient) GetVendorProdTypes(ctx context.Context, in *ClientRequestType, opts ...grpc.CallOption) (*ClientResponseType, error) {
	out := new(ClientResponseType)
	err := c.cc.Invoke(ctx, "/api.ProdService/GetVendorProdTypes", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *prodServiceClient) GetVendorProds(ctx context.Context, in *ClientRequestProds, opts ...grpc.CallOption) (ProdService_GetVendorProdsClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ProdService_serviceDesc.Streams[0], "/api.ProdService/GetVendorProds", opts...)
	if err != nil {
		return nil, err
	}
	x := &prodServiceGetVendorProdsClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type ProdService_GetVendorProdsClient interface {
	Recv() (*ClientResponseProds, error)
	grpc.ClientStream
}

type prodServiceGetVendorProdsClient struct {
	grpc.ClientStream
}

func (x *prodServiceGetVendorProdsClient) Recv() (*ClientResponseProds, error) {
	m := new(ClientResponseProds)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// ProdServiceServer is the server API for ProdService service.
type ProdServiceServer interface {
	GetVendorProdTypes(context.Context, *ClientRequestType) (*ClientResponseType, error)
	GetVendorProds(*ClientRequestProds, ProdService_GetVendorProdsServer) error
}

// UnimplementedProdServiceServer can be embedded to have forward compatible implementations.
type UnimplementedProdServiceServer struct {
}

func (*UnimplementedProdServiceServer) GetVendorProdTypes(ctx context.Context, req *ClientRequestType) (*ClientResponseType, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetVendorProdTypes not implemented")
}
func (*UnimplementedProdServiceServer) GetVendorProds(req *ClientRequestProds, srv ProdService_GetVendorProdsServer) error {
	return status.Errorf(codes.Unimplemented, "method GetVendorProds not implemented")
}

func RegisterProdServiceServer(s *grpc.Server, srv ProdServiceServer) {
	s.RegisterService(&_ProdService_serviceDesc, srv)
}

func _ProdService_GetVendorProdTypes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ClientRequestType)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProdServiceServer).GetVendorProdTypes(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.ProdService/GetVendorProdTypes",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProdServiceServer).GetVendorProdTypes(ctx, req.(*ClientRequestType))
	}
	return interceptor(ctx, in, info, handler)
}

func _ProdService_GetVendorProds_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ClientRequestProds)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ProdServiceServer).GetVendorProds(m, &prodServiceGetVendorProdsServer{stream})
}

type ProdService_GetVendorProdsServer interface {
	Send(*ClientResponseProds) error
	grpc.ServerStream
}

type prodServiceGetVendorProdsServer struct {
	grpc.ServerStream
}

func (x *prodServiceGetVendorProdsServer) Send(m *ClientResponseProds) error {
	return x.ServerStream.SendMsg(m)
}

var _ProdService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "api.ProdService",
	HandlerType: (*ProdServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetVendorProdTypes",
			Handler:    _ProdService_GetVendorProdTypes_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GetVendorProds",
			Handler:       _ProdService_GetVendorProds_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "api.proto",
}

// StorageServiceClient is the client API for StorageService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type StorageServiceClient interface {
	GetProdsDetail(ctx context.Context, in *StorageRequest, opts ...grpc.CallOption) (*StorageResponse, error)
}

type storageServiceClient struct {
	cc *grpc.ClientConn
}

func NewStorageServiceClient(cc *grpc.ClientConn) StorageServiceClient {
	return &storageServiceClient{cc}
}

func (c *storageServiceClient) GetProdsDetail(ctx context.Context, in *StorageRequest, opts ...grpc.CallOption) (*StorageResponse, error) {
	out := new(StorageResponse)
	err := c.cc.Invoke(ctx, "/api.StorageService/GetProdsDetail", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// StorageServiceServer is the server API for StorageService service.
type StorageServiceServer interface {
	GetProdsDetail(context.Context, *StorageRequest) (*StorageResponse, error)
}

// UnimplementedStorageServiceServer can be embedded to have forward compatible implementations.
type UnimplementedStorageServiceServer struct {
}

func (*UnimplementedStorageServiceServer) GetProdsDetail(ctx context.Context, req *StorageRequest) (*StorageResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetProdsDetail not implemented")
}

func RegisterStorageServiceServer(s *grpc.Server, srv StorageServiceServer) {
	s.RegisterService(&_StorageService_serviceDesc, srv)
}

func _StorageService_GetProdsDetail_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StorageRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StorageServiceServer).GetProdsDetail(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.StorageService/GetProdsDetail",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StorageServiceServer).GetProdsDetail(ctx, req.(*StorageRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _StorageService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "api.StorageService",
	HandlerType: (*StorageServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetProdsDetail",
			Handler:    _StorageService_GetProdsDetail_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "api.proto",
}