// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.3.0
// - protoc             v4.23.1
// source: testproto/invalid.proto

package testproto

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.32.0 or later.
const _ = grpc.SupportPackageIsVersion7

const (
	InterceptedWithOperationType_InvalidMethod_FullMethodName = "/testproto.InterceptedWithOperationType/InvalidMethod"
)

// InterceptedWithOperationTypeClient is the client API for InterceptedWithOperationType 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 InterceptedWithOperationTypeClient interface {
	// intercepted services can't have operation type annotations.
	InvalidMethod(ctx context.Context, in *InvalidMethodRequest, opts ...grpc.CallOption) (*InvalidMethodResponse, error)
}

type interceptedWithOperationTypeClient struct {
	cc grpc.ClientConnInterface
}

func NewInterceptedWithOperationTypeClient(cc grpc.ClientConnInterface) InterceptedWithOperationTypeClient {
	return &interceptedWithOperationTypeClient{cc}
}

func (c *interceptedWithOperationTypeClient) InvalidMethod(ctx context.Context, in *InvalidMethodRequest, opts ...grpc.CallOption) (*InvalidMethodResponse, error) {
	out := new(InvalidMethodResponse)
	err := c.cc.Invoke(ctx, InterceptedWithOperationType_InvalidMethod_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// InterceptedWithOperationTypeServer is the server API for InterceptedWithOperationType service.
// All implementations must embed UnimplementedInterceptedWithOperationTypeServer
// for forward compatibility
type InterceptedWithOperationTypeServer interface {
	// intercepted services can't have operation type annotations.
	InvalidMethod(context.Context, *InvalidMethodRequest) (*InvalidMethodResponse, error)
	mustEmbedUnimplementedInterceptedWithOperationTypeServer()
}

// UnimplementedInterceptedWithOperationTypeServer must be embedded to have forward compatible implementations.
type UnimplementedInterceptedWithOperationTypeServer struct {
}

func (UnimplementedInterceptedWithOperationTypeServer) InvalidMethod(context.Context, *InvalidMethodRequest) (*InvalidMethodResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method InvalidMethod not implemented")
}
func (UnimplementedInterceptedWithOperationTypeServer) mustEmbedUnimplementedInterceptedWithOperationTypeServer() {
}

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

func RegisterInterceptedWithOperationTypeServer(s grpc.ServiceRegistrar, srv InterceptedWithOperationTypeServer) {
	s.RegisterService(&InterceptedWithOperationType_ServiceDesc, srv)
}

func _InterceptedWithOperationType_InvalidMethod_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InvalidMethodRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InterceptedWithOperationTypeServer).InvalidMethod(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InterceptedWithOperationType_InvalidMethod_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InterceptedWithOperationTypeServer).InvalidMethod(ctx, req.(*InvalidMethodRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// InterceptedWithOperationType_ServiceDesc is the grpc.ServiceDesc for InterceptedWithOperationType service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var InterceptedWithOperationType_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "testproto.InterceptedWithOperationType",
	HandlerType: (*InterceptedWithOperationTypeServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "InvalidMethod",
			Handler:    _InterceptedWithOperationType_InvalidMethod_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "testproto/invalid.proto",
}

const (
	InvalidService_InvalidMethod0_FullMethodName                            = "/testproto.InvalidService/InvalidMethod0"
	InvalidService_InvalidMethod1_FullMethodName                            = "/testproto.InvalidService/InvalidMethod1"
	InvalidService_InvalidMethod2_FullMethodName                            = "/testproto.InvalidService/InvalidMethod2"
	InvalidService_InvalidMethod4_FullMethodName                            = "/testproto.InvalidService/InvalidMethod4"
	InvalidService_InvalidMethod5_FullMethodName                            = "/testproto.InvalidService/InvalidMethod5"
	InvalidService_InvalidMethod6_FullMethodName                            = "/testproto.InvalidService/InvalidMethod6"
	InvalidService_InvalidMethod7_FullMethodName                            = "/testproto.InvalidService/InvalidMethod7"
	InvalidService_InvalidMethod8_FullMethodName                            = "/testproto.InvalidService/InvalidMethod8"
	InvalidService_InvalidMethod9_FullMethodName                            = "/testproto.InvalidService/InvalidMethod9"
	InvalidService_InvalidMethod10_FullMethodName                           = "/testproto.InvalidService/InvalidMethod10"
	InvalidService_InvalidMethod11_FullMethodName                           = "/testproto.InvalidService/InvalidMethod11"
	InvalidService_InvalidMethod13_FullMethodName                           = "/testproto.InvalidService/InvalidMethod13"
	InvalidService_InvalidMethod14_FullMethodName                           = "/testproto.InvalidService/InvalidMethod14"
	InvalidService_MaintenanceWithMissingRepository_FullMethodName          = "/testproto.InvalidService/MaintenanceWithMissingRepository"
	InvalidService_MaintenanceWithUnflaggedRepository_FullMethodName        = "/testproto.InvalidService/MaintenanceWithUnflaggedRepository"
	InvalidService_MaintenanceWithWrongNestedRepositoryType_FullMethodName  = "/testproto.InvalidService/MaintenanceWithWrongNestedRepositoryType"
	InvalidService_MaintenanceWithInvalidTargetType_FullMethodName          = "/testproto.InvalidService/MaintenanceWithInvalidTargetType"
	InvalidService_MaintenanceWithInvalidNestedRequest_FullMethodName       = "/testproto.InvalidService/MaintenanceWithInvalidNestedRequest"
	InvalidService_MaintenanceWithStorageAndRepository_FullMethodName       = "/testproto.InvalidService/MaintenanceWithStorageAndRepository"
	InvalidService_MaintenanceWithNestedStorageAndRepository_FullMethodName = "/testproto.InvalidService/MaintenanceWithNestedStorageAndRepository"
	InvalidService_MaintenanceWithStorageScope_FullMethodName               = "/testproto.InvalidService/MaintenanceWithStorageScope"
)

// InvalidServiceClient is the client API for InvalidService 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 InvalidServiceClient interface {
	// should fail if op_type extension is missing
	InvalidMethod0(ctx context.Context, in *InvalidMethodRequest, opts ...grpc.CallOption) (*InvalidMethodResponse, error)
	// should fail if op type is unknown
	InvalidMethod1(ctx context.Context, in *InvalidMethodRequest, opts ...grpc.CallOption) (*InvalidMethodResponse, error)
	// should fail if target repo is not provided for accessor
	InvalidMethod2(ctx context.Context, in *InvalidMethodRequest, opts ...grpc.CallOption) (*InvalidMethodResponse, error)
	// should fail if missing either target repo or non-repo-scope for mutator
	InvalidMethod4(ctx context.Context, in *InvalidMethodRequest, opts ...grpc.CallOption) (*InvalidMethodResponse, error)
	// should fail if repository is not of type Repository
	InvalidMethod5(ctx context.Context, in *RequestWithWrongTypeRepository, opts ...grpc.CallOption) (*InvalidMethodResponse, error)
	// should fail if nested repository isn't flagged
	InvalidMethod6(ctx context.Context, in *RequestWithNestedRepoNotFlagged, opts ...grpc.CallOption) (*InvalidMethodResponse, error)
	// should fail if target field type is not of type Repository
	InvalidMethod7(ctx context.Context, in *InvalidTargetType, opts ...grpc.CallOption) (*InvalidMethodResponse, error)
	// should fail if nested target field type is not of type Repository
	InvalidMethod8(ctx context.Context, in *InvalidNestedRequest, opts ...grpc.CallOption) (*InvalidMethodResponse, error)
	// should fail if target repo is specified for storage scoped RPC
	InvalidMethod9(ctx context.Context, in *InvalidMethodRequestWithRepo, opts ...grpc.CallOption) (*InvalidMethodResponse, error)
	// should fail if storage is specified for implicit repository scoped RPC
	InvalidMethod10(ctx context.Context, in *RequestWithStorageAndRepo, opts ...grpc.CallOption) (*InvalidMethodResponse, error)
	// should fail if storage is specified for repository scoped RPC
	InvalidMethod11(ctx context.Context, in *RequestWithNestedStorageAndRepo, opts ...grpc.CallOption) (*InvalidMethodResponse, error)
	// should fail if storage isn't specified for storage scoped RPC
	InvalidMethod13(ctx context.Context, in *InvalidTargetType, opts ...grpc.CallOption) (*InvalidMethodResponse, error)
	// should fail if multiple storage is specified for storage scoped RPC
	InvalidMethod14(ctx context.Context, in *RequestWithMultipleNestedStorage, opts ...grpc.CallOption) (*InvalidMethodResponse, error)
	MaintenanceWithMissingRepository(ctx context.Context, in *InvalidMethodRequest, opts ...grpc.CallOption) (*InvalidMethodResponse, error)
	MaintenanceWithUnflaggedRepository(ctx context.Context, in *RequestWithNestedRepoNotFlagged, opts ...grpc.CallOption) (*InvalidMethodResponse, error)
	MaintenanceWithWrongNestedRepositoryType(ctx context.Context, in *RequestWithWrongTypeRepository, opts ...grpc.CallOption) (*InvalidMethodResponse, error)
	MaintenanceWithInvalidTargetType(ctx context.Context, in *InvalidTargetType, opts ...grpc.CallOption) (*InvalidMethodResponse, error)
	MaintenanceWithInvalidNestedRequest(ctx context.Context, in *InvalidNestedRequest, opts ...grpc.CallOption) (*InvalidMethodResponse, error)
	MaintenanceWithStorageAndRepository(ctx context.Context, in *RequestWithStorageAndRepo, opts ...grpc.CallOption) (*InvalidMethodResponse, error)
	MaintenanceWithNestedStorageAndRepository(ctx context.Context, in *RequestWithNestedStorageAndRepo, opts ...grpc.CallOption) (*InvalidMethodResponse, error)
	MaintenanceWithStorageScope(ctx context.Context, in *InvalidMethodRequestWithRepo, opts ...grpc.CallOption) (*InvalidMethodResponse, error)
}

type invalidServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewInvalidServiceClient(cc grpc.ClientConnInterface) InvalidServiceClient {
	return &invalidServiceClient{cc}
}

func (c *invalidServiceClient) InvalidMethod0(ctx context.Context, in *InvalidMethodRequest, opts ...grpc.CallOption) (*InvalidMethodResponse, error) {
	out := new(InvalidMethodResponse)
	err := c.cc.Invoke(ctx, InvalidService_InvalidMethod0_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *invalidServiceClient) InvalidMethod1(ctx context.Context, in *InvalidMethodRequest, opts ...grpc.CallOption) (*InvalidMethodResponse, error) {
	out := new(InvalidMethodResponse)
	err := c.cc.Invoke(ctx, InvalidService_InvalidMethod1_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *invalidServiceClient) InvalidMethod2(ctx context.Context, in *InvalidMethodRequest, opts ...grpc.CallOption) (*InvalidMethodResponse, error) {
	out := new(InvalidMethodResponse)
	err := c.cc.Invoke(ctx, InvalidService_InvalidMethod2_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *invalidServiceClient) InvalidMethod4(ctx context.Context, in *InvalidMethodRequest, opts ...grpc.CallOption) (*InvalidMethodResponse, error) {
	out := new(InvalidMethodResponse)
	err := c.cc.Invoke(ctx, InvalidService_InvalidMethod4_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *invalidServiceClient) InvalidMethod5(ctx context.Context, in *RequestWithWrongTypeRepository, opts ...grpc.CallOption) (*InvalidMethodResponse, error) {
	out := new(InvalidMethodResponse)
	err := c.cc.Invoke(ctx, InvalidService_InvalidMethod5_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *invalidServiceClient) InvalidMethod6(ctx context.Context, in *RequestWithNestedRepoNotFlagged, opts ...grpc.CallOption) (*InvalidMethodResponse, error) {
	out := new(InvalidMethodResponse)
	err := c.cc.Invoke(ctx, InvalidService_InvalidMethod6_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *invalidServiceClient) InvalidMethod7(ctx context.Context, in *InvalidTargetType, opts ...grpc.CallOption) (*InvalidMethodResponse, error) {
	out := new(InvalidMethodResponse)
	err := c.cc.Invoke(ctx, InvalidService_InvalidMethod7_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *invalidServiceClient) InvalidMethod8(ctx context.Context, in *InvalidNestedRequest, opts ...grpc.CallOption) (*InvalidMethodResponse, error) {
	out := new(InvalidMethodResponse)
	err := c.cc.Invoke(ctx, InvalidService_InvalidMethod8_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *invalidServiceClient) InvalidMethod9(ctx context.Context, in *InvalidMethodRequestWithRepo, opts ...grpc.CallOption) (*InvalidMethodResponse, error) {
	out := new(InvalidMethodResponse)
	err := c.cc.Invoke(ctx, InvalidService_InvalidMethod9_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *invalidServiceClient) InvalidMethod10(ctx context.Context, in *RequestWithStorageAndRepo, opts ...grpc.CallOption) (*InvalidMethodResponse, error) {
	out := new(InvalidMethodResponse)
	err := c.cc.Invoke(ctx, InvalidService_InvalidMethod10_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *invalidServiceClient) InvalidMethod11(ctx context.Context, in *RequestWithNestedStorageAndRepo, opts ...grpc.CallOption) (*InvalidMethodResponse, error) {
	out := new(InvalidMethodResponse)
	err := c.cc.Invoke(ctx, InvalidService_InvalidMethod11_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *invalidServiceClient) InvalidMethod13(ctx context.Context, in *InvalidTargetType, opts ...grpc.CallOption) (*InvalidMethodResponse, error) {
	out := new(InvalidMethodResponse)
	err := c.cc.Invoke(ctx, InvalidService_InvalidMethod13_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *invalidServiceClient) InvalidMethod14(ctx context.Context, in *RequestWithMultipleNestedStorage, opts ...grpc.CallOption) (*InvalidMethodResponse, error) {
	out := new(InvalidMethodResponse)
	err := c.cc.Invoke(ctx, InvalidService_InvalidMethod14_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *invalidServiceClient) MaintenanceWithMissingRepository(ctx context.Context, in *InvalidMethodRequest, opts ...grpc.CallOption) (*InvalidMethodResponse, error) {
	out := new(InvalidMethodResponse)
	err := c.cc.Invoke(ctx, InvalidService_MaintenanceWithMissingRepository_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *invalidServiceClient) MaintenanceWithUnflaggedRepository(ctx context.Context, in *RequestWithNestedRepoNotFlagged, opts ...grpc.CallOption) (*InvalidMethodResponse, error) {
	out := new(InvalidMethodResponse)
	err := c.cc.Invoke(ctx, InvalidService_MaintenanceWithUnflaggedRepository_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *invalidServiceClient) MaintenanceWithWrongNestedRepositoryType(ctx context.Context, in *RequestWithWrongTypeRepository, opts ...grpc.CallOption) (*InvalidMethodResponse, error) {
	out := new(InvalidMethodResponse)
	err := c.cc.Invoke(ctx, InvalidService_MaintenanceWithWrongNestedRepositoryType_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *invalidServiceClient) MaintenanceWithInvalidTargetType(ctx context.Context, in *InvalidTargetType, opts ...grpc.CallOption) (*InvalidMethodResponse, error) {
	out := new(InvalidMethodResponse)
	err := c.cc.Invoke(ctx, InvalidService_MaintenanceWithInvalidTargetType_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *invalidServiceClient) MaintenanceWithInvalidNestedRequest(ctx context.Context, in *InvalidNestedRequest, opts ...grpc.CallOption) (*InvalidMethodResponse, error) {
	out := new(InvalidMethodResponse)
	err := c.cc.Invoke(ctx, InvalidService_MaintenanceWithInvalidNestedRequest_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *invalidServiceClient) MaintenanceWithStorageAndRepository(ctx context.Context, in *RequestWithStorageAndRepo, opts ...grpc.CallOption) (*InvalidMethodResponse, error) {
	out := new(InvalidMethodResponse)
	err := c.cc.Invoke(ctx, InvalidService_MaintenanceWithStorageAndRepository_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *invalidServiceClient) MaintenanceWithNestedStorageAndRepository(ctx context.Context, in *RequestWithNestedStorageAndRepo, opts ...grpc.CallOption) (*InvalidMethodResponse, error) {
	out := new(InvalidMethodResponse)
	err := c.cc.Invoke(ctx, InvalidService_MaintenanceWithNestedStorageAndRepository_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *invalidServiceClient) MaintenanceWithStorageScope(ctx context.Context, in *InvalidMethodRequestWithRepo, opts ...grpc.CallOption) (*InvalidMethodResponse, error) {
	out := new(InvalidMethodResponse)
	err := c.cc.Invoke(ctx, InvalidService_MaintenanceWithStorageScope_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// InvalidServiceServer is the server API for InvalidService service.
// All implementations must embed UnimplementedInvalidServiceServer
// for forward compatibility
type InvalidServiceServer interface {
	// should fail if op_type extension is missing
	InvalidMethod0(context.Context, *InvalidMethodRequest) (*InvalidMethodResponse, error)
	// should fail if op type is unknown
	InvalidMethod1(context.Context, *InvalidMethodRequest) (*InvalidMethodResponse, error)
	// should fail if target repo is not provided for accessor
	InvalidMethod2(context.Context, *InvalidMethodRequest) (*InvalidMethodResponse, error)
	// should fail if missing either target repo or non-repo-scope for mutator
	InvalidMethod4(context.Context, *InvalidMethodRequest) (*InvalidMethodResponse, error)
	// should fail if repository is not of type Repository
	InvalidMethod5(context.Context, *RequestWithWrongTypeRepository) (*InvalidMethodResponse, error)
	// should fail if nested repository isn't flagged
	InvalidMethod6(context.Context, *RequestWithNestedRepoNotFlagged) (*InvalidMethodResponse, error)
	// should fail if target field type is not of type Repository
	InvalidMethod7(context.Context, *InvalidTargetType) (*InvalidMethodResponse, error)
	// should fail if nested target field type is not of type Repository
	InvalidMethod8(context.Context, *InvalidNestedRequest) (*InvalidMethodResponse, error)
	// should fail if target repo is specified for storage scoped RPC
	InvalidMethod9(context.Context, *InvalidMethodRequestWithRepo) (*InvalidMethodResponse, error)
	// should fail if storage is specified for implicit repository scoped RPC
	InvalidMethod10(context.Context, *RequestWithStorageAndRepo) (*InvalidMethodResponse, error)
	// should fail if storage is specified for repository scoped RPC
	InvalidMethod11(context.Context, *RequestWithNestedStorageAndRepo) (*InvalidMethodResponse, error)
	// should fail if storage isn't specified for storage scoped RPC
	InvalidMethod13(context.Context, *InvalidTargetType) (*InvalidMethodResponse, error)
	// should fail if multiple storage is specified for storage scoped RPC
	InvalidMethod14(context.Context, *RequestWithMultipleNestedStorage) (*InvalidMethodResponse, error)
	MaintenanceWithMissingRepository(context.Context, *InvalidMethodRequest) (*InvalidMethodResponse, error)
	MaintenanceWithUnflaggedRepository(context.Context, *RequestWithNestedRepoNotFlagged) (*InvalidMethodResponse, error)
	MaintenanceWithWrongNestedRepositoryType(context.Context, *RequestWithWrongTypeRepository) (*InvalidMethodResponse, error)
	MaintenanceWithInvalidTargetType(context.Context, *InvalidTargetType) (*InvalidMethodResponse, error)
	MaintenanceWithInvalidNestedRequest(context.Context, *InvalidNestedRequest) (*InvalidMethodResponse, error)
	MaintenanceWithStorageAndRepository(context.Context, *RequestWithStorageAndRepo) (*InvalidMethodResponse, error)
	MaintenanceWithNestedStorageAndRepository(context.Context, *RequestWithNestedStorageAndRepo) (*InvalidMethodResponse, error)
	MaintenanceWithStorageScope(context.Context, *InvalidMethodRequestWithRepo) (*InvalidMethodResponse, error)
	mustEmbedUnimplementedInvalidServiceServer()
}

// UnimplementedInvalidServiceServer must be embedded to have forward compatible implementations.
type UnimplementedInvalidServiceServer struct {
}

func (UnimplementedInvalidServiceServer) InvalidMethod0(context.Context, *InvalidMethodRequest) (*InvalidMethodResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method InvalidMethod0 not implemented")
}
func (UnimplementedInvalidServiceServer) InvalidMethod1(context.Context, *InvalidMethodRequest) (*InvalidMethodResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method InvalidMethod1 not implemented")
}
func (UnimplementedInvalidServiceServer) InvalidMethod2(context.Context, *InvalidMethodRequest) (*InvalidMethodResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method InvalidMethod2 not implemented")
}
func (UnimplementedInvalidServiceServer) InvalidMethod4(context.Context, *InvalidMethodRequest) (*InvalidMethodResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method InvalidMethod4 not implemented")
}
func (UnimplementedInvalidServiceServer) InvalidMethod5(context.Context, *RequestWithWrongTypeRepository) (*InvalidMethodResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method InvalidMethod5 not implemented")
}
func (UnimplementedInvalidServiceServer) InvalidMethod6(context.Context, *RequestWithNestedRepoNotFlagged) (*InvalidMethodResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method InvalidMethod6 not implemented")
}
func (UnimplementedInvalidServiceServer) InvalidMethod7(context.Context, *InvalidTargetType) (*InvalidMethodResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method InvalidMethod7 not implemented")
}
func (UnimplementedInvalidServiceServer) InvalidMethod8(context.Context, *InvalidNestedRequest) (*InvalidMethodResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method InvalidMethod8 not implemented")
}
func (UnimplementedInvalidServiceServer) InvalidMethod9(context.Context, *InvalidMethodRequestWithRepo) (*InvalidMethodResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method InvalidMethod9 not implemented")
}
func (UnimplementedInvalidServiceServer) InvalidMethod10(context.Context, *RequestWithStorageAndRepo) (*InvalidMethodResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method InvalidMethod10 not implemented")
}
func (UnimplementedInvalidServiceServer) InvalidMethod11(context.Context, *RequestWithNestedStorageAndRepo) (*InvalidMethodResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method InvalidMethod11 not implemented")
}
func (UnimplementedInvalidServiceServer) InvalidMethod13(context.Context, *InvalidTargetType) (*InvalidMethodResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method InvalidMethod13 not implemented")
}
func (UnimplementedInvalidServiceServer) InvalidMethod14(context.Context, *RequestWithMultipleNestedStorage) (*InvalidMethodResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method InvalidMethod14 not implemented")
}
func (UnimplementedInvalidServiceServer) MaintenanceWithMissingRepository(context.Context, *InvalidMethodRequest) (*InvalidMethodResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MaintenanceWithMissingRepository not implemented")
}
func (UnimplementedInvalidServiceServer) MaintenanceWithUnflaggedRepository(context.Context, *RequestWithNestedRepoNotFlagged) (*InvalidMethodResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MaintenanceWithUnflaggedRepository not implemented")
}
func (UnimplementedInvalidServiceServer) MaintenanceWithWrongNestedRepositoryType(context.Context, *RequestWithWrongTypeRepository) (*InvalidMethodResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MaintenanceWithWrongNestedRepositoryType not implemented")
}
func (UnimplementedInvalidServiceServer) MaintenanceWithInvalidTargetType(context.Context, *InvalidTargetType) (*InvalidMethodResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MaintenanceWithInvalidTargetType not implemented")
}
func (UnimplementedInvalidServiceServer) MaintenanceWithInvalidNestedRequest(context.Context, *InvalidNestedRequest) (*InvalidMethodResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MaintenanceWithInvalidNestedRequest not implemented")
}
func (UnimplementedInvalidServiceServer) MaintenanceWithStorageAndRepository(context.Context, *RequestWithStorageAndRepo) (*InvalidMethodResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MaintenanceWithStorageAndRepository not implemented")
}
func (UnimplementedInvalidServiceServer) MaintenanceWithNestedStorageAndRepository(context.Context, *RequestWithNestedStorageAndRepo) (*InvalidMethodResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MaintenanceWithNestedStorageAndRepository not implemented")
}
func (UnimplementedInvalidServiceServer) MaintenanceWithStorageScope(context.Context, *InvalidMethodRequestWithRepo) (*InvalidMethodResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MaintenanceWithStorageScope not implemented")
}
func (UnimplementedInvalidServiceServer) mustEmbedUnimplementedInvalidServiceServer() {}

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

func RegisterInvalidServiceServer(s grpc.ServiceRegistrar, srv InvalidServiceServer) {
	s.RegisterService(&InvalidService_ServiceDesc, srv)
}

func _InvalidService_InvalidMethod0_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InvalidMethodRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InvalidServiceServer).InvalidMethod0(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InvalidService_InvalidMethod0_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InvalidServiceServer).InvalidMethod0(ctx, req.(*InvalidMethodRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _InvalidService_InvalidMethod1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InvalidMethodRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InvalidServiceServer).InvalidMethod1(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InvalidService_InvalidMethod1_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InvalidServiceServer).InvalidMethod1(ctx, req.(*InvalidMethodRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _InvalidService_InvalidMethod2_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InvalidMethodRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InvalidServiceServer).InvalidMethod2(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InvalidService_InvalidMethod2_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InvalidServiceServer).InvalidMethod2(ctx, req.(*InvalidMethodRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _InvalidService_InvalidMethod4_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InvalidMethodRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InvalidServiceServer).InvalidMethod4(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InvalidService_InvalidMethod4_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InvalidServiceServer).InvalidMethod4(ctx, req.(*InvalidMethodRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _InvalidService_InvalidMethod5_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RequestWithWrongTypeRepository)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InvalidServiceServer).InvalidMethod5(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InvalidService_InvalidMethod5_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InvalidServiceServer).InvalidMethod5(ctx, req.(*RequestWithWrongTypeRepository))
	}
	return interceptor(ctx, in, info, handler)
}

func _InvalidService_InvalidMethod6_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RequestWithNestedRepoNotFlagged)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InvalidServiceServer).InvalidMethod6(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InvalidService_InvalidMethod6_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InvalidServiceServer).InvalidMethod6(ctx, req.(*RequestWithNestedRepoNotFlagged))
	}
	return interceptor(ctx, in, info, handler)
}

func _InvalidService_InvalidMethod7_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InvalidTargetType)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InvalidServiceServer).InvalidMethod7(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InvalidService_InvalidMethod7_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InvalidServiceServer).InvalidMethod7(ctx, req.(*InvalidTargetType))
	}
	return interceptor(ctx, in, info, handler)
}

func _InvalidService_InvalidMethod8_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InvalidNestedRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InvalidServiceServer).InvalidMethod8(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InvalidService_InvalidMethod8_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InvalidServiceServer).InvalidMethod8(ctx, req.(*InvalidNestedRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _InvalidService_InvalidMethod9_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InvalidMethodRequestWithRepo)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InvalidServiceServer).InvalidMethod9(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InvalidService_InvalidMethod9_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InvalidServiceServer).InvalidMethod9(ctx, req.(*InvalidMethodRequestWithRepo))
	}
	return interceptor(ctx, in, info, handler)
}

func _InvalidService_InvalidMethod10_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RequestWithStorageAndRepo)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InvalidServiceServer).InvalidMethod10(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InvalidService_InvalidMethod10_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InvalidServiceServer).InvalidMethod10(ctx, req.(*RequestWithStorageAndRepo))
	}
	return interceptor(ctx, in, info, handler)
}

func _InvalidService_InvalidMethod11_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RequestWithNestedStorageAndRepo)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InvalidServiceServer).InvalidMethod11(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InvalidService_InvalidMethod11_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InvalidServiceServer).InvalidMethod11(ctx, req.(*RequestWithNestedStorageAndRepo))
	}
	return interceptor(ctx, in, info, handler)
}

func _InvalidService_InvalidMethod13_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InvalidTargetType)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InvalidServiceServer).InvalidMethod13(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InvalidService_InvalidMethod13_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InvalidServiceServer).InvalidMethod13(ctx, req.(*InvalidTargetType))
	}
	return interceptor(ctx, in, info, handler)
}

func _InvalidService_InvalidMethod14_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RequestWithMultipleNestedStorage)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InvalidServiceServer).InvalidMethod14(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InvalidService_InvalidMethod14_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InvalidServiceServer).InvalidMethod14(ctx, req.(*RequestWithMultipleNestedStorage))
	}
	return interceptor(ctx, in, info, handler)
}

