// Code generated by protoc-gen-triple. DO NOT EDIT.
//
// Source: hipstershop.proto
package demo

import (
	"context"
)

import (
	"dubbo.apache.org/dubbo-go/v3"
	"dubbo.apache.org/dubbo-go/v3/client"
	"dubbo.apache.org/dubbo-go/v3/common"
	"dubbo.apache.org/dubbo-go/v3/common/constant"
	"dubbo.apache.org/dubbo-go/v3/protocol/triple/triple_protocol"
	"dubbo.apache.org/dubbo-go/v3/server"
)

// This is a compile-time assertion to ensure that this generated file and the Triple package
// are compatible. If you get a compiler error that this constant is not defined, this code was
// generated with a version of Triple newer than the one compiled into your binary. You can fix the
// problem by either regenerating this code with an older version of Triple or updating the Triple
// version compiled into your binary.
const _ = triple_protocol.IsAtLeastVersion0_1_0

const (
	// CartServiceName is the fully-qualified name of the CartService service.
	CartServiceName = "hipstershop.CartService"
)

// These constants are the fully-qualified names of the RPCs defined in this package. They're
// exposed at runtime as procedure and as the final two segments of the HTTP route.
//
// Note that these are different from the fully-qualified method names used by
// google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
// reflection-formatted method names, remove the leading slash and convert the remaining slash to a
// period.
const (
	// CartServiceAddItemProcedure is the fully-qualified name of the CartService's AddItem RPC.
	CartServiceAddItemProcedure = "/hipstershop.CartService/AddItem"
	// CartServiceGetCartProcedure is the fully-qualified name of the CartService's GetCart RPC.
	CartServiceGetCartProcedure = "/hipstershop.CartService/GetCart"
	// CartServiceEmptyCartProcedure is the fully-qualified name of the CartService's EmptyCart RPC.
	CartServiceEmptyCartProcedure = "/hipstershop.CartService/EmptyCart"
)
const (
	// RecommendationServiceName is the fully-qualified name of the RecommendationService service.
	RecommendationServiceName = "hipstershop.RecommendationService"
)

// These constants are the fully-qualified names of the RPCs defined in this package. They're
// exposed at runtime as procedure and as the final two segments of the HTTP route.
//
// Note that these are different from the fully-qualified method names used by
// google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
// reflection-formatted method names, remove the leading slash and convert the remaining slash to a
// period.
const (
	// RecommendationServiceListRecommendationsProcedure is the fully-qualified name of the RecommendationService's ListRecommendations RPC.
	RecommendationServiceListRecommendationsProcedure = "/hipstershop.RecommendationService/ListRecommendations"
)
const (
	// ProductCatalogServiceName is the fully-qualified name of the ProductCatalogService service.
	ProductCatalogServiceName = "hipstershop.ProductCatalogService"
)

// These constants are the fully-qualified names of the RPCs defined in this package. They're
// exposed at runtime as procedure and as the final two segments of the HTTP route.
//
// Note that these are different from the fully-qualified method names used by
// google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
// reflection-formatted method names, remove the leading slash and convert the remaining slash to a
// period.
const (
	// ProductCatalogServiceListProductsProcedure is the fully-qualified name of the ProductCatalogService's ListProducts RPC.
	ProductCatalogServiceListProductsProcedure = "/hipstershop.ProductCatalogService/ListProducts"
	// ProductCatalogServiceGetProductProcedure is the fully-qualified name of the ProductCatalogService's GetProduct RPC.
	ProductCatalogServiceGetProductProcedure = "/hipstershop.ProductCatalogService/GetProduct"
	// ProductCatalogServiceSearchProductsProcedure is the fully-qualified name of the ProductCatalogService's SearchProducts RPC.
	ProductCatalogServiceSearchProductsProcedure = "/hipstershop.ProductCatalogService/SearchProducts"
)
const (
	// ShippingServiceName is the fully-qualified name of the ShippingService service.
	ShippingServiceName = "hipstershop.ShippingService"
)

// These constants are the fully-qualified names of the RPCs defined in this package. They're
// exposed at runtime as procedure and as the final two segments of the HTTP route.
//
// Note that these are different from the fully-qualified method names used by
// google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
// reflection-formatted method names, remove the leading slash and convert the remaining slash to a
// period.
const (
	// ShippingServiceGetQuoteProcedure is the fully-qualified name of the ShippingService's GetQuote RPC.
	ShippingServiceGetQuoteProcedure = "/hipstershop.ShippingService/GetQuote"
	// ShippingServiceShipOrderProcedure is the fully-qualified name of the ShippingService's ShipOrder RPC.
	ShippingServiceShipOrderProcedure = "/hipstershop.ShippingService/ShipOrder"
)
const (
	// CurrencyServiceName is the fully-qualified name of the CurrencyService service.
	CurrencyServiceName = "hipstershop.CurrencyService"
)

// These constants are the fully-qualified names of the RPCs defined in this package. They're
// exposed at runtime as procedure and as the final two segments of the HTTP route.
//
// Note that these are different from the fully-qualified method names used by
// google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
// reflection-formatted method names, remove the leading slash and convert the remaining slash to a
// period.
const (
	// CurrencyServiceGetSupportedCurrenciesProcedure is the fully-qualified name of the CurrencyService's GetSupportedCurrencies RPC.
	CurrencyServiceGetSupportedCurrenciesProcedure = "/hipstershop.CurrencyService/GetSupportedCurrencies"
	// CurrencyServiceConvertProcedure is the fully-qualified name of the CurrencyService's Convert RPC.
	CurrencyServiceConvertProcedure = "/hipstershop.CurrencyService/Convert"
)
const (
	// PaymentServiceName is the fully-qualified name of the PaymentService service.
	PaymentServiceName = "hipstershop.PaymentService"
)

