// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.6.1
// - protoc             (unknown)
// source: app/v1/catalog.proto

package appv1

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 (
	Domains_ListDomains_FullMethodName  = "/stream.app.v1.Domains/ListDomains"
	Domains_CreateDomain_FullMethodName = "/stream.app.v1.Domains/CreateDomain"
	Domains_DeleteDomain_FullMethodName = "/stream.app.v1.Domains/DeleteDomain"
)

// DomainsClient is the client API for Domains 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 DomainsClient interface {
	ListDomains(ctx context.Context, in *ListDomainsRequest, opts ...grpc.CallOption) (*ListDomainsResponse, error)
	CreateDomain(ctx context.Context, in *CreateDomainRequest, opts ...grpc.CallOption) (*CreateDomainResponse, error)
	DeleteDomain(ctx context.Context, in *DeleteDomainRequest, opts ...grpc.CallOption) (*MessageResponse, error)
}

type domainsClient struct {
	cc grpc.ClientConnInterface
}

func NewDomainsClient(cc grpc.ClientConnInterface) DomainsClient {
	return &domainsClient{cc}
}

func (c *domainsClient) ListDomains(ctx context.Context, in *ListDomainsRequest, opts ...grpc.CallOption) (*ListDomainsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListDomainsResponse)
	err := c.cc.Invoke(ctx, Domains_ListDomains_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *domainsClient) CreateDomain(ctx context.Context, in *CreateDomainRequest, opts ...grpc.CallOption) (*CreateDomainResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CreateDomainResponse)
	err := c.cc.Invoke(ctx, Domains_CreateDomain_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *domainsClient) DeleteDomain(ctx context.Context, in *DeleteDomainRequest, opts ...grpc.CallOption) (*MessageResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(MessageResponse)
	err := c.cc.Invoke(ctx, Domains_DeleteDomain_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// DomainsServer is the server API for Domains service.
// All implementations must embed UnimplementedDomainsServer
// for forward compatibility.
type DomainsServer interface {
	ListDomains(context.Context, *ListDomainsRequest) (*ListDomainsResponse, error)
	CreateDomain(context.Context, *CreateDomainRequest) (*CreateDomainResponse, error)
	DeleteDomain(context.Context, *DeleteDomainRequest) (*MessageResponse, error)
	mustEmbedUnimplementedDomainsServer()
}

// UnimplementedDomainsServer 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 UnimplementedDomainsServer struct{}

func (UnimplementedDomainsServer) ListDomains(context.Context, *ListDomainsRequest) (*ListDomainsResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ListDomains not implemented")
}
func (UnimplementedDomainsServer) CreateDomain(context.Context, *CreateDomainRequest) (*CreateDomainResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method CreateDomain not implemented")
}
func (UnimplementedDomainsServer) DeleteDomain(context.Context, *DeleteDomainRequest) (*MessageResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method DeleteDomain not implemented")
}
func (UnimplementedDomainsServer) mustEmbedUnimplementedDomainsServer() {}
func (UnimplementedDomainsServer) testEmbeddedByValue()                 {}

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

func RegisterDomainsServer(s grpc.ServiceRegistrar, srv DomainsServer) {
	// If the following call panics, it indicates UnimplementedDomainsServer 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(&Domains_ServiceDesc, srv)
}

func _Domains_ListDomains_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListDomainsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DomainsServer).ListDomains(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Domains_ListDomains_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DomainsServer).ListDomains(ctx, req.(*ListDomainsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Domains_CreateDomain_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateDomainRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DomainsServer).CreateDomain(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Domains_CreateDomain_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DomainsServer).CreateDomain(ctx, req.(*CreateDomainRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Domains_DeleteDomain_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteDomainRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DomainsServer).DeleteDomain(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Domains_DeleteDomain_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DomainsServer).DeleteDomain(ctx, req.(*DeleteDomainRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// Domains_ServiceDesc is the grpc.ServiceDesc for Domains service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var Domains_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "stream.app.v1.Domains",
	HandlerType: (*DomainsServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ListDomains",
			Handler:    _Domains_ListDomains_Handler,
		},
		{
			MethodName: "CreateDomain",
			Handler:    _Domains_CreateDomain_Handler,
		},
		{
			MethodName: "DeleteDomain",
			Handler:    _Domains_DeleteDomain_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "app/v1/catalog.proto",
}

const (
	AdTemplates_ListAdTemplates_FullMethodName  = "/stream.app.v1.AdTemplates/ListAdTemplates"
	AdTemplates_CreateAdTemplate_FullMethodName = "/stream.app.v1.AdTemplates/CreateAdTemplate"
	AdTemplates_UpdateAdTemplate_FullMethodName = "/stream.app.v1.AdTemplates/UpdateAdTemplate"
	AdTemplates_DeleteAdTemplate_FullMethodName = "/stream.app.v1.AdTemplates/DeleteAdTemplate"
)

// AdTemplatesClient is the client API for AdTemplates 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 AdTemplatesClient interface {
	ListAdTemplates(ctx context.Context, in *ListAdTemplatesRequest, opts ...grpc.CallOption) (*ListAdTemplatesResponse, error)
	CreateAdTemplate(ctx context.Context, in *CreateAdTemplateRequest, opts ...grpc.CallOption) (*CreateAdTemplateResponse, error)
	UpdateAdTemplate(ctx context.Context, in *UpdateAdTemplateRequest, opts ...grpc.CallOption) (*UpdateAdTemplateResponse, error)
	DeleteAdTemplate(ctx context.Context, in *DeleteAdTemplateRequest, opts ...grpc.CallOption) (*MessageResponse, error)
}

type adTemplatesClient struct {
	cc grpc.ClientConnInterface
}

func NewAdTemplatesClient(cc grpc.ClientConnInterface) AdTemplatesClient {
	return &adTemplatesClient{cc}
}

func (c *adTemplatesClient) ListAdTemplates(ctx context.Context, in *ListAdTemplatesRequest, opts ...grpc.CallOption) (*ListAdTemplatesResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListAdTemplatesResponse)
	err := c.cc.Invoke(ctx, AdTemplates_ListAdTemplates_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adTemplatesClient) CreateAdTemplate(ctx context.Context, in *CreateAdTemplateRequest, opts ...grpc.CallOption) (*CreateAdTemplateResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CreateAdTemplateResponse)
	err := c.cc.Invoke(ctx, AdTemplates_CreateAdTemplate_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adTemplatesClient) UpdateAdTemplate(ctx context.Context, in *UpdateAdTemplateRequest, opts ...grpc.CallOption) (*UpdateAdTemplateResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(UpdateAdTemplateResponse)
	err := c.cc.Invoke(ctx, AdTemplates_UpdateAdTemplate_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adTemplatesClient) DeleteAdTemplate(ctx context.Context, in *DeleteAdTemplateRequest, opts ...grpc.CallOption) (*MessageResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(MessageResponse)
	err := c.cc.Invoke(ctx, AdTemplates_DeleteAdTemplate_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// AdTemplatesServer is the server API for AdTemplates service.
// All implementations must embed UnimplementedAdTemplatesServer
// for forward compatibility.
type AdTemplatesServer interface {
	ListAdTemplates(context.Context, *ListAdTemplatesRequest) (*ListAdTemplatesResponse, error)
	CreateAdTemplate(context.Context, *CreateAdTemplateRequest) (*CreateAdTemplateResponse, error)
	UpdateAdTemplate(context.Context, *UpdateAdTemplateRequest) (*UpdateAdTemplateResponse, error)
	DeleteAdTemplate(context.Context, *DeleteAdTemplateRequest) (*MessageResponse, error)
	mustEmbedUnimplementedAdTemplatesServer()
}

// UnimplementedAdTemplatesServer 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 UnimplementedAdTemplatesServer struct{}

func (UnimplementedAdTemplatesServer) ListAdTemplates(context.Context, *ListAdTemplatesRequest) (*ListAdTemplatesResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ListAdTemplates not implemented")
}
func (UnimplementedAdTemplatesServer) CreateAdTemplate(context.Context, *CreateAdTemplateRequest) (*CreateAdTemplateResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method CreateAdTemplate not implemented")
}
func (UnimplementedAdTemplatesServer) UpdateAdTemplate(context.Context, *UpdateAdTemplateRequest) (*UpdateAdTemplateResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method UpdateAdTemplate not implemented")
}
func (UnimplementedAdTemplatesServer) DeleteAdTemplate(context.Context, *DeleteAdTemplateRequest) (*MessageResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method DeleteAdTemplate not implemented")
}
func (UnimplementedAdTemplatesServer) mustEmbedUnimplementedAdTemplatesServer() {}
func (UnimplementedAdTemplatesServer) testEmbeddedByValue()                     {}

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

func RegisterAdTemplatesServer(s grpc.ServiceRegistrar, srv AdTemplatesServer) {
	// If the following call panics, it indicates UnimplementedAdTemplatesServer 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(&AdTemplates_ServiceDesc, srv)
}

func _AdTemplates_ListAdTemplates_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListAdTemplatesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdTemplatesServer).ListAdTemplates(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdTemplates_ListAdTemplates_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdTemplatesServer).ListAdTemplates(ctx, req.(*ListAdTemplatesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdTemplates_CreateAdTemplate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateAdTemplateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdTemplatesServer).CreateAdTemplate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdTemplates_CreateAdTemplate_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdTemplatesServer).CreateAdTemplate(ctx, req.(*CreateAdTemplateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdTemplates_UpdateAdTemplate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateAdTemplateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdTemplatesServer).UpdateAdTemplate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdTemplates_UpdateAdTemplate_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdTemplatesServer).UpdateAdTemplate(ctx, req.(*UpdateAdTemplateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdTemplates_DeleteAdTemplate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteAdTemplateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdTemplatesServer).DeleteAdTemplate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdTemplates_DeleteAdTemplate_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdTemplatesServer).DeleteAdTemplate(ctx, req.(*DeleteAdTemplateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// AdTemplates_ServiceDesc is the grpc.ServiceDesc for AdTemplates service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var AdTemplates_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "stream.app.v1.AdTemplates",
	HandlerType: (*AdTemplatesServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ListAdTemplates",
			Handler:    _AdTemplates_ListAdTemplates_Handler,
		},
		{
			MethodName: "CreateAdTemplate",
			Handler:    _AdTemplates_CreateAdTemplate_Handler,
		},
		{
			MethodName: "UpdateAdTemplate",
			Handler:    _AdTemplates_UpdateAdTemplate_Handler,
		},
		{
			MethodName: "DeleteAdTemplate",
			Handler:    _AdTemplates_DeleteAdTemplate_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "app/v1/catalog.proto",
}

const (
	PlayerConfigs_ListPlayerConfigs_FullMethodName  = "/stream.app.v1.PlayerConfigs/ListPlayerConfigs"
	PlayerConfigs_CreatePlayerConfig_FullMethodName = "/stream.app.v1.PlayerConfigs/CreatePlayerConfig"
	PlayerConfigs_UpdatePlayerConfig_FullMethodName = "/stream.app.v1.PlayerConfigs/UpdatePlayerConfig"
	PlayerConfigs_DeletePlayerConfig_FullMethodName = "/stream.app.v1.PlayerConfigs/DeletePlayerConfig"
)

// PlayerConfigsClient is the client API for PlayerConfigs 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 PlayerConfigsClient interface {
	ListPlayerConfigs(ctx context.Context, in *ListPlayerConfigsRequest, opts ...grpc.CallOption) (*ListPlayerConfigsResponse, error)
	CreatePlayerConfig(ctx context.Context, in *CreatePlayerConfigRequest, opts ...grpc.CallOption) (*CreatePlayerConfigResponse, error)
	UpdatePlayerConfig(ctx context.Context, in *UpdatePlayerConfigRequest, opts ...grpc.CallOption) (*UpdatePlayerConfigResponse, error)
	DeletePlayerConfig(ctx context.Context, in *DeletePlayerConfigRequest, opts ...grpc.CallOption) (*MessageResponse, error)
}

type playerConfigsClient struct {
	cc grpc.ClientConnInterface
}

func NewPlayerConfigsClient(cc grpc.ClientConnInterface) PlayerConfigsClient {
	return &playerConfigsClient{cc}
}

func (c *playerConfigsClient) ListPlayerConfigs(ctx context.Context, in *ListPlayerConfigsRequest, opts ...grpc.CallOption) (*ListPlayerConfigsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListPlayerConfigsResponse)
	err := c.cc.Invoke(ctx, PlayerConfigs_ListPlayerConfigs_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *playerConfigsClient) CreatePlayerConfig(ctx context.Context, in *CreatePlayerConfigRequest, opts ...grpc.CallOption) (*CreatePlayerConfigResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CreatePlayerConfigResponse)
	err := c.cc.Invoke(ctx, PlayerConfigs_CreatePlayerConfig_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *playerConfigsClient) UpdatePlayerConfig(ctx context.Context, in *UpdatePlayerConfigRequest, opts ...grpc.CallOption) (*UpdatePlayerConfigResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(UpdatePlayerConfigResponse)
	err := c.cc.Invoke(ctx, PlayerConfigs_UpdatePlayerConfig_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *playerConfigsClient) DeletePlayerConfig(ctx context.Context, in *DeletePlayerConfigRequest, opts ...grpc.CallOption) (*MessageResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(MessageResponse)
	err := c.cc.Invoke(ctx, PlayerConfigs_DeletePlayerConfig_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// PlayerConfigsServer is the server API for PlayerConfigs service.
// All implementations must embed UnimplementedPlayerConfigsServer
// for forward compatibility.
type PlayerConfigsServer interface {
	ListPlayerConfigs(context.Context, *ListPlayerConfigsRequest) (*ListPlayerConfigsResponse, error)
	CreatePlayerConfig(context.Context, *CreatePlayerConfigRequest) (*CreatePlayerConfigResponse, error)
	UpdatePlayerConfig(context.Context, *UpdatePlayerConfigRequest) (*UpdatePlayerConfigResponse, error)
	DeletePlayerConfig(context.Context, *DeletePlayerConfigRequest) (*MessageResponse, error)
	mustEmbedUnimplementedPlayerConfigsServer()
}

// UnimplementedPlayerConfigsServer 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 UnimplementedPlayerConfigsServer struct{}

func (UnimplementedPlayerConfigsServer) ListPlayerConfigs(context.Context, *ListPlayerConfigsRequest) (*ListPlayerConfigsResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ListPlayerConfigs not implemented")
}
func (UnimplementedPlayerConfigsServer) CreatePlayerConfig(context.Context, *CreatePlayerConfigRequest) (*CreatePlayerConfigResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method CreatePlayerConfig not implemented")
}
func (UnimplementedPlayerConfigsServer) UpdatePlayerConfig(context.Context, *UpdatePlayerConfigRequest) (*UpdatePlayerConfigResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method UpdatePlayerConfig not implemented")
}
func (UnimplementedPlayerConfigsServer) DeletePlayerConfig(context.Context, *DeletePlayerConfigRequest) (*MessageResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method DeletePlayerConfig not implemented")
}
func (UnimplementedPlayerConfigsServer) mustEmbedUnimplementedPlayerConfigsServer() {}
func (UnimplementedPlayerConfigsServer) testEmbeddedByValue()                       {}

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

func RegisterPlayerConfigsServer(s grpc.ServiceRegistrar, srv PlayerConfigsServer) {
	// If the following call panics, it indicates UnimplementedPlayerConfigsServer 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(&PlayerConfigs_ServiceDesc, srv)
}

func _PlayerConfigs_ListPlayerConfigs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListPlayerConfigsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PlayerConfigsServer).ListPlayerConfigs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: PlayerConfigs_ListPlayerConfigs_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PlayerConfigsServer).ListPlayerConfigs(ctx, req.(*ListPlayerConfigsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _PlayerConfigs_CreatePlayerConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreatePlayerConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PlayerConfigsServer).CreatePlayerConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: PlayerConfigs_CreatePlayerConfig_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PlayerConfigsServer).CreatePlayerConfig(ctx, req.(*CreatePlayerConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _PlayerConfigs_UpdatePlayerConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdatePlayerConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PlayerConfigsServer).UpdatePlayerConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: PlayerConfigs_UpdatePlayerConfig_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PlayerConfigsServer).UpdatePlayerConfig(ctx, req.(*UpdatePlayerConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _PlayerConfigs_DeletePlayerConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeletePlayerConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PlayerConfigsServer).DeletePlayerConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: PlayerConfigs_DeletePlayerConfig_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PlayerConfigsServer).DeletePlayerConfig(ctx, req.(*DeletePlayerConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// PlayerConfigs_ServiceDesc is the grpc.ServiceDesc for PlayerConfigs service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var PlayerConfigs_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "stream.app.v1.PlayerConfigs",
	HandlerType: (*PlayerConfigsServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ListPlayerConfigs",
			Handler:    _PlayerConfigs_ListPlayerConfigs_Handler,
		},
		{
			MethodName: "CreatePlayerConfig",
			Handler:    _PlayerConfigs_CreatePlayerConfig_Handler,
		},
		{
			MethodName: "UpdatePlayerConfig",
			Handler:    _PlayerConfigs_UpdatePlayerConfig_Handler,
		},
		{
			MethodName: "DeletePlayerConfig",
			Handler:    _PlayerConfigs_DeletePlayerConfig_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "app/v1/catalog.proto",
}

const (
	Plans_ListPlans_FullMethodName = "/stream.app.v1.Plans/ListPlans"
)

// PlansClient is the client API for Plans 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 PlansClient interface {
	ListPlans(ctx context.Context, in *ListPlansRequest, opts ...grpc.CallOption) (*ListPlansResponse, error)
}

type plansClient struct {
	cc grpc.ClientConnInterface
}

func NewPlansClient(cc grpc.ClientConnInterface) PlansClient {
	return &plansClient{cc}
}

func (c *plansClient) ListPlans(ctx context.Context, in *ListPlansRequest, opts ...grpc.CallOption) (*ListPlansResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListPlansResponse)
	err := c.cc.Invoke(ctx, Plans_ListPlans_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// PlansServer is the server API for Plans service.
// All implementations must embed UnimplementedPlansServer
// for forward compatibility.
type PlansServer interface {
	ListPlans(context.Context, *ListPlansRequest) (*ListPlansResponse, error)
	mustEmbedUnimplementedPlansServer()
}

// UnimplementedPlansServer 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 UnimplementedPlansServer struct{}

func (UnimplementedPlansServer) ListPlans(context.Context, *ListPlansRequest) (*ListPlansResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ListPlans not implemented")
}
func (UnimplementedPlansServer) mustEmbedUnimplementedPlansServer() {}
func (UnimplementedPlansServer) testEmbeddedByValue()               {}

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

func RegisterPlansServer(s grpc.ServiceRegistrar, srv PlansServer) {
	// If the following call panics, it indicates UnimplementedPlansServer 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(&Plans_ServiceDesc, srv)
}

func _Plans_ListPlans_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListPlansRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PlansServer).ListPlans(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Plans_ListPlans_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PlansServer).ListPlans(ctx, req.(*ListPlansRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// Plans_ServiceDesc is the grpc.ServiceDesc for Plans service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var Plans_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "stream.app.v1.Plans",
	HandlerType: (*PlansServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ListPlans",
			Handler:    _Plans_ListPlans_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "app/v1/catalog.proto",
}