muyu-apiserver/rpc/inventory/pb/inventory_grpc.pb.go

// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.6.2
// - protoc             v7.34.1
// source: inventory.proto

package pb

import (
	context "context"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
)

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
// Requires gRPC-Go v1.64.0 or later.
const _ = grpc.SupportPackageIsVersion9

const (
	InventoryService_CreateProduct_FullMethodName      = "/inventory.InventoryService/CreateProduct"
	InventoryService_UpdateProduct_FullMethodName      = "/inventory.InventoryService/UpdateProduct"
	InventoryService_DeleteProduct_FullMethodName      = "/inventory.InventoryService/DeleteProduct"
	InventoryService_GetProduct_FullMethodName         = "/inventory.InventoryService/GetProduct"
	InventoryService_ListProduct_FullMethodName        = "/inventory.InventoryService/ListProduct"
	InventoryService_GetProductTree_FullMethodName     = "/inventory.InventoryService/GetProductTree"
	InventoryService_ListProductSummary_FullMethodName = "/inventory.InventoryService/ListProductSummary"
	InventoryService_ListColorDetail_FullMethodName    = "/inventory.InventoryService/ListColorDetail"
	InventoryService_CreateYarn_FullMethodName         = "/inventory.InventoryService/CreateYarn"
	InventoryService_UpdateYarn_FullMethodName         = "/inventory.InventoryService/UpdateYarn"
	InventoryService_DeleteYarn_FullMethodName         = "/inventory.InventoryService/DeleteYarn"
	InventoryService_GetYarn_FullMethodName            = "/inventory.InventoryService/GetYarn"
	InventoryService_ListYarn_FullMethodName           = "/inventory.InventoryService/ListYarn"
	InventoryService_CreateProductBatch_FullMethodName = "/inventory.InventoryService/CreateProductBatch"
	InventoryService_UpdateProductBatch_FullMethodName = "/inventory.InventoryService/UpdateProductBatch"
	InventoryService_DeleteProductBatch_FullMethodName = "/inventory.InventoryService/DeleteProductBatch"
	InventoryService_ListProductBatch_FullMethodName   = "/inventory.InventoryService/ListProductBatch"
	InventoryService_ListPanView_FullMethodName        = "/inventory.InventoryService/ListPanView"
	InventoryService_ListBoltView_FullMethodName       = "/inventory.InventoryService/ListBoltView"
	InventoryService_ListPans_FullMethodName           = "/inventory.InventoryService/ListPans"
	InventoryService_SavePans_FullMethodName           = "/inventory.InventoryService/SavePans"
	InventoryService_ListBolts_FullMethodName          = "/inventory.InventoryService/ListBolts"
	InventoryService_SaveBolts_FullMethodName          = "/inventory.InventoryService/SaveBolts"
	InventoryService_ImportProducts_FullMethodName     = "/inventory.InventoryService/ImportProducts"
	InventoryService_ListImportLog_FullMethodName      = "/inventory.InventoryService/ListImportLog"
	InventoryService_GetStockSummary_FullMethodName    = "/inventory.InventoryService/GetStockSummary"
	InventoryService_GetStockGroup_FullMethodName      = "/inventory.InventoryService/GetStockGroup"
	InventoryService_CreateStockCheck_FullMethodName   = "/inventory.InventoryService/CreateStockCheck"
	InventoryService_UpdateStockCheck_FullMethodName   = "/inventory.InventoryService/UpdateStockCheck"
	InventoryService_ConfirmStockCheck_FullMethodName  = "/inventory.InventoryService/ConfirmStockCheck"
	InventoryService_GetStockCheck_FullMethodName      = "/inventory.InventoryService/GetStockCheck"
	InventoryService_ListStockCheck_FullMethodName     = "/inventory.InventoryService/ListStockCheck"
	InventoryService_CreateStockAdjust_FullMethodName  = "/inventory.InventoryService/CreateStockAdjust"
	InventoryService_ApproveStockAdjust_FullMethodName = "/inventory.InventoryService/ApproveStockAdjust"
	InventoryService_GetStockAdjust_FullMethodName     = "/inventory.InventoryService/GetStockAdjust"
	InventoryService_ListStockAdjust_FullMethodName    = "/inventory.InventoryService/ListStockAdjust"
)