// These constants are the fully-qualified names of the RPCs defined in this package. They're
// exposed at runtime as procedure and as the final two segments of the HTTP route.
//
// Note that these are different from the fully-qualified method names used by
// google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
// reflection-formatted method names, remove the leading slash and convert the remaining slash to a
// period.
const (
	// PaymentServiceChargeProcedure is the fully-qualified name of the PaymentService's Charge RPC.
	PaymentServiceChargeProcedure = "/hipstershop.PaymentService/Charge"
)
const (
	// EmailServiceName is the fully-qualified name of the EmailService service.
	EmailServiceName = "hipstershop.EmailService"
)

// These constants are the fully-qualified names of the RPCs defined in this package. They're
// exposed at runtime as procedure and as the final two segments of the HTTP route.
//
// Note that these are different from the fully-qualified method names used by
// google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
// reflection-formatted method names, remove the leading slash and convert the remaining slash to a
// period.
const (
	// EmailServiceSendOrderConfirmationProcedure is the fully-qualified name of the EmailService's SendOrderConfirmation RPC.
	EmailServiceSendOrderConfirmationProcedure = "/hipstershop.EmailService/SendOrderConfirmation"
)
const (
	// CheckoutServiceName is the fully-qualified name of the CheckoutService service.
	CheckoutServiceName = "hipstershop.CheckoutService"
)

// These constants are the fully-qualified names of the RPCs defined in this package. They're
// exposed at runtime as procedure and as the final two segments of the HTTP route.
//
// Note that these are different from the fully-qualified method names used by
// google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
// reflection-formatted method names, remove the leading slash and convert the remaining slash to a
// period.
const (
	// CheckoutServicePlaceOrderProcedure is the fully-qualified name of the CheckoutService's PlaceOrder RPC.
	CheckoutServicePlaceOrderProcedure = "/hipstershop.CheckoutService/PlaceOrder"
)
const (
	// AdServiceName is the fully-qualified name of the AdService service.
	AdServiceName = "hipstershop.AdService"
)

// These constants are the fully-qualified names of the RPCs defined in this package. They're
// exposed at runtime as procedure and as the final two segments of the HTTP route.
//
// Note that these are different from the fully-qualified method names used by
// google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
// reflection-formatted method names, remove the leading slash and convert the remaining slash to a
// period.
const (
	// AdServiceGetAdsProcedure is the fully-qualified name of the AdService's GetAds RPC.
	AdServiceGetAdsProcedure = "/hipstershop.AdService/GetAds"
)

var (
	_ CartService = (*CartServiceImpl)(nil)

	_ RecommendationService = (*RecommendationServiceImpl)(nil)

	_ ProductCatalogService = (*ProductCatalogServiceImpl)(nil)

	_ ShippingService = (*ShippingServiceImpl)(nil)

	_ CurrencyService = (*CurrencyServiceImpl)(nil)

	_ PaymentService = (*PaymentServiceImpl)(nil)

	_ EmailService = (*EmailServiceImpl)(nil)

	_ CheckoutService = (*CheckoutServiceImpl)(nil)

	_ AdService = (*AdServiceImpl)(nil)
)

// CartService is a client for the hipstershop.CartService service.
type CartService interface {
	AddItem(ctx context.Context, req *AddItemRequest, opts ...client.CallOption) (*Empty, error)
	GetCart(ctx context.Context, req *GetCartRequest, opts ...client.CallOption) (*Cart, error)
	EmptyCart(ctx context.Context, req *EmptyCartRequest, opts ...client.CallOption) (*Empty, error)
}

// RecommendationService is a client for the hipstershop.RecommendationService service.
type RecommendationService interface {
	ListRecommendations(ctx context.Context, req *ListRecommendationsRequest, opts ...client.CallOption) (*ListRecommendationsResponse, error)
}

// ProductCatalogService is a client for the hipstershop.ProductCatalogService service.
type ProductCatalogService interface {
	ListProducts(ctx context.Context, req *Empty, opts ...client.CallOption) (*ListProductsResponse, error)
	GetProduct(ctx context.Context, req *GetProductRequest, opts ...client.CallOption) (*Product, error)
	SearchProducts(ctx context.Context, req *SearchProductsRequest, opts ...client.CallOption) (*SearchProductsResponse, error)
}

// ShippingService is a client for the hipstershop.ShippingService service.
type ShippingService interface {
	GetQuote(ctx context.Context, req *GetQuoteRequest, opts ...client.CallOption) (*GetQuoteResponse, error)
	ShipOrder(ctx context.Context, req *ShipOrderRequest, opts ...client.CallOption) (*ShipOrderResponse, error)
}

// CurrencyService is a client for the hipstershop.CurrencyService service.
type CurrencyService interface {
	GetSupportedCurrencies(ctx context.Context, req *Empty, opts ...client.CallOption) (*GetSupportedCurrenciesResponse, error)
	Convert(ctx context.Context, req *CurrencyConversionRequest, opts ...client.CallOption) (*Money, error)
}

