// Code generated by protoc-gen-go. DO NOT EDIT.
// source: go/internal/linter/testdata/invalid.proto

package test

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	gitalypb "gitlab.com/gitlab-org/gitaly/v14/proto/go/gitalypb"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	math "math"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package

type InvalidMethodRequest struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *InvalidMethodRequest) Reset()         { *m = InvalidMethodRequest{} }
func (m *InvalidMethodRequest) String() string { return proto.CompactTextString(m) }
func (*InvalidMethodRequest) ProtoMessage()    {}
func (*InvalidMethodRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_506a53e91b227711, []int{0}
}

func (m *InvalidMethodRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_InvalidMethodRequest.Unmarshal(m, b)
}
func (m *InvalidMethodRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_InvalidMethodRequest.Marshal(b, m, deterministic)
}
func (m *InvalidMethodRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_InvalidMethodRequest.Merge(m, src)
}
func (m *InvalidMethodRequest) XXX_Size() int {
	return xxx_messageInfo_InvalidMethodRequest.Size(m)
}
func (m *InvalidMethodRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_InvalidMethodRequest.DiscardUnknown(m)
}

var xxx_messageInfo_InvalidMethodRequest proto.InternalMessageInfo

type InvalidMethodRequestWithRepo struct {
	Destination          *gitalypb.Repository `protobuf:"bytes,1,opt,name=destination,proto3" json:"destination,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *InvalidMethodRequestWithRepo) Reset()         { *m = InvalidMethodRequestWithRepo{} }
func (m *InvalidMethodRequestWithRepo) String() string { return proto.CompactTextString(m) }
func (*InvalidMethodRequestWithRepo) ProtoMessage()    {}
func (*InvalidMethodRequestWithRepo) Descriptor() ([]byte, []int) {
	return fileDescriptor_506a53e91b227711, []int{1}
}

func (m *InvalidMethodRequestWithRepo) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_InvalidMethodRequestWithRepo.Unmarshal(m, b)
}
func (m *InvalidMethodRequestWithRepo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_InvalidMethodRequestWithRepo.Marshal(b, m, deterministic)
}
func (m *InvalidMethodRequestWithRepo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_InvalidMethodRequestWithRepo.Merge(m, src)
}
func (m *InvalidMethodRequestWithRepo) XXX_Size() int {
	return xxx_messageInfo_InvalidMethodRequestWithRepo.Size(m)
}
func (m *InvalidMethodRequestWithRepo) XXX_DiscardUnknown() {
	xxx_messageInfo_InvalidMethodRequestWithRepo.DiscardUnknown(m)
}

var xxx_messageInfo_InvalidMethodRequestWithRepo proto.InternalMessageInfo

func (m *InvalidMethodRequestWithRepo) GetDestination() *gitalypb.Repository {
	if m != nil {
		return m.Destination
	}
	return nil
}

type InvalidTargetType struct {
	WrongType            int32    `protobuf:"varint,1,opt,name=wrong_type,json=wrongType,proto3" json:"wrong_type,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *InvalidTargetType) Reset()         { *m = InvalidTargetType{} }
func (m *InvalidTargetType) String() string { return proto.CompactTextString(m) }
func (*InvalidTargetType) ProtoMessage()    {}
func (*InvalidTargetType) Descriptor() ([]byte, []int) {
	return fileDescriptor_506a53e91b227711, []int{2}
}

func (m *InvalidTargetType) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_InvalidTargetType.Unmarshal(m, b)
}
func (m *InvalidTargetType) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_InvalidTargetType.Marshal(b, m, deterministic)
}
func (m *InvalidTargetType) XXX_Merge(src proto.Message) {
	xxx_messageInfo_InvalidTargetType.Merge(m, src)
}
func (m *InvalidTargetType) XXX_Size() int {
	return xxx_messageInfo_InvalidTargetType.Size(m)
}
func (m *InvalidTargetType) XXX_DiscardUnknown() {
	xxx_messageInfo_InvalidTargetType.DiscardUnknown(m)
}

var xxx_messageInfo_InvalidTargetType proto.InternalMessageInfo

func (m *InvalidTargetType) GetWrongType() int32 {
	if m != nil {
		return m.WrongType
	}
	return 0
}

type InvalidMethodResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *InvalidMethodResponse) Reset()         { *m = InvalidMethodResponse{} }
func (m *InvalidMethodResponse) String() string { return proto.CompactTextString(m) }
func (*InvalidMethodResponse) ProtoMessage()    {}
func (*InvalidMethodResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_506a53e91b227711, []int{3}
}

func (m *InvalidMethodResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_InvalidMethodResponse.Unmarshal(m, b)
}
func (m *InvalidMethodResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_InvalidMethodResponse.Marshal(b, m, deterministic)
}
func (m *InvalidMethodResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_InvalidMethodResponse.Merge(m, src)
}
func (m *InvalidMethodResponse) XXX_Size() int {
	return xxx_messageInfo_InvalidMethodResponse.Size(m)
}
func (m *InvalidMethodResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_InvalidMethodResponse.DiscardUnknown(m)
}