// InventoryServiceClient is the client API for InventoryService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type InventoryServiceClient interface {
	// Product CRUD
	CreateProduct(ctx context.Context, in *CreateProductReq, opts ...grpc.CallOption) (*IdResp, error)
	UpdateProduct(ctx context.Context, in *UpdateProductReq, opts ...grpc.CallOption) (*Empty, error)
	DeleteProduct(ctx context.Context, in *DeleteProductReq, opts ...grpc.CallOption) (*Empty, error)
	GetProduct(ctx context.Context, in *GetProductReq, opts ...grpc.CallOption) (*ProductInfo, error)
	ListProduct(ctx context.Context, in *ListProductReq, opts ...grpc.CallOption) (*ListProductResp, error)
	// Product Tree (panel 3)
	GetProductTree(ctx context.Context, in *GetProductReq, opts ...grpc.CallOption) (*ProductTreeResp, error)
	// Product Summary (panel 1)
	ListProductSummary(ctx context.Context, in *ListProductSummaryReq, opts ...grpc.CallOption) (*ListProductSummaryResp, error)
	// Color Detail (panel 2)
	ListColorDetail(ctx context.Context, in *ListColorDetailReq, opts ...grpc.CallOption) (*ListColorDetailResp, error)
	// Yarn CRUD
	CreateYarn(ctx context.Context, in *CreateYarnReq, opts ...grpc.CallOption) (*IdResp, error)
	UpdateYarn(ctx context.Context, in *UpdateYarnReq, opts ...grpc.CallOption) (*Empty, error)
	DeleteYarn(ctx context.Context, in *DeleteYarnReq, opts ...grpc.CallOption) (*Empty, error)
	GetYarn(ctx context.Context, in *GetYarnReq, opts ...grpc.CallOption) (*YarnInfo, error)
	ListYarn(ctx context.Context, in *ListYarnReq, opts ...grpc.CallOption) (*ListYarnResp, error)
	// Product Batch CRUD
	CreateProductBatch(ctx context.Context, in *CreateProductBatchReq, opts ...grpc.CallOption) (*IdResp, error)
	UpdateProductBatch(ctx context.Context, in *UpdateProductBatchReq, opts ...grpc.CallOption) (*Empty, error)
	DeleteProductBatch(ctx context.Context, in *DeleteProductBatchReq, opts ...grpc.CallOption) (*Empty, error)
	ListProductBatch(ctx context.Context, in *ListProductBatchReq, opts ...grpc.CallOption) (*ListProductBatchResp, error)
	// Pan / Bolt list views (dimension panels)
	ListPanView(ctx context.Context, in *ListPanViewReq, opts ...grpc.CallOption) (*ListPanViewResp, error)
	ListBoltView(ctx context.Context, in *ListBoltViewReq, opts ...grpc.CallOption) (*ListBoltViewResp, error)
	// Pan CRUD
	ListPans(ctx context.Context, in *ListPanReq, opts ...grpc.CallOption) (*ListPanResp, error)
	SavePans(ctx context.Context, in *SavePansReq, opts ...grpc.CallOption) (*Empty, error)
	// Bolt CRUD
	ListBolts(ctx context.Context, in *ListBoltReq, opts ...grpc.CallOption) (*ListBoltResp, error)
	SaveBolts(ctx context.Context, in *SaveBoltsReq, opts ...grpc.CallOption) (*Empty, error)
	// Import
	ImportProducts(ctx context.Context, in *ImportProductReq, opts ...grpc.CallOption) (*ImportProductResp, error)
	ListImportLog(ctx context.Context, in *ListImportLogReq, opts ...grpc.CallOption) (*ListImportLogResp, error)
	// Stock Statistics
	GetStockSummary(ctx context.Context, in *StockSummaryReq, opts ...grpc.CallOption) (*StockSummaryResp, error)
	GetStockGroup(ctx context.Context, in *StockGroupReq, opts ...grpc.CallOption) (*StockGroupResp, error)
	// Stock Check
	CreateStockCheck(ctx context.Context, in *CreateStockCheckReq, opts ...grpc.CallOption) (*IdResp, error)
	UpdateStockCheck(ctx context.Context, in *UpdateStockCheckReq, opts ...grpc.CallOption) (*Empty, error)
	ConfirmStockCheck(ctx context.Context, in *ConfirmStockCheckReq, opts ...grpc.CallOption) (*Empty, error)
	GetStockCheck(ctx context.Context, in *GetStockCheckReq, opts ...grpc.CallOption) (*StockCheckInfo, error)
	ListStockCheck(ctx context.Context, in *ListStockCheckReq, opts ...grpc.CallOption) (*ListStockCheckResp, error)
	// Stock Adjust
	CreateStockAdjust(ctx context.Context, in *CreateStockAdjustReq, opts ...grpc.CallOption) (*IdResp, error)
	ApproveStockAdjust(ctx context.Context, in *ApproveStockAdjustReq, opts ...grpc.CallOption) (*Empty, error)
	GetStockAdjust(ctx context.Context, in *GetStockAdjustReq, opts ...grpc.CallOption) (*StockAdjustInfo, error)
	ListStockAdjust(ctx context.Context, in *ListStockAdjustReq, opts ...grpc.CallOption) (*ListStockAdjustResp, error)
}

type inventoryServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewInventoryServiceClient(cc grpc.ClientConnInterface) InventoryServiceClient {
	return &inventoryServiceClient{cc}
}