// PaymentService is a client for the hipstershop.PaymentService service.
type PaymentService interface {
	Charge(ctx context.Context, req *ChargeRequest, opts ...client.CallOption) (*ChargeResponse, error)
}

// EmailService is a client for the hipstershop.EmailService service.
type EmailService interface {
	SendOrderConfirmation(ctx context.Context, req *SendOrderConfirmationRequest, opts ...client.CallOption) (*Empty, error)
}

// CheckoutService is a client for the hipstershop.CheckoutService service.
type CheckoutService interface {
	PlaceOrder(ctx context.Context, req *PlaceOrderRequest, opts ...client.CallOption) (*PlaceOrderResponse, error)
}

// AdService is a client for the hipstershop.AdService service.
type AdService interface {
	GetAds(ctx context.Context, req *AdRequest, opts ...client.CallOption) (*AdResponse, error)
}

// NewCartService constructs a client for the demo.CartService service.
func NewCartService(cli *client.Client, opts ...client.ReferenceOption) (CartService, error) {
	conn, err := cli.DialWithInfo("hipstershop.CartService", &CartService_ClientInfo, opts...)
	if err != nil {
		return nil, err
	}
	return &CartServiceImpl{
		conn: conn,
	}, nil
}

func SetConsumerCartService(srv common.RPCService) {
	dubbo.SetConsumerServiceWithInfo(srv, &CartService_ClientInfo)
}

// CartServiceImpl implements CartService.
type CartServiceImpl struct {
	conn *client.Connection
}

func (c *CartServiceImpl) AddItem(ctx context.Context, req *AddItemRequest, opts ...client.CallOption) (*Empty, error) {
	resp := new(Empty)
	if err := c.conn.CallUnary(ctx, []interface{}{req}, resp, "AddItem", opts...); err != nil {
		return nil, err
	}
	return resp, nil
}

func (c *CartServiceImpl) GetCart(ctx context.Context, req *GetCartRequest, opts ...client.CallOption) (*Cart, error) {
	resp := new(Cart)
	if err := c.conn.CallUnary(ctx, []interface{}{req}, resp, "GetCart", opts...); err != nil {
		return nil, err
	}
	return resp, nil
}

func (c *CartServiceImpl) EmptyCart(ctx context.Context, req *EmptyCartRequest, opts ...client.CallOption) (*Empty, error) {
	resp := new(Empty)
	if err := c.conn.CallUnary(ctx, []interface{}{req}, resp, "EmptyCart", opts...); err != nil {
		return nil, err
	}
	return resp, nil
}

// NewRecommendationService constructs a client for the demo.RecommendationService service.
func NewRecommendationService(cli *client.Client, opts ...client.ReferenceOption) (RecommendationService, error) {
	conn, err := cli.DialWithInfo("hipstershop.RecommendationService", &RecommendationService_ClientInfo, opts...)
	if err != nil {
		return nil, err
	}
	return &RecommendationServiceImpl{
		conn: conn,
	}, nil
}

func SetConsumerRecommendationService(srv common.RPCService) {
	dubbo.SetConsumerServiceWithInfo(srv, &RecommendationService_ClientInfo)
}

// RecommendationServiceImpl implements RecommendationService.
type RecommendationServiceImpl struct {
	conn *client.Connection
}

func (c *RecommendationServiceImpl) ListRecommendations(ctx context.Context, req *ListRecommendationsRequest, opts ...client.CallOption) (*ListRecommendationsResponse, error) {
	resp := new(ListRecommendationsResponse)
	if err := c.conn.CallUnary(ctx, []interface{}{req}, resp, "ListRecommendations", opts...); err != nil {
		return nil, err
	}
	return resp, nil
}

// NewProductCatalogService constructs a client for the demo.ProductCatalogService service.
func NewProductCatalogService(cli *client.Client, opts ...client.ReferenceOption) (ProductCatalogService, error) {
	conn, err := cli.DialWithInfo("hipstershop.ProductCatalogService", &ProductCatalogService_ClientInfo, opts...)
	if err != nil {
		return nil, err
	}
	return &ProductCatalogServiceImpl{
		conn: conn,
	}, nil
}

func SetConsumerProductCatalogService(srv common.RPCService) {
	dubbo.SetConsumerServiceWithInfo(srv, &ProductCatalogService_ClientInfo)
}

// ProductCatalogServiceImpl implements ProductCatalogService.
type ProductCatalogServiceImpl struct {
	conn *client.Connection
}

func (c *ProductCatalogServiceImpl) ListProducts(ctx context.Context, req *Empty, opts ...client.CallOption) (*ListProductsResponse, error) {
	resp := new(ListProductsResponse)
	if err := c.conn.CallUnary(ctx, []interface{}{req}, resp, "ListProducts", opts...); err != nil {
		return nil, err
	}
	return resp, nil
}

func (c *ProductCatalogServiceImpl) GetProduct(ctx context.Context, req *GetProductRequest, opts ...client.CallOption) (*Product, error) {
	resp := new(Product)
	if err := c.conn.CallUnary(ctx, []interface{}{req}, resp, "GetProduct", opts...); err != nil {
		return nil, err
	}
	return resp, nil
}