var xxx_messageInfo_InvalidMethodResponse proto.InternalMessageInfo

type InvalidNestedRequest struct {
	InnerMessage         *InvalidTargetType `protobuf:"bytes,1,opt,name=inner_message,json=innerMessage,proto3" json:"inner_message,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (m *InvalidNestedRequest) Reset()         { *m = InvalidNestedRequest{} }
func (m *InvalidNestedRequest) String() string { return proto.CompactTextString(m) }
func (*InvalidNestedRequest) ProtoMessage()    {}
func (*InvalidNestedRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_506a53e91b227711, []int{4}
}

func (m *InvalidNestedRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_InvalidNestedRequest.Unmarshal(m, b)
}
func (m *InvalidNestedRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_InvalidNestedRequest.Marshal(b, m, deterministic)
}
func (m *InvalidNestedRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_InvalidNestedRequest.Merge(m, src)
}
func (m *InvalidNestedRequest) XXX_Size() int {
	return xxx_messageInfo_InvalidNestedRequest.Size(m)
}
func (m *InvalidNestedRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_InvalidNestedRequest.DiscardUnknown(m)
}

var xxx_messageInfo_InvalidNestedRequest proto.InternalMessageInfo

func (m *InvalidNestedRequest) GetInnerMessage() *InvalidTargetType {
	if m != nil {
		return m.InnerMessage
	}
	return nil
}

type RequestWithStorage struct {
	StorageName          string               `protobuf:"bytes,1,opt,name=storage_name,json=storageName,proto3" json:"storage_name,omitempty"`
	Destination          *gitalypb.Repository `protobuf:"bytes,2,opt,name=destination,proto3" json:"destination,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *RequestWithStorage) Reset()         { *m = RequestWithStorage{} }
func (m *RequestWithStorage) String() string { return proto.CompactTextString(m) }
func (*RequestWithStorage) ProtoMessage()    {}
func (*RequestWithStorage) Descriptor() ([]byte, []int) {
	return fileDescriptor_506a53e91b227711, []int{5}
}

func (m *RequestWithStorage) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RequestWithStorage.Unmarshal(m, b)
}
func (m *RequestWithStorage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RequestWithStorage.Marshal(b, m, deterministic)
}
func (m *RequestWithStorage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RequestWithStorage.Merge(m, src)
}
func (m *RequestWithStorage) XXX_Size() int {
	return xxx_messageInfo_RequestWithStorage.Size(m)
}
func (m *RequestWithStorage) XXX_DiscardUnknown() {
	xxx_messageInfo_RequestWithStorage.DiscardUnknown(m)
}

var xxx_messageInfo_RequestWithStorage proto.InternalMessageInfo

func (m *RequestWithStorage) GetStorageName() string {
	if m != nil {
		return m.StorageName
	}
	return ""
}

func (m *RequestWithStorage) GetDestination() *gitalypb.Repository {
	if m != nil {
		return m.Destination
	}
	return nil
}

type RequestWithStorageAndRepo struct {
	StorageName          string               `protobuf:"bytes,1,opt,name=storage_name,json=storageName,proto3" json:"storage_name,omitempty"`
	Destination          *gitalypb.Repository `protobuf:"bytes,2,opt,name=destination,proto3" json:"destination,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *RequestWithStorageAndRepo) Reset()         { *m = RequestWithStorageAndRepo{} }
func (m *RequestWithStorageAndRepo) String() string { return proto.CompactTextString(m) }
func (*RequestWithStorageAndRepo) ProtoMessage()    {}
func (*RequestWithStorageAndRepo) Descriptor() ([]byte, []int) {
	return fileDescriptor_506a53e91b227711, []int{6}
}

func (m *RequestWithStorageAndRepo) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RequestWithStorageAndRepo.Unmarshal(m, b)
}
func (m *RequestWithStorageAndRepo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RequestWithStorageAndRepo.Marshal(b, m, deterministic)
}
func (m *RequestWithStorageAndRepo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RequestWithStorageAndRepo.Merge(m, src)
}
func (m *RequestWithStorageAndRepo) XXX_Size() int {
	return xxx_messageInfo_RequestWithStorageAndRepo.Size(m)
}
func (m *RequestWithStorageAndRepo) XXX_DiscardUnknown() {
	xxx_messageInfo_RequestWithStorageAndRepo.DiscardUnknown(m)
}

var xxx_messageInfo_RequestWithStorageAndRepo proto.InternalMessageInfo

func (m *RequestWithStorageAndRepo) GetStorageName() string {
	if m != nil {
		return m.StorageName
	}
	return ""
}

func (m *RequestWithStorageAndRepo) GetDestination() *gitalypb.Repository {
	if m != nil {
		return m.Destination
	}
	return nil
}

type RequestWithNestedStorageAndRepo struct {
	InnerMessage         *RequestWithStorageAndRepo `protobuf:"bytes,1,opt,name=inner_message,json=innerMessage,proto3" json:"inner_message,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                   `json:"-"`
	XXX_unrecognized     []byte                     `json:"-"`
	XXX_sizecache        int32                      `json:"-"`
}