func (c *inventoryServiceClient) CreateProduct(ctx context.Context, in *CreateProductReq, opts ...grpc.CallOption) (*IdResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(IdResp)
	err := c.cc.Invoke(ctx, InventoryService_CreateProduct_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *inventoryServiceClient) UpdateProduct(ctx context.Context, in *UpdateProductReq, opts ...grpc.CallOption) (*Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Empty)
	err := c.cc.Invoke(ctx, InventoryService_UpdateProduct_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *inventoryServiceClient) DeleteProduct(ctx context.Context, in *DeleteProductReq, opts ...grpc.CallOption) (*Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Empty)
	err := c.cc.Invoke(ctx, InventoryService_DeleteProduct_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *inventoryServiceClient) GetProduct(ctx context.Context, in *GetProductReq, opts ...grpc.CallOption) (*ProductInfo, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ProductInfo)
	err := c.cc.Invoke(ctx, InventoryService_GetProduct_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *inventoryServiceClient) ListProduct(ctx context.Context, in *ListProductReq, opts ...grpc.CallOption) (*ListProductResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListProductResp)
	err := c.cc.Invoke(ctx, InventoryService_ListProduct_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *inventoryServiceClient) GetProductTree(ctx context.Context, in *GetProductReq, opts ...grpc.CallOption) (*ProductTreeResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ProductTreeResp)
	err := c.cc.Invoke(ctx, InventoryService_GetProductTree_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *inventoryServiceClient) ListProductSummary(ctx context.Context, in *ListProductSummaryReq, opts ...grpc.CallOption) (*ListProductSummaryResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListProductSummaryResp)
	err := c.cc.Invoke(ctx, InventoryService_ListProductSummary_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *inventoryServiceClient) ListColorDetail(ctx context.Context, in *ListColorDetailReq, opts ...grpc.CallOption) (*ListColorDetailResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListColorDetailResp)
	err := c.cc.Invoke(ctx, InventoryService_ListColorDetail_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *inventoryServiceClient) CreateYarn(ctx context.Context, in *CreateYarnReq, opts ...grpc.CallOption) (*IdResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(IdResp)
	err := c.cc.Invoke(ctx, InventoryService_CreateYarn_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *inventoryServiceClient) UpdateYarn(ctx context.Context, in *UpdateYarnReq, opts ...grpc.CallOption) (*Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Empty)
	err := c.cc.Invoke(ctx, InventoryService_UpdateYarn_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *inventoryServiceClient) DeleteYarn(ctx context.Context, in *DeleteYarnReq, opts ...grpc.CallOption) (*Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Empty)
	err := c.cc.Invoke(ctx, InventoryService_DeleteYarn_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *inventoryServiceClient) GetYarn(ctx context.Context, in *GetYarnReq, opts ...grpc.CallOption) (*YarnInfo, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(YarnInfo)
	err := c.cc.Invoke(ctx, InventoryService_GetYarn_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *inventoryServiceClient) ListYarn(ctx context.Context, in *ListYarnReq, opts ...grpc.CallOption) (*ListYarnResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListYarnResp)
	err := c.cc.Invoke(ctx, InventoryService_ListYarn_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *inventoryServiceClient) CreateProductBatch(ctx context.Context, in *CreateProductBatchReq, opts ...grpc.CallOption) (*IdResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(IdResp)
	err := c.cc.Invoke(ctx, InventoryService_CreateProductBatch_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *inventoryServiceClient) UpdateProductBatch(ctx context.Context, in *UpdateProductBatchReq, opts ...grpc.CallOption) (*Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Empty)
	err := c.cc.Invoke(ctx, InventoryService_UpdateProductBatch_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *inventoryServiceClient) DeleteProductBatch(ctx context.Context, in *DeleteProductBatchReq, opts ...grpc.CallOption) (*Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Empty)
	err := c.cc.Invoke(ctx, InventoryService_DeleteProductBatch_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *inventoryServiceClient) ListProductBatch(ctx context.Context, in *ListProductBatchReq, opts ...grpc.CallOption) (*ListProductBatchResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListProductBatchResp)
	err := c.cc.Invoke(ctx, InventoryService_ListProductBatch_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *inventoryServiceClient) ListPanView(ctx context.Context, in *ListPanViewReq, opts ...grpc.CallOption) (*ListPanViewResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListPanViewResp)
	err := c.cc.Invoke(ctx, InventoryService_ListPanView_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *inventoryServiceClient) ListBoltView(ctx context.Context, in *ListBoltViewReq, opts ...grpc.CallOption) (*ListBoltViewResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListBoltViewResp)
	err := c.cc.Invoke(ctx, InventoryService_ListBoltView_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *inventoryServiceClient) ListPans(ctx context.Context, in *ListPanReq, opts ...grpc.CallOption) (*ListPanResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListPanResp)
	err := c.cc.Invoke(ctx, InventoryService_ListPans_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *inventoryServiceClient) SavePans(ctx context.Context, in *SavePansReq, opts ...grpc.CallOption) (*Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Empty)
	err := c.cc.Invoke(ctx, InventoryService_SavePans_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *inventoryServiceClient) ListBolts(ctx context.Context, in *ListBoltReq, opts ...grpc.CallOption) (*ListBoltResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListBoltResp)
	err := c.cc.Invoke(ctx, InventoryService_ListBolts_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *inventoryServiceClient) SaveBolts(ctx context.Context, in *SaveBoltsReq, opts ...grpc.CallOption) (*Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Empty)
	err := c.cc.Invoke(ctx, InventoryService_SaveBolts_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *inventoryServiceClient) ImportProducts(ctx context.Context, in *ImportProductReq, opts ...grpc.CallOption) (*ImportProductResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ImportProductResp)
	err := c.cc.Invoke(ctx, InventoryService_ImportProducts_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *inventoryServiceClient) ListImportLog(ctx context.Context, in *ListImportLogReq, opts ...grpc.CallOption) (*ListImportLogResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListImportLogResp)
	err := c.cc.Invoke(ctx, InventoryService_ListImportLog_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *inventoryServiceClient) GetStockSummary(ctx context.Context, in *StockSummaryReq, opts ...grpc.CallOption) (*StockSummaryResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(StockSummaryResp)
	err := c.cc.Invoke(ctx, InventoryService_GetStockSummary_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *inventoryServiceClient) GetStockGroup(ctx context.Context, in *StockGroupReq, opts ...grpc.CallOption) (*StockGroupResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(StockGroupResp)
	err := c.cc.Invoke(ctx, InventoryService_GetStockGroup_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *inventoryServiceClient) CreateStockCheck(ctx context.Context, in *CreateStockCheckReq, opts ...grpc.CallOption) (*IdResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(IdResp)
	err := c.cc.Invoke(ctx, InventoryService_CreateStockCheck_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *inventoryServiceClient) UpdateStockCheck(ctx context.Context, in *UpdateStockCheckReq, opts ...grpc.CallOption) (*Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Empty)
	err := c.cc.Invoke(ctx, InventoryService_UpdateStockCheck_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *inventoryServiceClient) ConfirmStockCheck(ctx context.Context, in *ConfirmStockCheckReq, opts ...grpc.CallOption) (*Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Empty)
	err := c.cc.Invoke(ctx, InventoryService_ConfirmStockCheck_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *inventoryServiceClient) GetStockCheck(ctx context.Context, in *GetStockCheckReq, opts ...grpc.CallOption) (*StockCheckInfo, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(StockCheckInfo)
	err := c.cc.Invoke(ctx, InventoryService_GetStockCheck_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *inventoryServiceClient) ListStockCheck(ctx context.Context, in *ListStockCheckReq, opts ...grpc.CallOption) (*ListStockCheckResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListStockCheckResp)
	err := c.cc.Invoke(ctx, InventoryService_ListStockCheck_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *inventoryServiceClient) CreateStockAdjust(ctx context.Context, in *CreateStockAdjustReq, opts ...grpc.CallOption) (*IdResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(IdResp)
	err := c.cc.Invoke(ctx, InventoryService_CreateStockAdjust_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *inventoryServiceClient) ApproveStockAdjust(ctx context.Context, in *ApproveStockAdjustReq, opts ...grpc.CallOption) (*Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Empty)
	err := c.cc.Invoke(ctx, InventoryService_ApproveStockAdjust_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *inventoryServiceClient) GetStockAdjust(ctx context.Context, in *GetStockAdjustReq, opts ...grpc.CallOption) (*StockAdjustInfo, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(StockAdjustInfo)
	err := c.cc.Invoke(ctx, InventoryService_GetStockAdjust_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *inventoryServiceClient) ListStockAdjust(ctx context.Context, in *ListStockAdjustReq, opts ...grpc.CallOption) (*ListStockAdjustResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListStockAdjustResp)
	err := c.cc.Invoke(ctx, InventoryService_ListStockAdjust_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// InventoryServiceServer is the server API for InventoryService service.
// All implementations must embed UnimplementedInventoryServiceServer
// for forward compatibility.
type InventoryServiceServer interface {
	// Product CRUD
	CreateProduct(context.Context, *CreateProductReq) (*IdResp, error)
	UpdateProduct(context.Context, *UpdateProductReq) (*Empty, error)
	DeleteProduct(context.Context, *DeleteProductReq) (*Empty, error)
	GetProduct(context.Context, *GetProductReq) (*ProductInfo, error)
	ListProduct(context.Context, *ListProductReq) (*ListProductResp, error)
	// Product Tree (panel 3)
	GetProductTree(context.Context, *GetProductReq) (*ProductTreeResp, error)
	// Product Summary (panel 1)
	ListProductSummary(context.Context, *ListProductSummaryReq) (*ListProductSummaryResp, error)
	// Color Detail (panel 2)
	ListColorDetail(context.Context, *ListColorDetailReq) (*ListColorDetailResp, error)
	// Yarn CRUD
	CreateYarn(context.Context, *CreateYarnReq) (*IdResp, error)
	UpdateYarn(context.Context, *UpdateYarnReq) (*Empty, error)
	DeleteYarn(context.Context, *DeleteYarnReq) (*Empty, error)
	GetYarn(context.Context, *GetYarnReq) (*YarnInfo, error)
	ListYarn(context.Context, *ListYarnReq) (*ListYarnResp, error)
	// Product Batch CRUD
	CreateProductBatch(context.Context, *CreateProductBatchReq) (*IdResp, error)
	UpdateProductBatch(context.Context, *UpdateProductBatchReq) (*Empty, error)
	DeleteProductBatch(context.Context, *DeleteProductBatchReq) (*Empty, error)
	ListProductBatch(context.Context, *ListProductBatchReq) (*ListProductBatchResp, error)
	// Pan / Bolt list views (dimension panels)
	ListPanView(context.Context, *ListPanViewReq) (*ListPanViewResp, error)
	ListBoltView(context.Context, *ListBoltViewReq) (*ListBoltViewResp, error)
	// Pan CRUD
	ListPans(context.Context, *ListPanReq) (*ListPanResp, error)
	SavePans(context.Context, *SavePansReq) (*Empty, error)
	// Bolt CRUD
	ListBolts(context.Context, *ListBoltReq) (*ListBoltResp, error)
	SaveBolts(context.Context, *SaveBoltsReq) (*Empty, error)
	// Import
	ImportProducts(context.Context, *ImportProductReq) (*ImportProductResp, error)
	ListImportLog(context.Context, *ListImportLogReq) (*ListImportLogResp, error)
	// Stock Statistics
	GetStockSummary(context.Context, *StockSummaryReq) (*StockSummaryResp, error)
	GetStockGroup(context.Context, *StockGroupReq) (*StockGroupResp, error)
	// Stock Check
	CreateStockCheck(context.Context, *CreateStockCheckReq) (*IdResp, error)
	UpdateStockCheck(context.Context, *UpdateStockCheckReq) (*Empty, error)
	ConfirmStockCheck(context.Context, *ConfirmStockCheckReq) (*Empty, error)
	GetStockCheck(context.Context, *GetStockCheckReq) (*StockCheckInfo, error)
	ListStockCheck(context.Context, *ListStockCheckReq) (*ListStockCheckResp, error)
	// Stock Adjust
	CreateStockAdjust(context.Context, *CreateStockAdjustReq) (*IdResp, error)
	ApproveStockAdjust(context.Context, *ApproveStockAdjustReq) (*Empty, error)
	GetStockAdjust(context.Context, *GetStockAdjustReq) (*StockAdjustInfo, error)
	ListStockAdjust(context.Context, *ListStockAdjustReq) (*ListStockAdjustResp, error)
	mustEmbedUnimplementedInventoryServiceServer()
}

// UnimplementedInventoryServiceServer must be embedded to have
// forward compatible implementations.
//
// NOTE: this should be embedded by value instead of pointer to avoid a nil
// pointer dereference when methods are called.
type UnimplementedInventoryServiceServer struct{}

func (UnimplementedInventoryServiceServer) CreateProduct(context.Context, *CreateProductReq) (*IdResp, error) {
	return nil, status.Error(codes.Unimplemented, "method CreateProduct not implemented")
}
func (UnimplementedInventoryServiceServer) UpdateProduct(context.Context, *UpdateProductReq) (*Empty, error) {
	return nil, status.Error(codes.Unimplemented, "method UpdateProduct not implemented")
}
func (UnimplementedInventoryServiceServer) DeleteProduct(context.Context, *DeleteProductReq) (*Empty, error) {
	return nil, status.Error(codes.Unimplemented, "method DeleteProduct not implemented")
}
func (UnimplementedInventoryServiceServer) GetProduct(context.Context, *GetProductReq) (*ProductInfo, error) {
	return nil, status.Error(codes.Unimplemented, "method GetProduct not implemented")
}
func (UnimplementedInventoryServiceServer) ListProduct(context.Context, *ListProductReq) (*ListProductResp, error) {
	return nil, status.Error(codes.Unimplemented, "method ListProduct not implemented")
}
func (UnimplementedInventoryServiceServer) GetProductTree(context.Context, *GetProductReq) (*ProductTreeResp, error) {
	return nil, status.Error(codes.Unimplemented, "method GetProductTree not implemented")
}
func (UnimplementedInventoryServiceServer) ListProductSummary(context.Context, *ListProductSummaryReq) (*ListProductSummaryResp, error) {
	return nil, status.Error(codes.Unimplemented, "method ListProductSummary not implemented")
}
func (UnimplementedInventoryServiceServer) ListColorDetail(context.Context, *ListColorDetailReq) (*ListColorDetailResp, error) {
	return nil, status.Error(codes.Unimplemented, "method ListColorDetail not implemented")
}
func (UnimplementedInventoryServiceServer) CreateYarn(context.Context, *CreateYarnReq) (*IdResp, error) {
	return nil, status.Error(codes.Unimplemented, "method CreateYarn not implemented")
}
func (UnimplementedInventoryServiceServer) UpdateYarn(context.Context, *UpdateYarnReq) (*Empty, error) {
	return nil, status.Error(codes.Unimplemented, "method UpdateYarn not implemented")
}
func (UnimplementedInventoryServiceServer) DeleteYarn(context.Context, *DeleteYarnReq) (*Empty, error) {
	return nil, status.Error(codes.Unimplemented, "method DeleteYarn not implemented")
}
func (UnimplementedInventoryServiceServer) GetYarn(context.Context, *GetYarnReq) (*YarnInfo, error) {
	return nil, status.Error(codes.Unimplemented, "method GetYarn not implemented")
}
func (UnimplementedInventoryServiceServer) ListYarn(context.Context, *ListYarnReq) (*ListYarnResp, error) {
	return nil, status.Error(codes.Unimplemented, "method ListYarn not implemented")
}
func (UnimplementedInventoryServiceServer) CreateProductBatch(context.Context, *CreateProductBatchReq) (*IdResp, error) {
	return nil, status.Error(codes.Unimplemented, "method CreateProductBatch not implemented")
}
func (UnimplementedInventoryServiceServer) UpdateProductBatch(context.Context, *UpdateProductBatchReq) (*Empty, error) {
	return nil, status.Error(codes.Unimplemented, "method UpdateProductBatch not implemented")
}
func (UnimplementedInventoryServiceServer) DeleteProductBatch(context.Context, *DeleteProductBatchReq) (*Empty, error) {
	return nil, status.Error(codes.Unimplemented, "method DeleteProductBatch not implemented")
}
func (UnimplementedInventoryServiceServer) ListProductBatch(context.Context, *ListProductBatchReq) (*ListProductBatchResp, error) {
	return nil, status.Error(codes.Unimplemented, "method ListProductBatch not implemented")
}
func (UnimplementedInventoryServiceServer) ListPanView(context.Context, *ListPanViewReq) (*ListPanViewResp, error) {
	return nil, status.Error(codes.Unimplemented, "method ListPanView not implemented")
}
func (UnimplementedInventoryServiceServer) ListBoltView(context.Context, *ListBoltViewReq) (*ListBoltViewResp, error) {
	return nil, status.Error(codes.Unimplemented, "method ListBoltView not implemented")
}
func (UnimplementedInventoryServiceServer) ListPans(context.Context, *ListPanReq) (*ListPanResp, error) {
	return nil, status.Error(codes.Unimplemented, "method ListPans not implemented")
}
func (UnimplementedInventoryServiceServer) SavePans(context.Context, *SavePansReq) (*Empty, error) {
	return nil, status.Error(codes.Unimplemented, "method SavePans not implemented")
}
func (UnimplementedInventoryServiceServer) ListBolts(context.Context, *ListBoltReq) (*ListBoltResp, error) {
	return nil, status.Error(codes.Unimplemented, "method ListBolts not implemented")
}
func (UnimplementedInventoryServiceServer) SaveBolts(context.Context, *SaveBoltsReq) (*Empty, error) {
	return nil, status.Error(codes.Unimplemented, "method SaveBolts not implemented")
}
func (UnimplementedInventoryServiceServer) ImportProducts(context.Context, *ImportProductReq) (*ImportProductResp, error) {
	return nil, status.Error(codes.Unimplemented, "method ImportProducts not implemented")
}
func (UnimplementedInventoryServiceServer) ListImportLog(context.Context, *ListImportLogReq) (*ListImportLogResp, error) {
	return nil, status.Error(codes.Unimplemented, "method ListImportLog not implemented")
}
func (UnimplementedInventoryServiceServer) GetStockSummary(context.Context, *StockSummaryReq) (*StockSummaryResp, error) {
	return nil, status.Error(codes.Unimplemented, "method GetStockSummary not implemented")
}
func (UnimplementedInventoryServiceServer) GetStockGroup(context.Context, *StockGroupReq) (*StockGroupResp, error) {
	return nil, status.Error(codes.Unimplemented, "method GetStockGroup not implemented")
}
func (UnimplementedInventoryServiceServer) CreateStockCheck(context.Context, *CreateStockCheckReq) (*IdResp, error) {
	return nil, status.Error(codes.Unimplemented, "method CreateStockCheck not implemented")
}
func (UnimplementedInventoryServiceServer) UpdateStockCheck(context.Context, *UpdateStockCheckReq) (*Empty, error) {
	return nil, status.Error(codes.Unimplemented, "method UpdateStockCheck not implemented")
}
func (UnimplementedInventoryServiceServer) ConfirmStockCheck(context.Context, *ConfirmStockCheckReq) (*Empty, error) {
	return nil, status.Error(codes.Unimplemented, "method ConfirmStockCheck not implemented")
}
func (UnimplementedInventoryServiceServer) GetStockCheck(context.Context, *GetStockCheckReq) (*StockCheckInfo, error) {
	return nil, status.Error(codes.Unimplemented, "method GetStockCheck not implemented")
}
func (UnimplementedInventoryServiceServer) ListStockCheck(context.Context, *ListStockCheckReq) (*ListStockCheckResp, error) {
	return nil, status.Error(codes.Unimplemented, "method ListStockCheck not implemented")
}
func (UnimplementedInventoryServiceServer) CreateStockAdjust(context.Context, *CreateStockAdjustReq) (*IdResp, error) {
	return nil, status.Error(codes.Unimplemented, "method CreateStockAdjust not implemented")
}
func (UnimplementedInventoryServiceServer) ApproveStockAdjust(context.Context, *ApproveStockAdjustReq) (*Empty, error) {
	return nil, status.Error(codes.Unimplemented, "method ApproveStockAdjust not implemented")
}
func (UnimplementedInventoryServiceServer) GetStockAdjust(context.Context, *GetStockAdjustReq) (*StockAdjustInfo, error) {
	return nil, status.Error(codes.Unimplemented, "method GetStockAdjust not implemented")
}
func (UnimplementedInventoryServiceServer) ListStockAdjust(context.Context, *ListStockAdjustReq) (*ListStockAdjustResp, error) {
	return nil, status.Error(codes.Unimplemented, "method ListStockAdjust not implemented")
}
func (UnimplementedInventoryServiceServer) mustEmbedUnimplementedInventoryServiceServer() {}
func (UnimplementedInventoryServiceServer) testEmbeddedByValue()                          {}

// UnsafeInventoryServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to InventoryServiceServer will
// result in compilation errors.
type UnsafeInventoryServiceServer interface {
	mustEmbedUnimplementedInventoryServiceServer()
}

func RegisterInventoryServiceServer(s grpc.ServiceRegistrar, srv InventoryServiceServer) {
	// If the following call panics, it indicates UnimplementedInventoryServiceServer was
	// embedded by pointer and is nil.  This will cause panics if an
	// unimplemented method is ever invoked, so we test this at initialization
	// time to prevent it from happening at runtime later due to I/O.
	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
		t.testEmbeddedByValue()
	}
	s.RegisterService(&InventoryService_ServiceDesc, srv)
}

func _InventoryService_CreateProduct_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateProductReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InventoryServiceServer).CreateProduct(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InventoryService_CreateProduct_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InventoryServiceServer).CreateProduct(ctx, req.(*CreateProductReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _InventoryService_UpdateProduct_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateProductReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InventoryServiceServer).UpdateProduct(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InventoryService_UpdateProduct_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InventoryServiceServer).UpdateProduct(ctx, req.(*UpdateProductReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _InventoryService_DeleteProduct_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteProductReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InventoryServiceServer).DeleteProduct(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InventoryService_DeleteProduct_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InventoryServiceServer).DeleteProduct(ctx, req.(*DeleteProductReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _InventoryService_GetProduct_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetProductReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InventoryServiceServer).GetProduct(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InventoryService_GetProduct_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InventoryServiceServer).GetProduct(ctx, req.(*GetProductReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _InventoryService_ListProduct_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListProductReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InventoryServiceServer).ListProduct(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InventoryService_ListProduct_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InventoryServiceServer).ListProduct(ctx, req.(*ListProductReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _InventoryService_GetProductTree_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetProductReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InventoryServiceServer).GetProductTree(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InventoryService_GetProductTree_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InventoryServiceServer).GetProductTree(ctx, req.(*GetProductReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _InventoryService_ListProductSummary_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListProductSummaryReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InventoryServiceServer).ListProductSummary(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InventoryService_ListProductSummary_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InventoryServiceServer).ListProductSummary(ctx, req.(*ListProductSummaryReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _InventoryService_ListColorDetail_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListColorDetailReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InventoryServiceServer).ListColorDetail(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InventoryService_ListColorDetail_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InventoryServiceServer).ListColorDetail(ctx, req.(*ListColorDetailReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _InventoryService_CreateYarn_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateYarnReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InventoryServiceServer).CreateYarn(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InventoryService_CreateYarn_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InventoryServiceServer).CreateYarn(ctx, req.(*CreateYarnReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _InventoryService_UpdateYarn_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateYarnReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InventoryServiceServer).UpdateYarn(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InventoryService_UpdateYarn_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InventoryServiceServer).UpdateYarn(ctx, req.(*UpdateYarnReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _InventoryService_DeleteYarn_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteYarnReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InventoryServiceServer).DeleteYarn(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InventoryService_DeleteYarn_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InventoryServiceServer).DeleteYarn(ctx, req.(*DeleteYarnReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _InventoryService_GetYarn_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetYarnReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InventoryServiceServer).GetYarn(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InventoryService_GetYarn_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InventoryServiceServer).GetYarn(ctx, req.(*GetYarnReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _InventoryService_ListYarn_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListYarnReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InventoryServiceServer).ListYarn(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InventoryService_ListYarn_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InventoryServiceServer).ListYarn(ctx, req.(*ListYarnReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _InventoryService_CreateProductBatch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateProductBatchReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InventoryServiceServer).CreateProductBatch(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InventoryService_CreateProductBatch_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InventoryServiceServer).CreateProductBatch(ctx, req.(*CreateProductBatchReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _InventoryService_UpdateProductBatch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateProductBatchReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InventoryServiceServer).UpdateProductBatch(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InventoryService_UpdateProductBatch_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InventoryServiceServer).UpdateProductBatch(ctx, req.(*UpdateProductBatchReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _InventoryService_DeleteProductBatch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteProductBatchReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InventoryServiceServer).DeleteProductBatch(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InventoryService_DeleteProductBatch_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InventoryServiceServer).DeleteProductBatch(ctx, req.(*DeleteProductBatchReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _InventoryService_ListProductBatch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListProductBatchReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InventoryServiceServer).ListProductBatch(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InventoryService_ListProductBatch_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InventoryServiceServer).ListProductBatch(ctx, req.(*ListProductBatchReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _InventoryService_ListPanView_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListPanViewReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InventoryServiceServer).ListPanView(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InventoryService_ListPanView_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InventoryServiceServer).ListPanView(ctx, req.(*ListPanViewReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _InventoryService_ListBoltView_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListBoltViewReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InventoryServiceServer).ListBoltView(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InventoryService_ListBoltView_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InventoryServiceServer).ListBoltView(ctx, req.(*ListBoltViewReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _InventoryService_ListPans_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListPanReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InventoryServiceServer).ListPans(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InventoryService_ListPans_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InventoryServiceServer).ListPans(ctx, req.(*ListPanReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _InventoryService_SavePans_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SavePansReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InventoryServiceServer).SavePans(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InventoryService_SavePans_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InventoryServiceServer).SavePans(ctx, req.(*SavePansReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _InventoryService_ListBolts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListBoltReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InventoryServiceServer).ListBolts(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InventoryService_ListBolts_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InventoryServiceServer).ListBolts(ctx, req.(*ListBoltReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _InventoryService_SaveBolts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SaveBoltsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InventoryServiceServer).SaveBolts(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InventoryService_SaveBolts_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InventoryServiceServer).SaveBolts(ctx, req.(*SaveBoltsReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _InventoryService_ImportProducts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ImportProductReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InventoryServiceServer).ImportProducts(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InventoryService_ImportProducts_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InventoryServiceServer).ImportProducts(ctx, req.(*ImportProductReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _InventoryService_ListImportLog_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListImportLogReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InventoryServiceServer).ListImportLog(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InventoryService_ListImportLog_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InventoryServiceServer).ListImportLog(ctx, req.(*ListImportLogReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _InventoryService_GetStockSummary_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StockSummaryReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InventoryServiceServer).GetStockSummary(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InventoryService_GetStockSummary_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InventoryServiceServer).GetStockSummary(ctx, req.(*StockSummaryReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _InventoryService_GetStockGroup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StockGroupReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InventoryServiceServer).GetStockGroup(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InventoryService_GetStockGroup_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InventoryServiceServer).GetStockGroup(ctx, req.(*StockGroupReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _InventoryService_CreateStockCheck_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateStockCheckReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InventoryServiceServer).CreateStockCheck(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InventoryService_CreateStockCheck_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InventoryServiceServer).CreateStockCheck(ctx, req.(*CreateStockCheckReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _InventoryService_UpdateStockCheck_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateStockCheckReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InventoryServiceServer).UpdateStockCheck(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InventoryService_UpdateStockCheck_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InventoryServiceServer).UpdateStockCheck(ctx, req.(*UpdateStockCheckReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _InventoryService_ConfirmStockCheck_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ConfirmStockCheckReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InventoryServiceServer).ConfirmStockCheck(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InventoryService_ConfirmStockCheck_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InventoryServiceServer).ConfirmStockCheck(ctx, req.(*ConfirmStockCheckReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _InventoryService_GetStockCheck_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetStockCheckReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InventoryServiceServer).GetStockCheck(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InventoryService_GetStockCheck_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InventoryServiceServer).GetStockCheck(ctx, req.(*GetStockCheckReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _InventoryService_ListStockCheck_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListStockCheckReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InventoryServiceServer).ListStockCheck(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InventoryService_ListStockCheck_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InventoryServiceServer).ListStockCheck(ctx, req.(*ListStockCheckReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _InventoryService_CreateStockAdjust_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateStockAdjustReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InventoryServiceServer).CreateStockAdjust(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InventoryService_CreateStockAdjust_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InventoryServiceServer).CreateStockAdjust(ctx, req.(*CreateStockAdjustReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _InventoryService_ApproveStockAdjust_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ApproveStockAdjustReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InventoryServiceServer).ApproveStockAdjust(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InventoryService_ApproveStockAdjust_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InventoryServiceServer).ApproveStockAdjust(ctx, req.(*ApproveStockAdjustReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _InventoryService_GetStockAdjust_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetStockAdjustReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InventoryServiceServer).GetStockAdjust(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InventoryService_GetStockAdjust_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InventoryServiceServer).GetStockAdjust(ctx, req.(*GetStockAdjustReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _InventoryService_ListStockAdjust_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListStockAdjustReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InventoryServiceServer).ListStockAdjust(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InventoryService_ListStockAdjust_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InventoryServiceServer).ListStockAdjust(ctx, req.(*ListStockAdjustReq))
	}
	return interceptor(ctx, in, info, handler)
}

// InventoryService_ServiceDesc is the grpc.ServiceDesc for InventoryService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var InventoryService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "inventory.InventoryService",
	HandlerType: (*InventoryServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateProduct",
			Handler:    _InventoryService_CreateProduct_Handler,
		},
		{
			MethodName: "UpdateProduct",
			Handler:    _InventoryService_UpdateProduct_Handler,
		},
		{
			MethodName: "DeleteProduct",
			Handler:    _InventoryService_DeleteProduct_Handler,
		},
		{
			MethodName: "GetProduct",
			Handler:    _InventoryService_GetProduct_Handler,
		},
		{
			MethodName: "ListProduct",
			Handler:    _InventoryService_ListProduct_Handler,
		},
		{
			MethodName: "GetProductTree",
			Handler:    _InventoryService_GetProductTree_Handler,
		},
		{
			MethodName: "ListProductSummary",
			Handler:    _InventoryService_ListProductSummary_Handler,
		},
		{
			MethodName: "ListColorDetail",
			Handler:    _InventoryService_ListColorDetail_Handler,
		},
		{
			MethodName: "CreateYarn",
			Handler:    _InventoryService_CreateYarn_Handler,
		},
		{
			MethodName: "UpdateYarn",
			Handler:    _InventoryService_UpdateYarn_Handler,
		},
		{
			MethodName: "DeleteYarn",
			Handler:    _InventoryService_DeleteYarn_Handler,
		},
		{
			MethodName: "GetYarn",
			Handler:    _InventoryService_GetYarn_Handler,
		},
		{
			MethodName: "ListYarn",
			Handler:    _InventoryService_ListYarn_Handler,
		},
		{
			MethodName: "CreateProductBatch",
			Handler:    _InventoryService_CreateProductBatch_Handler,
		},
		{
			MethodName: "UpdateProductBatch",
			Handler:    _InventoryService_UpdateProductBatch_Handler,
		},
		{
			MethodName: "DeleteProductBatch",
			Handler:    _InventoryService_DeleteProductBatch_Handler,
		},
		{
			MethodName: "ListProductBatch",
			Handler:    _InventoryService_ListProductBatch_Handler,
		},
		{
			MethodName: "ListPanView",
			Handler:    _InventoryService_ListPanView_Handler,
		},
		{
			MethodName: "ListBoltView",
			Handler:    _InventoryService_ListBoltView_Handler,
		},
		{
			MethodName: "ListPans",
			Handler:    _InventoryService_ListPans_Handler,
		},
		{
			MethodName: "SavePans",
			Handler:    _InventoryService_SavePans_Handler,
		},
		{
			MethodName: "ListBolts",
			Handler:    _InventoryService_ListBolts_Handler,
		},
		{
			MethodName: "SaveBolts",
			Handler:    _InventoryService_SaveBolts_Handler,
		},
		{
			MethodName: "ImportProducts",
			Handler:    _InventoryService_ImportProducts_Handler,
		},
		{
			MethodName: "ListImportLog",
			Handler:    _InventoryService_ListImportLog_Handler,
		},
		{
			MethodName: "GetStockSummary",
			Handler:    _InventoryService_GetStockSummary_Handler,
		},
		{
			MethodName: "GetStockGroup",
			Handler:    _InventoryService_GetStockGroup_Handler,
		},
		{
			MethodName: "CreateStockCheck",
			Handler:    _InventoryService_CreateStockCheck_Handler,
		},
		{
			MethodName: "UpdateStockCheck",
			Handler:    _InventoryService_UpdateStockCheck_Handler,
		},
		{
			MethodName: "ConfirmStockCheck",
			Handler:    _InventoryService_ConfirmStockCheck_Handler,
		},
		{
			MethodName: "GetStockCheck",
			Handler:    _InventoryService_GetStockCheck_Handler,
		},
		{
			MethodName: "ListStockCheck",
			Handler:    _InventoryService_ListStockCheck_Handler,
		},
		{
			MethodName: "CreateStockAdjust",
			Handler:    _InventoryService_CreateStockAdjust_Handler,
		},
		{
			MethodName: "ApproveStockAdjust",
			Handler:    _InventoryService_ApproveStockAdjust_Handler,
		},
		{
			MethodName: "GetStockAdjust",
			Handler:    _InventoryService_GetStockAdjust_Handler,
		},
		{
			MethodName: "ListStockAdjust",
			Handler:    _InventoryService_ListStockAdjust_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "inventory.proto",
}