func (c *ProductCatalogServiceImpl) SearchProducts(ctx context.Context, req *SearchProductsRequest, opts ...client.CallOption) (*SearchProductsResponse, error) {
	resp := new(SearchProductsResponse)
	if err := c.conn.CallUnary(ctx, []interface{}{req}, resp, "SearchProducts", opts...); err != nil {
		return nil, err
	}
	return resp, nil
}

// NewShippingService constructs a client for the demo.ShippingService service.
func NewShippingService(cli *client.Client, opts ...client.ReferenceOption) (ShippingService, error) {
	conn, err := cli.DialWithInfo("hipstershop.ShippingService", &ShippingService_ClientInfo, opts...)
	if err != nil {
		return nil, err
	}
	return &ShippingServiceImpl{
		conn: conn,
	}, nil
}

func SetConsumerShippingService(srv common.RPCService) {
	dubbo.SetConsumerServiceWithInfo(srv, &ShippingService_ClientInfo)
}

// ShippingServiceImpl implements ShippingService.
type ShippingServiceImpl struct {
	conn *client.Connection
}

func (c *ShippingServiceImpl) GetQuote(ctx context.Context, req *GetQuoteRequest, opts ...client.CallOption) (*GetQuoteResponse, error) {
	resp := new(GetQuoteResponse)
	if err := c.conn.CallUnary(ctx, []interface{}{req}, resp, "GetQuote", opts...); err != nil {
		return nil, err
	}
	return resp, nil
}

func (c *ShippingServiceImpl) ShipOrder(ctx context.Context, req *ShipOrderRequest, opts ...client.CallOption) (*ShipOrderResponse, error) {
	resp := new(ShipOrderResponse)
	if err := c.conn.CallUnary(ctx, []interface{}{req}, resp, "ShipOrder", opts...); err != nil {
		return nil, err
	}
	return resp, nil
}

// NewCurrencyService constructs a client for the demo.CurrencyService service.
func NewCurrencyService(cli *client.Client, opts ...client.ReferenceOption) (CurrencyService, error) {
	conn, err := cli.DialWithInfo("hipstershop.CurrencyService", &CurrencyService_ClientInfo, opts...)
	if err != nil {
		return nil, err
	}
	return &CurrencyServiceImpl{
		conn: conn,
	}, nil
}

func SetConsumerCurrencyService(srv common.RPCService) {
	dubbo.SetConsumerServiceWithInfo(srv, &CurrencyService_ClientInfo)
}

// CurrencyServiceImpl implements CurrencyService.
type CurrencyServiceImpl struct {
	conn *client.Connection
}

func (c *CurrencyServiceImpl) GetSupportedCurrencies(ctx context.Context, req *Empty, opts ...client.CallOption) (*GetSupportedCurrenciesResponse, error) {
	resp := new(GetSupportedCurrenciesResponse)
	if err := c.conn.CallUnary(ctx, []interface{}{req}, resp, "GetSupportedCurrencies", opts...); err != nil {
		return nil, err
	}
	return resp, nil
}

func (c *CurrencyServiceImpl) Convert(ctx context.Context, req *CurrencyConversionRequest, opts ...client.CallOption) (*Money, error) {
	resp := new(Money)
	if err := c.conn.CallUnary(ctx, []interface{}{req}, resp, "Convert", opts...); err != nil {
		return nil, err
	}
	return resp, nil
}

// NewPaymentService constructs a client for the demo.PaymentService service.
func NewPaymentService(cli *client.Client, opts ...client.ReferenceOption) (PaymentService, error) {
	conn, err := cli.DialWithInfo("hipstershop.PaymentService", &PaymentService_ClientInfo, opts...)
	if err != nil {
		return nil, err
	}
	return &PaymentServiceImpl{
		conn: conn,
	}, nil
}

func SetConsumerPaymentService(srv common.RPCService) {
	dubbo.SetConsumerServiceWithInfo(srv, &PaymentService_ClientInfo)
}

// PaymentServiceImpl implements PaymentService.
type PaymentServiceImpl struct {
	conn *client.Connection
}

func (c *PaymentServiceImpl) Charge(ctx context.Context, req *ChargeRequest, opts ...client.CallOption) (*ChargeResponse, error) {
	resp := new(ChargeResponse)
	if err := c.conn.CallUnary(ctx, []interface{}{req}, resp, "Charge", opts...); err != nil {
		return nil, err
	}
	return resp, nil
}

// NewEmailService constructs a client for the demo.EmailService service.
func NewEmailService(cli *client.Client, opts ...client.ReferenceOption) (EmailService, error) {
	conn, err := cli.DialWithInfo("hipstershop.EmailService", &EmailService_ClientInfo, opts...)
	if err != nil {
		return nil, err
	}
	return &EmailServiceImpl{
		conn: conn,
	}, nil
}

func SetConsumerEmailService(srv common.RPCService) {
	dubbo.SetConsumerServiceWithInfo(srv, &EmailService_ClientInfo)
}

// EmailServiceImpl implements EmailService.
type EmailServiceImpl struct {
	conn *client.Connection
}

func (c *EmailServiceImpl) SendOrderConfirmation(ctx context.Context, req *SendOrderConfirmationRequest, opts ...client.CallOption) (*Empty, error) {
	resp := new(Empty)
	if err := c.conn.CallUnary(ctx, []interface{}{req}, resp, "SendOrderConfirmation", opts...); err != nil {
		return nil, err
	}
	return resp, nil
}