func _InvalidService_MaintenanceWithMissingRepository_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InvalidMethodRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InvalidServiceServer).MaintenanceWithMissingRepository(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InvalidService_MaintenanceWithMissingRepository_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InvalidServiceServer).MaintenanceWithMissingRepository(ctx, req.(*InvalidMethodRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _InvalidService_MaintenanceWithUnflaggedRepository_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RequestWithNestedRepoNotFlagged)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InvalidServiceServer).MaintenanceWithUnflaggedRepository(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InvalidService_MaintenanceWithUnflaggedRepository_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InvalidServiceServer).MaintenanceWithUnflaggedRepository(ctx, req.(*RequestWithNestedRepoNotFlagged))
	}
	return interceptor(ctx, in, info, handler)
}

func _InvalidService_MaintenanceWithWrongNestedRepositoryType_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RequestWithWrongTypeRepository)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InvalidServiceServer).MaintenanceWithWrongNestedRepositoryType(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InvalidService_MaintenanceWithWrongNestedRepositoryType_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InvalidServiceServer).MaintenanceWithWrongNestedRepositoryType(ctx, req.(*RequestWithWrongTypeRepository))
	}
	return interceptor(ctx, in, info, handler)
}

func _InvalidService_MaintenanceWithInvalidTargetType_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InvalidTargetType)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InvalidServiceServer).MaintenanceWithInvalidTargetType(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InvalidService_MaintenanceWithInvalidTargetType_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InvalidServiceServer).MaintenanceWithInvalidTargetType(ctx, req.(*InvalidTargetType))
	}
	return interceptor(ctx, in, info, handler)
}