func (m *RequestWithNestedStorageAndRepo) Reset()         { *m = RequestWithNestedStorageAndRepo{} }
func (m *RequestWithNestedStorageAndRepo) String() string { return proto.CompactTextString(m) }
func (*RequestWithNestedStorageAndRepo) ProtoMessage()    {}
func (*RequestWithNestedStorageAndRepo) Descriptor() ([]byte, []int) {
	return fileDescriptor_506a53e91b227711, []int{7}
}

func (m *RequestWithNestedStorageAndRepo) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RequestWithNestedStorageAndRepo.Unmarshal(m, b)
}
func (m *RequestWithNestedStorageAndRepo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RequestWithNestedStorageAndRepo.Marshal(b, m, deterministic)
}
func (m *RequestWithNestedStorageAndRepo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RequestWithNestedStorageAndRepo.Merge(m, src)
}
func (m *RequestWithNestedStorageAndRepo) XXX_Size() int {
	return xxx_messageInfo_RequestWithNestedStorageAndRepo.Size(m)
}
func (m *RequestWithNestedStorageAndRepo) XXX_DiscardUnknown() {
	xxx_messageInfo_RequestWithNestedStorageAndRepo.DiscardUnknown(m)
}

var xxx_messageInfo_RequestWithNestedStorageAndRepo proto.InternalMessageInfo

func (m *RequestWithNestedStorageAndRepo) GetInnerMessage() *RequestWithStorageAndRepo {
	if m != nil {
		return m.InnerMessage
	}
	return nil
}

type RequestWithMultipleNestedStorage struct {
	InnerMessage         *RequestWithStorage `protobuf:"bytes,1,opt,name=inner_message,json=innerMessage,proto3" json:"inner_message,omitempty"`
	StorageName          string              `protobuf:"bytes,2,opt,name=storage_name,json=storageName,proto3" json:"storage_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

func (m *RequestWithMultipleNestedStorage) Reset()         { *m = RequestWithMultipleNestedStorage{} }
func (m *RequestWithMultipleNestedStorage) String() string { return proto.CompactTextString(m) }
func (*RequestWithMultipleNestedStorage) ProtoMessage()    {}
func (*RequestWithMultipleNestedStorage) Descriptor() ([]byte, []int) {
	return fileDescriptor_506a53e91b227711, []int{8}
}

func (m *RequestWithMultipleNestedStorage) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RequestWithMultipleNestedStorage.Unmarshal(m, b)
}
func (m *RequestWithMultipleNestedStorage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RequestWithMultipleNestedStorage.Marshal(b, m, deterministic)
}
func (m *RequestWithMultipleNestedStorage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RequestWithMultipleNestedStorage.Merge(m, src)
}
func (m *RequestWithMultipleNestedStorage) XXX_Size() int {
	return xxx_messageInfo_RequestWithMultipleNestedStorage.Size(m)
}
func (m *RequestWithMultipleNestedStorage) XXX_DiscardUnknown() {
	xxx_messageInfo_RequestWithMultipleNestedStorage.DiscardUnknown(m)
}

var xxx_messageInfo_RequestWithMultipleNestedStorage proto.InternalMessageInfo

func (m *RequestWithMultipleNestedStorage) GetInnerMessage() *RequestWithStorage {
	if m != nil {
		return m.InnerMessage
	}
	return nil
}

func (m *RequestWithMultipleNestedStorage) GetStorageName() string {
	if m != nil {
		return m.StorageName
	}
	return ""
}

type RequestWithInnerNestedStorage struct {
	Header               *RequestWithInnerNestedStorage_Header `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                              `json:"-"`
	XXX_unrecognized     []byte                                `json:"-"`
	XXX_sizecache        int32                                 `json:"-"`
}

func (m *RequestWithInnerNestedStorage) Reset()         { *m = RequestWithInnerNestedStorage{} }
func (m *RequestWithInnerNestedStorage) String() string { return proto.CompactTextString(m) }
func (*RequestWithInnerNestedStorage) ProtoMessage()    {}
func (*RequestWithInnerNestedStorage) Descriptor() ([]byte, []int) {
	return fileDescriptor_506a53e91b227711, []int{9}
}