// NewCheckoutService constructs a client for the demo.CheckoutService service.
func NewCheckoutService(cli *client.Client, opts ...client.ReferenceOption) (CheckoutService, error) {
	conn, err := cli.DialWithInfo("hipstershop.CheckoutService", &CheckoutService_ClientInfo, opts...)
	if err != nil {
		return nil, err
	}
	return &CheckoutServiceImpl{
		conn: conn,
	}, nil
}

func SetConsumerCheckoutService(srv common.RPCService) {
	dubbo.SetConsumerServiceWithInfo(srv, &CheckoutService_ClientInfo)
}

// CheckoutServiceImpl implements CheckoutService.
type CheckoutServiceImpl struct {
	conn *client.Connection
}

func (c *CheckoutServiceImpl) PlaceOrder(ctx context.Context, req *PlaceOrderRequest, opts ...client.CallOption) (*PlaceOrderResponse, error) {
	resp := new(PlaceOrderResponse)
	if err := c.conn.CallUnary(ctx, []interface{}{req}, resp, "PlaceOrder", opts...); err != nil {
		return nil, err
	}
	return resp, nil
}

// NewAdService constructs a client for the demo.AdService service.
func NewAdService(cli *client.Client, opts ...client.ReferenceOption) (AdService, error) {
	conn, err := cli.DialWithInfo("hipstershop.AdService", &AdService_ClientInfo, opts...)
	if err != nil {
		return nil, err
	}
	return &AdServiceImpl{
		conn: conn,
	}, nil
}

func SetConsumerAdService(srv common.RPCService) {
	dubbo.SetConsumerServiceWithInfo(srv, &AdService_ClientInfo)
}

// AdServiceImpl implements AdService.
type AdServiceImpl struct {
	conn *client.Connection
}

func (c *AdServiceImpl) GetAds(ctx context.Context, req *AdRequest, opts ...client.CallOption) (*AdResponse, error) {
	resp := new(AdResponse)
	if err := c.conn.CallUnary(ctx, []interface{}{req}, resp, "GetAds", opts...); err != nil {
		return nil, err
	}
	return resp, nil
}

var CartService_ClientInfo = client.ClientInfo{
	InterfaceName: "hipstershop.CartService",
	MethodNames:   []string{"AddItem", "GetCart", "EmptyCart"},
	ConnectionInjectFunc: func(dubboCliRaw interface{}, conn *client.Connection) {
		dubboCli := dubboCliRaw.(*CartServiceImpl)
		dubboCli.conn = conn
	},
}
var RecommendationService_ClientInfo = client.ClientInfo{
	InterfaceName: "hipstershop.RecommendationService",
	MethodNames:   []string{"ListRecommendations"},
	ConnectionInjectFunc: func(dubboCliRaw interface{}, conn *client.Connection) {
		dubboCli := dubboCliRaw.(*RecommendationServiceImpl)
		dubboCli.conn = conn
	},
}
var ProductCatalogService_ClientInfo = client.ClientInfo{
	InterfaceName: "hipstershop.ProductCatalogService",
	MethodNames:   []string{"ListProducts", "GetProduct", "SearchProducts"},
	ConnectionInjectFunc: func(dubboCliRaw interface{}, conn *client.Connection) {
		dubboCli := dubboCliRaw.(*ProductCatalogServiceImpl)
		dubboCli.conn = conn
	},
}
var ShippingService_ClientInfo = client.ClientInfo{
	InterfaceName: "hipstershop.ShippingService",
	MethodNames:   []string{"GetQuote", "ShipOrder"},
	ConnectionInjectFunc: func(dubboCliRaw interface{}, conn *client.Connection) {
		dubboCli := dubboCliRaw.(*ShippingServiceImpl)
		dubboCli.conn = conn
	},
}
var CurrencyService_ClientInfo = client.ClientInfo{
	InterfaceName: "hipstershop.CurrencyService",
	MethodNames:   []string{"GetSupportedCurrencies", "Convert"},
	ConnectionInjectFunc: func(dubboCliRaw interface{}, conn *client.Connection) {
		dubboCli := dubboCliRaw.(*CurrencyServiceImpl)
		dubboCli.conn = conn
	},
}
var PaymentService_ClientInfo = client.ClientInfo{
	InterfaceName: "hipstershop.PaymentService",
	MethodNames:   []string{"Charge"},
	ConnectionInjectFunc: func(dubboCliRaw interface{}, conn *client.Connection) {
		dubboCli := dubboCliRaw.(*PaymentServiceImpl)
		dubboCli.conn = conn
	},
}
var EmailService_ClientInfo = client.ClientInfo{
	InterfaceName: "hipstershop.EmailService",
	MethodNames:   []string{"SendOrderConfirmation"},
	ConnectionInjectFunc: func(dubboCliRaw interface{}, conn *client.Connection) {
		dubboCli := dubboCliRaw.(*EmailServiceImpl)
		dubboCli.conn = conn
	},
}
var CheckoutService_ClientInfo = client.ClientInfo{
	InterfaceName: "hipstershop.CheckoutService",
	MethodNames:   []string{"PlaceOrder"},
	ConnectionInjectFunc: func(dubboCliRaw interface{}, conn *client.Connection) {
		dubboCli := dubboCliRaw.(*CheckoutServiceImpl)
		dubboCli.conn = conn
	},
}
var AdService_ClientInfo = client.ClientInfo{
	InterfaceName: "hipstershop.AdService",
	MethodNames:   []string{"GetAds"},
	ConnectionInjectFunc: func(dubboCliRaw interface{}, conn *client.Connection) {
		dubboCli := dubboCliRaw.(*AdServiceImpl)
		dubboCli.conn = conn
	},
}