func _InvalidService_MaintenanceWithInvalidNestedRequest_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InvalidNestedRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InvalidServiceServer).MaintenanceWithInvalidNestedRequest(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InvalidService_MaintenanceWithInvalidNestedRequest_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InvalidServiceServer).MaintenanceWithInvalidNestedRequest(ctx, req.(*InvalidNestedRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _InvalidService_MaintenanceWithStorageAndRepository_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RequestWithStorageAndRepo)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InvalidServiceServer).MaintenanceWithStorageAndRepository(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InvalidService_MaintenanceWithStorageAndRepository_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InvalidServiceServer).MaintenanceWithStorageAndRepository(ctx, req.(*RequestWithStorageAndRepo))
	}
	return interceptor(ctx, in, info, handler)
}

func _InvalidService_MaintenanceWithNestedStorageAndRepository_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RequestWithNestedStorageAndRepo)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InvalidServiceServer).MaintenanceWithNestedStorageAndRepository(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InvalidService_MaintenanceWithNestedStorageAndRepository_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InvalidServiceServer).MaintenanceWithNestedStorageAndRepository(ctx, req.(*RequestWithNestedStorageAndRepo))
	}
	return interceptor(ctx, in, info, handler)
}

func _InvalidService_MaintenanceWithStorageScope_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InvalidMethodRequestWithRepo)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InvalidServiceServer).MaintenanceWithStorageScope(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InvalidService_MaintenanceWithStorageScope_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InvalidServiceServer).MaintenanceWithStorageScope(ctx, req.(*InvalidMethodRequestWithRepo))
	}
	return interceptor(ctx, in, info, handler)
}