func (m *RequestWithInnerNestedStorage) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RequestWithInnerNestedStorage.Unmarshal(m, b)
}
func (m *RequestWithInnerNestedStorage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RequestWithInnerNestedStorage.Marshal(b, m, deterministic)
}
func (m *RequestWithInnerNestedStorage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RequestWithInnerNestedStorage.Merge(m, src)
}
func (m *RequestWithInnerNestedStorage) XXX_Size() int {
	return xxx_messageInfo_RequestWithInnerNestedStorage.Size(m)
}
func (m *RequestWithInnerNestedStorage) XXX_DiscardUnknown() {
	xxx_messageInfo_RequestWithInnerNestedStorage.DiscardUnknown(m)
}

var xxx_messageInfo_RequestWithInnerNestedStorage proto.InternalMessageInfo

func (m *RequestWithInnerNestedStorage) GetHeader() *RequestWithInnerNestedStorage_Header {
	if m != nil {
		return m.Header
	}
	return nil
}

type RequestWithInnerNestedStorage_Header struct {
	StorageName          string   `protobuf:"bytes,1,opt,name=storage_name,json=storageName,proto3" json:"storage_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RequestWithInnerNestedStorage_Header) Reset()         { *m = RequestWithInnerNestedStorage_Header{} }
func (m *RequestWithInnerNestedStorage_Header) String() string { return proto.CompactTextString(m) }
func (*RequestWithInnerNestedStorage_Header) ProtoMessage()    {}
func (*RequestWithInnerNestedStorage_Header) Descriptor() ([]byte, []int) {
	return fileDescriptor_506a53e91b227711, []int{9, 0}
}

func (m *RequestWithInnerNestedStorage_Header) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RequestWithInnerNestedStorage_Header.Unmarshal(m, b)
}
func (m *RequestWithInnerNestedStorage_Header) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RequestWithInnerNestedStorage_Header.Marshal(b, m, deterministic)
}
func (m *RequestWithInnerNestedStorage_Header) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RequestWithInnerNestedStorage_Header.Merge(m, src)
}
func (m *RequestWithInnerNestedStorage_Header) XXX_Size() int {
	return xxx_messageInfo_RequestWithInnerNestedStorage_Header.Size(m)
}
func (m *RequestWithInnerNestedStorage_Header) XXX_DiscardUnknown() {
	xxx_messageInfo_RequestWithInnerNestedStorage_Header.DiscardUnknown(m)
}

var xxx_messageInfo_RequestWithInnerNestedStorage_Header proto.InternalMessageInfo

func (m *RequestWithInnerNestedStorage_Header) GetStorageName() string {
	if m != nil {
		return m.StorageName
	}
	return ""
}

type RequestWithWrongTypeRepository struct {
	Header               *RequestWithWrongTypeRepository_Header `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                               `json:"-"`
	XXX_unrecognized     []byte                                 `json:"-"`
	XXX_sizecache        int32                                  `json:"-"`
}

func (m *RequestWithWrongTypeRepository) Reset()         { *m = RequestWithWrongTypeRepository{} }
func (m *RequestWithWrongTypeRepository) String() string { return proto.CompactTextString(m) }
func (*RequestWithWrongTypeRepository) ProtoMessage()    {}
func (*RequestWithWrongTypeRepository) Descriptor() ([]byte, []int) {
	return fileDescriptor_506a53e91b227711, []int{10}
}

func (m *RequestWithWrongTypeRepository) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RequestWithWrongTypeRepository.Unmarshal(m, b)
}
func (m *RequestWithWrongTypeRepository) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RequestWithWrongTypeRepository.Marshal(b, m, deterministic)
}
func (m *RequestWithWrongTypeRepository) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RequestWithWrongTypeRepository.Merge(m, src)
}
func (m *RequestWithWrongTypeRepository) XXX_Size() int {
	return xxx_messageInfo_RequestWithWrongTypeRepository.Size(m)
}
func (m *RequestWithWrongTypeRepository) XXX_DiscardUnknown() {
	xxx_messageInfo_RequestWithWrongTypeRepository.DiscardUnknown(m)
}

var xxx_messageInfo_RequestWithWrongTypeRepository proto.InternalMessageInfo

func (m *RequestWithWrongTypeRepository) GetHeader() *RequestWithWrongTypeRepository_Header {
	if m != nil {
		return m.Header
	}
	return nil
}