// CartServiceHandler is an implementation of the hipstershop.CartService service.
type CartServiceHandler interface {
	AddItem(context.Context, *AddItemRequest) (*Empty, error)
	GetCart(context.Context, *GetCartRequest) (*Cart, error)
	EmptyCart(context.Context, *EmptyCartRequest) (*Empty, error)
}

func RegisterCartServiceHandler(srv *server.Server, hdlr CartServiceHandler, opts ...server.ServiceOption) error {
	return srv.Register(hdlr, &CartService_ServiceInfo, opts...)
}

func SetProviderCartService(srv common.RPCService) {
	dubbo.SetProviderServiceWithInfo(srv, &CartService_ServiceInfo)
}

// RecommendationServiceHandler is an implementation of the hipstershop.RecommendationService service.
type RecommendationServiceHandler interface {
	ListRecommendations(context.Context, *ListRecommendationsRequest) (*ListRecommendationsResponse, error)
}

func RegisterRecommendationServiceHandler(srv *server.Server, hdlr RecommendationServiceHandler, opts ...server.ServiceOption) error {
	return srv.Register(hdlr, &RecommendationService_ServiceInfo, opts...)
}

func SetProviderRecommendationService(srv common.RPCService) {
	dubbo.SetProviderServiceWithInfo(srv, &RecommendationService_ServiceInfo)
}

// ProductCatalogServiceHandler is an implementation of the hipstershop.ProductCatalogService service.
type ProductCatalogServiceHandler interface {
	ListProducts(context.Context, *Empty) (*ListProductsResponse, error)
	GetProduct(context.Context, *GetProductRequest) (*Product, error)
	SearchProducts(context.Context, *SearchProductsRequest) (*SearchProductsResponse, error)
}

func RegisterProductCatalogServiceHandler(srv *server.Server, hdlr ProductCatalogServiceHandler, opts ...server.ServiceOption) error {
	return srv.Register(hdlr, &ProductCatalogService_ServiceInfo, opts...)
}

func SetProviderProductCatalogService(srv common.RPCService) {
	dubbo.SetProviderServiceWithInfo(srv, &ProductCatalogService_ServiceInfo)
}

// ShippingServiceHandler is an implementation of the hipstershop.ShippingService service.
type ShippingServiceHandler interface {
	GetQuote(context.Context, *GetQuoteRequest) (*GetQuoteResponse, error)
	ShipOrder(context.Context, *ShipOrderRequest) (*ShipOrderResponse, error)
}

func RegisterShippingServiceHandler(srv *server.Server, hdlr ShippingServiceHandler, opts ...server.ServiceOption) error {
	return srv.Register(hdlr, &ShippingService_ServiceInfo, opts...)
}

func SetProviderShippingService(srv common.RPCService) {
	dubbo.SetProviderServiceWithInfo(srv, &ShippingService_ServiceInfo)
}

// CurrencyServiceHandler is an implementation of the hipstershop.CurrencyService service.
type CurrencyServiceHandler interface {
	GetSupportedCurrencies(context.Context, *Empty) (*GetSupportedCurrenciesResponse, error)
	Convert(context.Context, *CurrencyConversionRequest) (*Money, error)
}

func RegisterCurrencyServiceHandler(srv *server.Server, hdlr CurrencyServiceHandler, opts ...server.ServiceOption) error {
	return srv.Register(hdlr, &CurrencyService_ServiceInfo, opts...)
}

func SetProviderCurrencyService(srv common.RPCService) {
	dubbo.SetProviderServiceWithInfo(srv, &CurrencyService_ServiceInfo)
}

// PaymentServiceHandler is an implementation of the hipstershop.PaymentService service.
type PaymentServiceHandler interface {
	Charge(context.Context, *ChargeRequest) (*ChargeResponse, error)
}

func RegisterPaymentServiceHandler(srv *server.Server, hdlr PaymentServiceHandler, opts ...server.ServiceOption) error {
	return srv.Register(hdlr, &PaymentService_ServiceInfo, opts...)
}

func SetProviderPaymentService(srv common.RPCService) {
	dubbo.SetProviderServiceWithInfo(srv, &PaymentService_ServiceInfo)
}

// EmailServiceHandler is an implementation of the hipstershop.EmailService service.
type EmailServiceHandler interface {
	SendOrderConfirmation(context.Context, *SendOrderConfirmationRequest) (*Empty, error)
}

func RegisterEmailServiceHandler(srv *server.Server, hdlr EmailServiceHandler, opts ...server.ServiceOption) error {
	return srv.Register(hdlr, &EmailService_ServiceInfo, opts...)
}

func SetProviderEmailService(srv common.RPCService) {
	dubbo.SetProviderServiceWithInfo(srv, &EmailService_ServiceInfo)
}

// CheckoutServiceHandler is an implementation of the hipstershop.CheckoutService service.
type CheckoutServiceHandler interface {
	PlaceOrder(context.Context, *PlaceOrderRequest) (*PlaceOrderResponse, error)
}

