// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.6.1
// - protoc             v6.30.2
// 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.64.0 or later.
const _ = grpc.SupportPackageIsVersion9

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) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(InvalidMethodResponse)
	err := c.cc.Invoke(ctx, InterceptedWithOperationType_InvalidMethod_FullMethodName, in, out, cOpts...)
	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.
//
// NOTE: this should be embedded by value instead of pointer to avoid a nil
// pointer dereference when methods are called.
type UnimplementedInterceptedWithOperationTypeServer struct{}

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

// 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) {
	// If the following call panics, it indicates UnimplementedInterceptedWithOperationTypeServer 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(&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_InvalidMethod15_FullMethodName                           = "/testproto.InvalidService/InvalidMethod15"
	InvalidService_InvalidMethod16_FullMethodName                           = "/testproto.InvalidService/InvalidMethod16"
	InvalidService_InvalidMethod17_FullMethodName                           = "/testproto.InvalidService/InvalidMethod17"
	InvalidService_InvalidMethod18_FullMethodName                           = "/testproto.InvalidService/InvalidMethod18"
	InvalidService_InvalidMethod19_FullMethodName                           = "/testproto.InvalidService/InvalidMethod19"
	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)
	// should fail if storage isn't specified for partition scoped RPC
	InvalidMethod15(ctx context.Context, in *InvalidMethodRequest, opts ...grpc.CallOption) (*InvalidMethodResponse, error)
	// should fail if target repo is specified for partition scoped RPC
	InvalidMethod16(ctx context.Context, in *InvalidMethodRequestWithRepo, opts ...grpc.CallOption) (*InvalidMethodResponse, error)
	// should fail if partition id isn't specified for partition scoped RPC
	InvalidMethod17(ctx context.Context, in *RequestWithStorage, opts ...grpc.CallOption) (*InvalidMethodResponse, error)
	// should fail if partition is specified for repository scoped RPC
	InvalidMethod18(ctx context.Context, in *RequestWithPartition, opts ...grpc.CallOption) (*InvalidMethodResponse, error)
	// should fail if partition is specified for storage scoped RPC
	InvalidMethod19(ctx context.Context, in *RequestWithPartition, 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) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(InvalidMethodResponse)
	err := c.cc.Invoke(ctx, InvalidService_InvalidMethod0_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

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

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

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

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

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

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

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

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

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

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

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

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

func (c *invalidServiceClient) InvalidMethod15(ctx context.Context, in *InvalidMethodRequest, opts ...grpc.CallOption) (*InvalidMethodResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(InvalidMethodResponse)
	err := c.cc.Invoke(ctx, InvalidService_InvalidMethod15_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *invalidServiceClient) InvalidMethod16(ctx context.Context, in *InvalidMethodRequestWithRepo, opts ...grpc.CallOption) (*InvalidMethodResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(InvalidMethodResponse)
	err := c.cc.Invoke(ctx, InvalidService_InvalidMethod16_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *invalidServiceClient) InvalidMethod17(ctx context.Context, in *RequestWithStorage, opts ...grpc.CallOption) (*InvalidMethodResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(InvalidMethodResponse)
	err := c.cc.Invoke(ctx, InvalidService_InvalidMethod17_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *invalidServiceClient) InvalidMethod18(ctx context.Context, in *RequestWithPartition, opts ...grpc.CallOption) (*InvalidMethodResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(InvalidMethodResponse)
	err := c.cc.Invoke(ctx, InvalidService_InvalidMethod18_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *invalidServiceClient) InvalidMethod19(ctx context.Context, in *RequestWithPartition, opts ...grpc.CallOption) (*InvalidMethodResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(InvalidMethodResponse)
	err := c.cc.Invoke(ctx, InvalidService_InvalidMethod19_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

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

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

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

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

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

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

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

func (c *invalidServiceClient) MaintenanceWithStorageScope(ctx context.Context, in *InvalidMethodRequestWithRepo, opts ...grpc.CallOption) (*InvalidMethodResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(InvalidMethodResponse)
	err := c.cc.Invoke(ctx, InvalidService_MaintenanceWithStorageScope_FullMethodName, in, out, cOpts...)
	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)
	// should fail if storage isn't specified for partition scoped RPC
	InvalidMethod15(context.Context, *InvalidMethodRequest) (*InvalidMethodResponse, error)
	// should fail if target repo is specified for partition scoped RPC
	InvalidMethod16(context.Context, *InvalidMethodRequestWithRepo) (*InvalidMethodResponse, error)
	// should fail if partition id isn't specified for partition scoped RPC
	InvalidMethod17(context.Context, *RequestWithStorage) (*InvalidMethodResponse, error)
	// should fail if partition is specified for repository scoped RPC
	InvalidMethod18(context.Context, *RequestWithPartition) (*InvalidMethodResponse, error)
	// should fail if partition is specified for storage scoped RPC
	InvalidMethod19(context.Context, *RequestWithPartition) (*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.
//
// NOTE: this should be embedded by value instead of pointer to avoid a nil
// pointer dereference when methods are called.
type UnimplementedInvalidServiceServer struct{}

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

// 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) {
	// If the following call panics, it indicates UnimplementedInvalidServiceServer 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(&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_InvalidMethod15_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).InvalidMethod15(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InvalidService_InvalidMethod15_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InvalidServiceServer).InvalidMethod15(ctx, req.(*InvalidMethodRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _InvalidService_InvalidMethod16_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).InvalidMethod16(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InvalidService_InvalidMethod16_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InvalidServiceServer).InvalidMethod16(ctx, req.(*InvalidMethodRequestWithRepo))
	}
	return interceptor(ctx, in, info, handler)
}

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

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

func _InvalidService_InvalidMethod19_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RequestWithPartition)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InvalidServiceServer).InvalidMethod19(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InvalidService_InvalidMethod19_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InvalidServiceServer).InvalidMethod19(ctx, req.(*RequestWithPartition))
	}
	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: "InvalidMethod15",
			Handler:    _InvalidService_InvalidMethod15_Handler,
		},
		{
			MethodName: "InvalidMethod16",
			Handler:    _InvalidService_InvalidMethod16_Handler,
		},
		{
			MethodName: "InvalidMethod17",
			Handler:    _InvalidService_InvalidMethod17_Handler,
		},
		{
			MethodName: "InvalidMethod18",
			Handler:    _InvalidService_InvalidMethod18_Handler,
		},
		{
			MethodName: "InvalidMethod19",
			Handler:    _InvalidService_InvalidMethod19_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",
}