type RequestWithWrongTypeRepository_Header struct {
	Repository           *InvalidMethodResponse `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (m *RequestWithWrongTypeRepository_Header) Reset()         { *m = RequestWithWrongTypeRepository_Header{} }
func (m *RequestWithWrongTypeRepository_Header) String() string { return proto.CompactTextString(m) }
func (*RequestWithWrongTypeRepository_Header) ProtoMessage()    {}
func (*RequestWithWrongTypeRepository_Header) Descriptor() ([]byte, []int) {
	return fileDescriptor_506a53e91b227711, []int{10, 0}
}

func (m *RequestWithWrongTypeRepository_Header) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RequestWithWrongTypeRepository_Header.Unmarshal(m, b)
}
func (m *RequestWithWrongTypeRepository_Header) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RequestWithWrongTypeRepository_Header.Marshal(b, m, deterministic)
}
func (m *RequestWithWrongTypeRepository_Header) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RequestWithWrongTypeRepository_Header.Merge(m, src)
}
func (m *RequestWithWrongTypeRepository_Header) XXX_Size() int {
	return xxx_messageInfo_RequestWithWrongTypeRepository_Header.Size(m)
}
func (m *RequestWithWrongTypeRepository_Header) XXX_DiscardUnknown() {
	xxx_messageInfo_RequestWithWrongTypeRepository_Header.DiscardUnknown(m)
}

var xxx_messageInfo_RequestWithWrongTypeRepository_Header proto.InternalMessageInfo

func (m *RequestWithWrongTypeRepository_Header) GetRepository() *InvalidMethodResponse {
	if m != nil {
		return m.Repository
	}
	return nil
}

type RequestWithNestedRepoNotFlagged struct {
	Header               *RequestWithNestedRepoNotFlagged_Header `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                                `json:"-"`
	XXX_unrecognized     []byte                                  `json:"-"`
	XXX_sizecache        int32                                   `json:"-"`
}

func (m *RequestWithNestedRepoNotFlagged) Reset()         { *m = RequestWithNestedRepoNotFlagged{} }
func (m *RequestWithNestedRepoNotFlagged) String() string { return proto.CompactTextString(m) }
func (*RequestWithNestedRepoNotFlagged) ProtoMessage()    {}
func (*RequestWithNestedRepoNotFlagged) Descriptor() ([]byte, []int) {
	return fileDescriptor_506a53e91b227711, []int{11}
}

func (m *RequestWithNestedRepoNotFlagged) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RequestWithNestedRepoNotFlagged.Unmarshal(m, b)
}
func (m *RequestWithNestedRepoNotFlagged) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RequestWithNestedRepoNotFlagged.Marshal(b, m, deterministic)
}
func (m *RequestWithNestedRepoNotFlagged) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RequestWithNestedRepoNotFlagged.Merge(m, src)
}
func (m *RequestWithNestedRepoNotFlagged) XXX_Size() int {
	return xxx_messageInfo_RequestWithNestedRepoNotFlagged.Size(m)
}
func (m *RequestWithNestedRepoNotFlagged) XXX_DiscardUnknown() {
	xxx_messageInfo_RequestWithNestedRepoNotFlagged.DiscardUnknown(m)
}

var xxx_messageInfo_RequestWithNestedRepoNotFlagged proto.InternalMessageInfo

func (m *RequestWithNestedRepoNotFlagged) GetHeader() *RequestWithNestedRepoNotFlagged_Header {
	if m != nil {
		return m.Header
	}
	return nil
}

type RequestWithNestedRepoNotFlagged_Header struct {
	Repository           *gitalypb.Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *RequestWithNestedRepoNotFlagged_Header) Reset() {
	*m = RequestWithNestedRepoNotFlagged_Header{}
}
func (m *RequestWithNestedRepoNotFlagged_Header) String() string { return proto.CompactTextString(m) }
func (*RequestWithNestedRepoNotFlagged_Header) ProtoMessage()    {}
func (*RequestWithNestedRepoNotFlagged_Header) Descriptor() ([]byte, []int) {
	return fileDescriptor_506a53e91b227711, []int{11, 0}
}

func (m *RequestWithNestedRepoNotFlagged_Header) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RequestWithNestedRepoNotFlagged_Header.Unmarshal(m, b)
}
func (m *RequestWithNestedRepoNotFlagged_Header) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RequestWithNestedRepoNotFlagged_Header.Marshal(b, m, deterministic)
}
func (m *RequestWithNestedRepoNotFlagged_Header) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RequestWithNestedRepoNotFlagged_Header.Merge(m, src)
}
func (m *RequestWithNestedRepoNotFlagged_Header) XXX_Size() int {
	return xxx_messageInfo_RequestWithNestedRepoNotFlagged_Header.Size(m)
}
func (m *RequestWithNestedRepoNotFlagged_Header) XXX_DiscardUnknown() {
	xxx_messageInfo_RequestWithNestedRepoNotFlagged_Header.DiscardUnknown(m)
}

var xxx_messageInfo_RequestWithNestedRepoNotFlagged_Header proto.InternalMessageInfo

func (m *RequestWithNestedRepoNotFlagged_Header) GetRepository() *gitalypb.Repository {
	if m != nil {
		return m.Repository
	}
	return nil
}