func RegisterCheckoutServiceHandler(srv *server.Server, hdlr CheckoutServiceHandler, opts ...server.ServiceOption) error {
	return srv.Register(hdlr, &CheckoutService_ServiceInfo, opts...)
}

func SetProviderCheckoutService(srv common.RPCService) {
	dubbo.SetProviderServiceWithInfo(srv, &CheckoutService_ServiceInfo)
}

// AdServiceHandler is an implementation of the hipstershop.AdService service.
type AdServiceHandler interface {
	GetAds(context.Context, *AdRequest) (*AdResponse, error)
}

func RegisterAdServiceHandler(srv *server.Server, hdlr AdServiceHandler, opts ...server.ServiceOption) error {
	return srv.Register(hdlr, &AdService_ServiceInfo, opts...)
}

func SetProviderAdService(srv common.RPCService) {
	dubbo.SetProviderServiceWithInfo(srv, &AdService_ServiceInfo)
}

var CartService_ServiceInfo = server.ServiceInfo{
	InterfaceName: "hipstershop.CartService",
	ServiceType:   (*CartServiceHandler)(nil),
	Methods: []server.MethodInfo{
		{
			Name: "AddItem",
			Type: constant.CallUnary,
			ReqInitFunc: func() interface{} {
				return new(AddItemRequest)
			},
			MethodFunc: func(ctx context.Context, args []interface{}, handler interface{}) (interface{}, error) {
				req := args[0].(*AddItemRequest)
				res, err := handler.(CartServiceHandler).AddItem(ctx, req)
				if err != nil {
					return nil, err
				}
				return triple_protocol.NewResponse(res), nil
			},
		},
		{
			Name: "GetCart",
			Type: constant.CallUnary,
			ReqInitFunc: func() interface{} {
				return new(GetCartRequest)
			},
			MethodFunc: func(ctx context.Context, args []interface{}, handler interface{}) (interface{}, error) {
				req := args[0].(*GetCartRequest)
				res, err := handler.(CartServiceHandler).GetCart(ctx, req)
				if err != nil {
					return nil, err
				}
				return triple_protocol.NewResponse(res), nil
			},
		},
		{
			Name: "EmptyCart",
			Type: constant.CallUnary,
			ReqInitFunc: func() interface{} {
				return new(EmptyCartRequest)
			},
			MethodFunc: func(ctx context.Context, args []interface{}, handler interface{}) (interface{}, error) {
				req := args[0].(*EmptyCartRequest)
				res, err := handler.(CartServiceHandler).EmptyCart(ctx, req)
				if err != nil {
					return nil, err
				}
				return triple_protocol.NewResponse(res), nil
			},
		},
	},
}
var RecommendationService_ServiceInfo = server.ServiceInfo{
	InterfaceName: "hipstershop.RecommendationService",
	ServiceType:   (*RecommendationServiceHandler)(nil),
	Methods: []server.MethodInfo{
		{
			Name: "ListRecommendations",
			Type: constant.CallUnary,
			ReqInitFunc: func() interface{} {
				return new(ListRecommendationsRequest)
			},
			MethodFunc: func(ctx context.Context, args []interface{}, handler interface{}) (interface{}, error) {
				req := args[0].(*ListRecommendationsRequest)
				res, err := handler.(RecommendationServiceHandler).ListRecommendations(ctx, req)
				if err != nil {
					return nil, err
				}
				return triple_protocol.NewResponse(res), nil
			},
		},
	},
}
var ProductCatalogService_ServiceInfo = server.ServiceInfo{
	InterfaceName: "hipstershop.ProductCatalogService",
	ServiceType:   (*ProductCatalogServiceHandler)(nil),
	Methods: []server.MethodInfo{
		{
			Name: "ListProducts",
			Type: constant.CallUnary,
			ReqInitFunc: func() interface{} {
				return new(Empty)
			},
			MethodFunc: func(ctx context.Context, args []interface{}, handler interface{}) (interface{}, error) {
				req := args[0].(*Empty)
				res, err := handler.(ProductCatalogServiceHandler).ListProducts(ctx, req)
				if err != nil {
					return nil, err
				}
				return triple_protocol.NewResponse(res), nil
			},
		},
		{
			Name: "GetProduct",
			Type: constant.CallUnary,
			ReqInitFunc: func() interface{} {
				return new(GetProductRequest)
			},
			MethodFunc: func(ctx context.Context, args []interface{}, handler interface{}) (interface{}, error) {
				req := args[0].(*GetProductRequest)
				res, err := handler.(ProductCatalogServiceHandler).GetProduct(ctx, req)
				if err != nil {
					return nil, err
				}
				return triple_protocol.NewResponse(res), nil
			},
		},
		{
			Name: "SearchProducts",
			Type: constant.CallUnary,
			ReqInitFunc: func() interface{} {
				return new(SearchProductsRequest)
			},
			MethodFunc: func(ctx context.Context, args []interface{}, handler interface{}) (interface{}, error) {
				req := args[0].(*SearchProductsRequest)
				res, err := handler.(ProductCatalogServiceHandler).SearchProducts(ctx, req)
				if err != nil {
					return nil, err
				}
				return triple_protocol.NewResponse(res), nil
			},
		},
	},
}
var ShippingService_ServiceInfo = server.ServiceInfo{
	InterfaceName: "hipstershop.ShippingService",
	ServiceType:   (*ShippingServiceHandler)(nil),
	Methods: []server.MethodInfo{
		{
			Name: "GetQuote",
			Type: constant.CallUnary,
			ReqInitFunc: func() interface{} {
				return new(GetQuoteRequest)
			},
			MethodFunc: func(ctx context.Context, args []interface{}, handler interface{}) (interface{}, error) {
				req := args[0].(*GetQuoteRequest)
				res, err := handler.(ShippingServiceHandler).GetQuote(ctx, req)
				if err != nil {
					return nil, err
				}
				return triple_protocol.NewResponse(res), nil
			},
		},
		{
			Name: "ShipOrder",
			Type: constant.CallUnary,
			ReqInitFunc: func() interface{} {
				return new(ShipOrderRequest)
			},
			MethodFunc: func(ctx context.Context, args []interface{}, handler interface{}) (interface{}, error) {
				req := args[0].(*ShipOrderRequest)
				res, err := handler.(ShippingServiceHandler).ShipOrder(ctx, req)
				if err != nil {
					return nil, err
				}
				return triple_protocol.NewResponse(res), nil
			},
		},
	},
}
var CurrencyService_ServiceInfo = server.ServiceInfo{
	InterfaceName: "hipstershop.CurrencyService",
	ServiceType:   (*CurrencyServiceHandler)(nil),
	Methods: []server.MethodInfo{
		{
			Name: "GetSupportedCurrencies",
			Type: constant.CallUnary,
			ReqInitFunc: func() interface{} {
				return new(Empty)
			},
			MethodFunc: func(ctx context.Context, args []interface{}, handler interface{}) (interface{}, error) {
				req := args[0].(*Empty)
				res, err := handler.(CurrencyServiceHandler).GetSupportedCurrencies(ctx, req)
				if err != nil {
					return nil, err
				}
				return triple_protocol.NewResponse(res), nil
			},
		},
		{
			Name: "Convert",
			Type: constant.CallUnary,
			ReqInitFunc: func() interface{} {
				return new(CurrencyConversionRequest)
			},
			MethodFunc: func(ctx context.Context, args []interface{}, handler interface{}) (interface{}, error) {
				req := args[0].(*CurrencyConversionRequest)
				res, err := handler.(CurrencyServiceHandler).Convert(ctx, req)
				if err != nil {
					return nil, err
				}
				return triple_protocol.NewResponse(res), nil
			},
		},
	},
}
var PaymentService_ServiceInfo = server.ServiceInfo{
	InterfaceName: "hipstershop.PaymentService",
	ServiceType:   (*PaymentServiceHandler)(nil),
	Methods: []server.MethodInfo{
		{
			Name: "Charge",
			Type: constant.CallUnary,
			ReqInitFunc: func() interface{} {
				return new(ChargeRequest)
			},
			MethodFunc: func(ctx context.Context, args []interface{}, handler interface{}) (interface{}, error) {
				req := args[0].(*ChargeRequest)
				res, err := handler.(PaymentServiceHandler).Charge(ctx, req)
				if err != nil {
					return nil, err
				}
				return triple_protocol.NewResponse(res), nil
			},
		},
	},
}
var EmailService_ServiceInfo = server.ServiceInfo{
	InterfaceName: "hipstershop.EmailService",
	ServiceType:   (*EmailServiceHandler)(nil),
	Methods: []server.MethodInfo{
		{
			Name: "SendOrderConfirmation",
			Type: constant.CallUnary,
			ReqInitFunc: func() interface{} {
				return new(SendOrderConfirmationRequest)
			},
			MethodFunc: func(ctx context.Context, args []interface{}, handler interface{}) (interface{}, error) {
				req := args[0].(*SendOrderConfirmationRequest)
				res, err := handler.(EmailServiceHandler).SendOrderConfirmation(ctx, req)
				if err != nil {
					return nil, err
				}
				return triple_protocol.NewResponse(res), nil
			},
		},
	},
}
var CheckoutService_ServiceInfo = server.ServiceInfo{
	InterfaceName: "hipstershop.CheckoutService",
	ServiceType:   (*CheckoutServiceHandler)(nil),
	Methods: []server.MethodInfo{
		{
			Name: "PlaceOrder",
			Type: constant.CallUnary,
			ReqInitFunc: func() interface{} {
				return new(PlaceOrderRequest)
			},
			MethodFunc: func(ctx context.Context, args []interface{}, handler interface{}) (interface{}, error) {
				req := args[0].(*PlaceOrderRequest)
				res, err := handler.(CheckoutServiceHandler).PlaceOrder(ctx, req)
				if err != nil {
					return nil, err
				}
				return triple_protocol.NewResponse(res), nil
			},
		},
	},
}
var AdService_ServiceInfo = server.ServiceInfo{
	InterfaceName: "hipstershop.AdService",
	ServiceType:   (*AdServiceHandler)(nil),
	Methods: []server.MethodInfo{
		{
			Name: "GetAds",
			Type: constant.CallUnary,
			ReqInitFunc: func() interface{} {
				return new(AdRequest)
			},
			MethodFunc: func(ctx context.Context, args []interface{}, handler interface{}) (interface{}, error) {
				req := args[0].(*AdRequest)
				res, err := handler.(AdServiceHandler).GetAds(ctx, req)
				if err != nil {
					return nil, err
				}
				return triple_protocol.NewResponse(res), nil
			},
		},
	},
}