// InvalidService_ServiceDesc is the grpc.ServiceDesc for InvalidService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var InvalidService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "testproto.InvalidService",
	HandlerType: (*InvalidServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "InvalidMethod0",
			Handler:    _InvalidService_InvalidMethod0_Handler,
		},
		{
			MethodName: "InvalidMethod1",
			Handler:    _InvalidService_InvalidMethod1_Handler,
		},
		{
			MethodName: "InvalidMethod2",
			Handler:    _InvalidService_InvalidMethod2_Handler,
		},
		{
			MethodName: "InvalidMethod4",
			Handler:    _InvalidService_InvalidMethod4_Handler,
		},
		{
			MethodName: "InvalidMethod5",
			Handler:    _InvalidService_InvalidMethod5_Handler,
		},
		{
			MethodName: "InvalidMethod6",
			Handler:    _InvalidService_InvalidMethod6_Handler,
		},
		{
			MethodName: "InvalidMethod7",
			Handler:    _InvalidService_InvalidMethod7_Handler,
		},
		{
			MethodName: "InvalidMethod8",
			Handler:    _InvalidService_InvalidMethod8_Handler,
		},
		{
			MethodName: "InvalidMethod9",
			Handler:    _InvalidService_InvalidMethod9_Handler,
		},
		{
			MethodName: "InvalidMethod10",
			Handler:    _InvalidService_InvalidMethod10_Handler,
		},
		{
			MethodName: "InvalidMethod11",
			Handler:    _InvalidService_InvalidMethod11_Handler,
		},
		{
			MethodName: "InvalidMethod13",
			Handler:    _InvalidService_InvalidMethod13_Handler,
		},
		{
			MethodName: "InvalidMethod14",
			Handler:    _InvalidService_InvalidMethod14_Handler,
		},
		{
			MethodName: "MaintenanceWithMissingRepository",
			Handler:    _InvalidService_MaintenanceWithMissingRepository_Handler,
		},
		{
			MethodName: "MaintenanceWithUnflaggedRepository",
			Handler:    _InvalidService_MaintenanceWithUnflaggedRepository_Handler,
		},
		{
			MethodName: "MaintenanceWithWrongNestedRepositoryType",
			Handler:    _InvalidService_MaintenanceWithWrongNestedRepositoryType_Handler,
		},
		{
			MethodName: "MaintenanceWithInvalidTargetType",
			Handler:    _InvalidService_MaintenanceWithInvalidTargetType_Handler,
		},
		{
			MethodName: "MaintenanceWithInvalidNestedRequest",
			Handler:    _InvalidService_MaintenanceWithInvalidNestedRequest_Handler,
		},
		{
			MethodName: "MaintenanceWithStorageAndRepository",
			Handler:    _InvalidService_MaintenanceWithStorageAndRepository_Handler,
		},
		{
			MethodName: "MaintenanceWithNestedStorageAndRepository",
			Handler:    _InvalidService_MaintenanceWithNestedStorageAndRepository_Handler,
		},
		{
			MethodName: "MaintenanceWithStorageScope",
			Handler:    _InvalidService_MaintenanceWithStorageScope_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "testproto/invalid.proto",
}