func init() {
	proto.RegisterType((*InvalidMethodRequest)(nil), "test.InvalidMethodRequest")
	proto.RegisterType((*InvalidMethodRequestWithRepo)(nil), "test.InvalidMethodRequestWithRepo")
	proto.RegisterType((*InvalidTargetType)(nil), "test.InvalidTargetType")
	proto.RegisterType((*InvalidMethodResponse)(nil), "test.InvalidMethodResponse")
	proto.RegisterType((*InvalidNestedRequest)(nil), "test.InvalidNestedRequest")
	proto.RegisterType((*RequestWithStorage)(nil), "test.RequestWithStorage")
	proto.RegisterType((*RequestWithStorageAndRepo)(nil), "test.RequestWithStorageAndRepo")
	proto.RegisterType((*RequestWithNestedStorageAndRepo)(nil), "test.RequestWithNestedStorageAndRepo")
	proto.RegisterType((*RequestWithMultipleNestedStorage)(nil), "test.RequestWithMultipleNestedStorage")
	proto.RegisterType((*RequestWithInnerNestedStorage)(nil), "test.RequestWithInnerNestedStorage")
	proto.RegisterType((*RequestWithInnerNestedStorage_Header)(nil), "test.RequestWithInnerNestedStorage.Header")
	proto.RegisterType((*RequestWithWrongTypeRepository)(nil), "test.RequestWithWrongTypeRepository")
	proto.RegisterType((*RequestWithWrongTypeRepository_Header)(nil), "test.RequestWithWrongTypeRepository.Header")
	proto.RegisterType((*RequestWithNestedRepoNotFlagged)(nil), "test.RequestWithNestedRepoNotFlagged")
	proto.RegisterType((*RequestWithNestedRepoNotFlagged_Header)(nil), "test.RequestWithNestedRepoNotFlagged.Header")
}

func init() {
	proto.RegisterFile("go/internal/linter/testdata/invalid.proto", fileDescriptor_506a53e91b227711)
}

var fileDescriptor_506a53e91b227711 = []byte{
	// 711 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x96, 0x5b, 0x4f, 0xd4, 0x40,
	0x14, 0xc7, 0xed, 0x66, 0xdd, 0x2c, 0x07, 0xf0, 0x32, 0x51, 0xc1, 0xf5, 0x02, 0xa9, 0xb7, 0x55,
	0x49, 0x17, 0x16, 0x54, 0x24, 0xf8, 0xc0, 0xc6, 0x18, 0x91, 0xb0, 0xea, 0x42, 0x42, 0xe2, 0x25,
	0x38, 0xd2, 0x93, 0x6e, 0x93, 0xd2, 0xd6, 0x99, 0x01, 0xb3, 0x6f, 0x3e, 0x1a, 0x9f, 0x7c, 0x12,
	0xbf, 0x83, 0x5f, 0xc0, 0x4f, 0xe0, 0xe7, 0xf1, 0x99, 0x07, 0x63, 0x7a, 0xd9, 0xa5, 0x9d, 0x4e,
	0xb1, 0xc2, 0x5b, 0x33, 0x3d, 0xe7, 0x7f, 0x7e, 0xf3, 0x3f, 0x73, 0x3a, 0x85, 0xdb, 0x96, 0xd7,
	0xb0, 0x5d, 0x81, 0xcc, 0xa5, 0x4e, 0xc3, 0x09, 0x9f, 0x1a, 0x02, 0xb9, 0x30, 0xa9, 0xa0, 0x0d,
	0xdb, 0xdd, 0xa5, 0x8e, 0x6d, 0x1a, 0x3e, 0xf3, 0x84, 0x47, 0xca, 0xc1, 0x7a, 0x0d, 0x82, 0xa0,
	0x68, 0xa5, 0x36, 0xc2, 0xbb, 0x94, 0x61, 0xfc, 0x5e, 0xbf, 0x00, 0xe7, 0x96, 0xa3, 0x84, 0x55,
	0x14, 0x5d, 0xcf, 0xec, 0xe0, 0x87, 0x1d, 0xe4, 0x42, 0x7f, 0x05, 0x97, 0x55, 0xeb, 0x1b, 0xb6,
	0xe8, 0x76, 0xd0, 0xf7, 0xc8, 0x02, 0x0c, 0x9b, 0xc8, 0x85, 0xed, 0x52, 0x61, 0x7b, 0xee, 0xb8,
	0x36, 0xa9, 0xd5, 0x87, 0x9b, 0xc4, 0xb0, 0x6c, 0x41, 0x9d, 0x9e, 0x11, 0x84, 0x70, 0x5b, 0x78,
	0xac, 0xd7, 0x2a, 0x7f, 0xff, 0x35, 0xa5, 0x75, 0x92, 0xc1, 0xfa, 0x3c, 0x9c, 0x8d, 0xb5, 0xd7,
	0x29, 0xb3, 0x50, 0xac, 0xf7, 0x7c, 0x24, 0xd7, 0x00, 0x3e, 0x32, 0xcf, 0xb5, 0x36, 0x45, 0xcf,
	0xc7, 0x50, 0xef, 0x64, 0x9c, 0x3b, 0x14, 0xae, 0x07, 0x41, 0xfa, 0x18, 0x9c, 0x97, 0xa8, 0xb8,
	0xef, 0xb9, 0x1c, 0xf5, 0xf5, 0xc1, 0x36, 0xda, 0xc8, 0x05, 0xf6, 0x71, 0xc9, 0x22, 0x8c, 0xda,
	0xae, 0x8b, 0x6c, 0x73, 0x1b, 0x39, 0xa7, 0x16, 0xc6, 0xa0, 0x63, 0x46, 0x60, 0x8b, 0x91, 0xa1,
	0xe8, 0x8c, 0x84, 0xd1, 0xab, 0x51, 0xb0, 0xce, 0x81, 0x24, 0xf6, 0xbd, 0x26, 0x3c, 0x46, 0x2d,
	0x24, 0xb7, 0x60, 0x84, 0x47, 0x8f, 0x9b, 0x2e, 0xdd, 0x8e, 0x24, 0x87, 0x5a, 0xe5, 0xcf, 0xe1,
	0x3e, 0xe3, 0x37, 0x6d, 0xba, 0x8d, 0x64, 0x2e, 0xed, 0x51, 0x29, 0xcf, 0xa3, 0xb4, 0x3b, 0x9f,
	0x34, 0xb8, 0x98, 0xad, 0xba, 0xe4, 0x9a, 0xa1, 0xef, 0x85, 0x8b, 0x2f, 0x14, 0x2c, 0xae, 0x6a,
	0x90, 0x05, 0x13, 0x09, 0x82, 0xc8, 0x51, 0x89, 0xe3, 0xb1, 0xda, 0xd8, 0x89, 0xc8, 0xd8, 0x5c,
	0x7e, 0xc9, 0xe0, 0x2f, 0x1a, 0x4c, 0x26, 0x62, 0x57, 0x77, 0x1c, 0x61, 0xfb, 0x0e, 0xa6, 0x2a,
	0x92, 0x47, 0xea, 0x52, 0xe3, 0x79, 0xa5, 0xd2, 0x35, 0x32, 0x8e, 0x95, 0x72, 0x1c, 0xd3, 0xbf,
	0x69, 0x70, 0x25, 0xa1, 0xb6, 0x1c, 0x88, 0xa4, 0x49, 0x5a, 0x50, 0xe9, 0x22, 0x35, 0x91, 0xc5,
	0x08, 0x77, 0x32, 0x08, 0xd9, 0x24, 0xe3, 0x69, 0x98, 0xd1, 0x89, 0x33, 0x6b, 0x33, 0x50, 0x89,
	0x56, 0x0a, 0xb7, 0x52, 0xff, 0xa9, 0xc1, 0xd5, 0x44, 0x8d, 0x8d, 0xfe, 0x38, 0x1c, 0x34, 0x91,
	0x2c, 0x4b, 0x64, 0x77, 0x33, 0x64, 0x8a, 0xac, 0x18, 0x2d, 0x3e, 0x01, 0x7d, 0xc0, 0x95, 0x01,
	0xe0, 0x12, 0x00, 0x1b, 0x04, 0xc7, 0xc2, 0x97, 0x52, 0x93, 0x93, 0x9e, 0xc2, 0x56, 0xf9, 0x6b,
	0x20, 0x94, 0x48, 0xd2, 0x7f, 0x68, 0x8a, 0xa3, 0x14, 0x10, 0xb4, 0x3d, 0xf1, 0xc4, 0xa1, 0x96,
	0x85, 0x26, 0x79, 0x26, 0xb1, 0x4f, 0x65, 0xd8, 0x55, 0x69, 0x6a, 0xf8, 0xc5, 0x01, 0x7c, 0x53,
	0x01, 0xaf, 0x9a, 0xbd, 0x44, 0x54, 0x73, 0x37, 0xf8, 0xe8, 0x09, 0x64, 0x5b, 0xe8, 0x0b, 0x34,
	0x83, 0xca, 0xcf, 0x7d, 0x64, 0xe1, 0x4c, 0x84, 0xdf, 0xa8, 0x17, 0x30, 0x9a, 0xda, 0x38, 0xa9,
	0x29, 0xdd, 0x08, 0xb9, 0x6b, 0x87, 0x39, 0xa5, 0x57, 0xf6, 0xf7, 0xea, 0xa5, 0x6a, 0xa9, 0x56,
	0xfe, 0xbd, 0x57, 0xd7, 0x9a, 0x7f, 0xaa, 0x70, 0x2a, 0x8e, 0x5b, 0x43, 0xb6, 0x6b, 0x6f, 0x21,
	0x59, 0x19, 0xac, 0x44, 0x99, 0xd3, 0x47, 0xaf, 0x75, 0x82, 0xbc, 0x94, 0xc4, 0x66, 0x8e, 0x0b,
	0x9e, 0x95, 0x6c, 0x1e, 0xdb, 0x8b, 0x8c, 0xe4, 0xdc, 0x71, 0x25, 0x35, 0xf2, 0x5a, 0x92, 0xbc,
	0x47, 0xae, 0x17, 0x19, 0x8c, 0x62, 0xe2, 0x6f, 0x24, 0xf1, 0xfb, 0xe4, 0x46, 0xa1, 0x93, 0x5b,
	0x4c, 0xbd, 0x2d, 0xa9, 0x3f, 0x20, 0x79, 0x97, 0x56, 0x31, 0x3d, 0xd9, 0xdd, 0x79, 0xc9, 0xdd,
	0xd4, 0xbd, 0x79, 0x34, 0x77, 0x1f, 0x12, 0x3d, 0xbf, 0x61, 0xfd, 0x3f, 0x87, 0xc3, 0xa5, 0xab,
	0xfb, 0x7b, 0xf5, 0x72, 0x55, 0x3b, 0x53, 0x22, 0x1b, 0x70, 0x3a, 0x7d, 0x66, 0xa7, 0xc9, 0xbf,
	0x2e, 0x97, 0x62, 0xc7, 0xec, 0xad, 0x2c, 0x3c, 0x93, 0xdb, 0xb7, 0xff, 0x97, 0x0f, 0x7c, 0x96,
	0xe4, 0x67, 0x8f, 0xd8, 0xb8, 0x03, 0x2b, 0xde, 0xc9, 0x92, 0x73, 0xe4, 0x66, 0x86, 0x58, 0x79,
	0x77, 0x16, 0xac, 0xf0, 0xbe, 0x12, 0xfe, 0x0c, 0xce, 0xfe, 0x0d, 0x00, 0x00, 0xff, 0xff, 0x76,
	0x6b, 0x7b, 0x04, 0x59, 0x0a, 0x00, 0x00,
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// InterceptedWithOperationTypeClient is the client API for InterceptedWithOperationType service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#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.ClientConn
}

func NewInterceptedWithOperationTypeClient(cc *grpc.ClientConn) 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, "/test.InterceptedWithOperationType/InvalidMethod", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

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

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

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

func RegisterInterceptedWithOperationTypeServer(s *grpc.Server, 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: "/test.InterceptedWithOperationType/InvalidMethod",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InterceptedWithOperationTypeServer).InvalidMethod(ctx, req.(*InvalidMethodRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _InterceptedWithOperationType_serviceDesc = grpc.ServiceDesc{
	ServiceName: "test.InterceptedWithOperationType",
	HandlerType: (*InterceptedWithOperationTypeServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "InvalidMethod",
			Handler:    _InterceptedWithOperationType_InvalidMethod_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "go/internal/linter/testdata/invalid.proto",
}

// InvalidServiceClient is the client API for InvalidService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#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)
}

type invalidServiceClient struct {
	cc *grpc.ClientConn
}

func NewInvalidServiceClient(cc *grpc.ClientConn) 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, "/test.InvalidService/InvalidMethod0", 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, "/test.InvalidService/InvalidMethod1", 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, "/test.InvalidService/InvalidMethod2", 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, "/test.InvalidService/InvalidMethod4", 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, "/test.InvalidService/InvalidMethod5", 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, "/test.InvalidService/InvalidMethod6", 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, "/test.InvalidService/InvalidMethod7", 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, "/test.InvalidService/InvalidMethod8", 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, "/test.InvalidService/InvalidMethod9", 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, "/test.InvalidService/InvalidMethod10", 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, "/test.InvalidService/InvalidMethod11", 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, "/test.InvalidService/InvalidMethod13", 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, "/test.InvalidService/InvalidMethod14", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// InvalidServiceServer is the server API for InvalidService service.
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)
}

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

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

func RegisterInvalidServiceServer(s *grpc.Server, 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: "/test.InvalidService/InvalidMethod0",
	}
	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: "/test.InvalidService/InvalidMethod1",
	}
	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: "/test.InvalidService/InvalidMethod2",
	}
	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: "/test.InvalidService/InvalidMethod4",
	}
	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: "/test.InvalidService/InvalidMethod5",
	}
	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: "/test.InvalidService/InvalidMethod6",
	}
	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: "/test.InvalidService/InvalidMethod7",
	}
	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: "/test.InvalidService/InvalidMethod8",
	}
	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: "/test.InvalidService/InvalidMethod9",
	}
	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: "/test.InvalidService/InvalidMethod10",
	}
	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: "/test.InvalidService/InvalidMethod11",
	}
	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: "/test.InvalidService/InvalidMethod13",
	}
	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: "/test.InvalidService/InvalidMethod14",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InvalidServiceServer).InvalidMethod14(ctx, req.(*RequestWithMultipleNestedStorage))
	}
	return interceptor(ctx, in, info, handler)
}

var _InvalidService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "test.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,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "go/internal/linter/testdata/invalid.proto",
}
