// Code generated by protoc-gen-go. DO NOT EDIT.
// source: go/internal/linter/testdata/valid.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 ValidRequest 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 *ValidRequest) Reset()         { *m = ValidRequest{} }
func (m *ValidRequest) String() string { return proto.CompactTextString(m) }
func (*ValidRequest) ProtoMessage()    {}
func (*ValidRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_7058768ff0db2cf7, []int{0}
}

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

var xxx_messageInfo_ValidRequest proto.InternalMessageInfo

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

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

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

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

var xxx_messageInfo_ValidRequestWithoutRepo proto.InternalMessageInfo

type ValidStorageRequest 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 *ValidStorageRequest) Reset()         { *m = ValidStorageRequest{} }
func (m *ValidStorageRequest) String() string { return proto.CompactTextString(m) }
func (*ValidStorageRequest) ProtoMessage()    {}
func (*ValidStorageRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_7058768ff0db2cf7, []int{2}
}

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

var xxx_messageInfo_ValidStorageRequest proto.InternalMessageInfo

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

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

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

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

var xxx_messageInfo_ValidResponse proto.InternalMessageInfo

type ValidNestedRequest struct {
	InnerMessage         *ValidRequest `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 *ValidNestedRequest) Reset()         { *m = ValidNestedRequest{} }
func (m *ValidNestedRequest) String() string { return proto.CompactTextString(m) }
func (*ValidNestedRequest) ProtoMessage()    {}
func (*ValidNestedRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_7058768ff0db2cf7, []int{4}
}

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

var xxx_messageInfo_ValidNestedRequest proto.InternalMessageInfo

func (m *ValidNestedRequest) GetInnerMessage() *ValidRequest {
	if m != nil {
		return m.InnerMessage
	}
	return nil
}

type ValidStorageNestedRequest struct {
	InnerMessage         *ValidStorageRequest `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 *ValidStorageNestedRequest) Reset()         { *m = ValidStorageNestedRequest{} }
func (m *ValidStorageNestedRequest) String() string { return proto.CompactTextString(m) }
func (*ValidStorageNestedRequest) ProtoMessage()    {}
func (*ValidStorageNestedRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_7058768ff0db2cf7, []int{5}
}

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

var xxx_messageInfo_ValidStorageNestedRequest proto.InternalMessageInfo

func (m *ValidStorageNestedRequest) GetInnerMessage() *ValidStorageRequest {
	if m != nil {
		return m.InnerMessage
	}
	return nil
}

type ValidNestedSharedRequest struct {
	NestedTargetRepo     *gitalypb.ObjectPool `protobuf:"bytes,1,opt,name=nested_target_repo,json=nestedTargetRepo,proto3" json:"nested_target_repo,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

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

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

var xxx_messageInfo_ValidNestedSharedRequest proto.InternalMessageInfo

func (m *ValidNestedSharedRequest) GetNestedTargetRepo() *gitalypb.ObjectPool {
	if m != nil {
		return m.NestedTargetRepo
	}
	return nil
}

type ValidInnerNestedRequest struct {
	Header               *ValidInnerNestedRequest_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 *ValidInnerNestedRequest) Reset()         { *m = ValidInnerNestedRequest{} }
func (m *ValidInnerNestedRequest) String() string { return proto.CompactTextString(m) }
func (*ValidInnerNestedRequest) ProtoMessage()    {}
func (*ValidInnerNestedRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_7058768ff0db2cf7, []int{7}
}

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

var xxx_messageInfo_ValidInnerNestedRequest proto.InternalMessageInfo

func (m *ValidInnerNestedRequest) GetHeader() *ValidInnerNestedRequest_Header {
	if m != nil {
		return m.Header
	}
	return nil
}

type ValidInnerNestedRequest_Header 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 *ValidInnerNestedRequest_Header) Reset()         { *m = ValidInnerNestedRequest_Header{} }
func (m *ValidInnerNestedRequest_Header) String() string { return proto.CompactTextString(m) }
func (*ValidInnerNestedRequest_Header) ProtoMessage()    {}
func (*ValidInnerNestedRequest_Header) Descriptor() ([]byte, []int) {
	return fileDescriptor_7058768ff0db2cf7, []int{7, 0}
}

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

var xxx_messageInfo_ValidInnerNestedRequest_Header proto.InternalMessageInfo

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

type ValidStorageInnerNestedRequest struct {
	Header               *ValidStorageInnerNestedRequest_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 *ValidStorageInnerNestedRequest) Reset()         { *m = ValidStorageInnerNestedRequest{} }
func (m *ValidStorageInnerNestedRequest) String() string { return proto.CompactTextString(m) }
func (*ValidStorageInnerNestedRequest) ProtoMessage()    {}
func (*ValidStorageInnerNestedRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_7058768ff0db2cf7, []int{8}
}

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

var xxx_messageInfo_ValidStorageInnerNestedRequest proto.InternalMessageInfo

func (m *ValidStorageInnerNestedRequest) GetHeader() *ValidStorageInnerNestedRequest_Header {
	if m != nil {
		return m.Header
	}
	return nil
}

type ValidStorageInnerNestedRequest_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 *ValidStorageInnerNestedRequest_Header) Reset()         { *m = ValidStorageInnerNestedRequest_Header{} }
func (m *ValidStorageInnerNestedRequest_Header) String() string { return proto.CompactTextString(m) }
func (*ValidStorageInnerNestedRequest_Header) ProtoMessage()    {}
func (*ValidStorageInnerNestedRequest_Header) Descriptor() ([]byte, []int) {
	return fileDescriptor_7058768ff0db2cf7, []int{8, 0}
}

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

var xxx_messageInfo_ValidStorageInnerNestedRequest_Header proto.InternalMessageInfo

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

func init() {
	proto.RegisterType((*ValidRequest)(nil), "test.ValidRequest")
	proto.RegisterType((*ValidRequestWithoutRepo)(nil), "test.ValidRequestWithoutRepo")
	proto.RegisterType((*ValidStorageRequest)(nil), "test.ValidStorageRequest")
	proto.RegisterType((*ValidResponse)(nil), "test.ValidResponse")
	proto.RegisterType((*ValidNestedRequest)(nil), "test.ValidNestedRequest")
	proto.RegisterType((*ValidStorageNestedRequest)(nil), "test.ValidStorageNestedRequest")
	proto.RegisterType((*ValidNestedSharedRequest)(nil), "test.ValidNestedSharedRequest")
	proto.RegisterType((*ValidInnerNestedRequest)(nil), "test.ValidInnerNestedRequest")
	proto.RegisterType((*ValidInnerNestedRequest_Header)(nil), "test.ValidInnerNestedRequest.Header")
	proto.RegisterType((*ValidStorageInnerNestedRequest)(nil), "test.ValidStorageInnerNestedRequest")
	proto.RegisterType((*ValidStorageInnerNestedRequest_Header)(nil), "test.ValidStorageInnerNestedRequest.Header")
}

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

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

// InterceptedServiceClient is the client API for InterceptedService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type InterceptedServiceClient interface {
	TestMethod(ctx context.Context, in *ValidRequest, opts ...grpc.CallOption) (*ValidResponse, error)
}

type interceptedServiceClient struct {
	cc *grpc.ClientConn
}

func NewInterceptedServiceClient(cc *grpc.ClientConn) InterceptedServiceClient {
	return &interceptedServiceClient{cc}
}

func (c *interceptedServiceClient) TestMethod(ctx context.Context, in *ValidRequest, opts ...grpc.CallOption) (*ValidResponse, error) {
	out := new(ValidResponse)
	err := c.cc.Invoke(ctx, "/test.InterceptedService/TestMethod", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// InterceptedServiceServer is the server API for InterceptedService service.
type InterceptedServiceServer interface {
	TestMethod(context.Context, *ValidRequest) (*ValidResponse, error)
}

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

func (*UnimplementedInterceptedServiceServer) TestMethod(ctx context.Context, req *ValidRequest) (*ValidResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method TestMethod not implemented")
}

func RegisterInterceptedServiceServer(s *grpc.Server, srv InterceptedServiceServer) {
	s.RegisterService(&_InterceptedService_serviceDesc, srv)
}

func _InterceptedService_TestMethod_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ValidRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InterceptedServiceServer).TestMethod(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/test.InterceptedService/TestMethod",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InterceptedServiceServer).TestMethod(ctx, req.(*ValidRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _InterceptedService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "test.InterceptedService",
	HandlerType: (*InterceptedServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "TestMethod",
			Handler:    _InterceptedService_TestMethod_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "go/internal/linter/testdata/valid.proto",
}

// ValidServiceClient is the client API for ValidService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ValidServiceClient interface {
	TestMethod(ctx context.Context, in *ValidRequest, opts ...grpc.CallOption) (*ValidResponse, error)
	TestMethod2(ctx context.Context, in *ValidRequest, opts ...grpc.CallOption) (*ValidResponse, error)
	TestMethod3(ctx context.Context, in *ValidRequest, opts ...grpc.CallOption) (*ValidResponse, error)
	TestMethod5(ctx context.Context, in *ValidNestedRequest, opts ...grpc.CallOption) (*ValidResponse, error)
	TestMethod6(ctx context.Context, in *ValidNestedSharedRequest, opts ...grpc.CallOption) (*ValidResponse, error)
	TestMethod7(ctx context.Context, in *ValidInnerNestedRequest, opts ...grpc.CallOption) (*ValidResponse, error)
	TestMethod8(ctx context.Context, in *ValidStorageRequest, opts ...grpc.CallOption) (*ValidResponse, error)
	TestMethod9(ctx context.Context, in *ValidStorageNestedRequest, opts ...grpc.CallOption) (*ValidResponse, error)
}

type validServiceClient struct {
	cc *grpc.ClientConn
}

func NewValidServiceClient(cc *grpc.ClientConn) ValidServiceClient {
	return &validServiceClient{cc}
}

func (c *validServiceClient) TestMethod(ctx context.Context, in *ValidRequest, opts ...grpc.CallOption) (*ValidResponse, error) {
	out := new(ValidResponse)
	err := c.cc.Invoke(ctx, "/test.ValidService/TestMethod", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *validServiceClient) TestMethod2(ctx context.Context, in *ValidRequest, opts ...grpc.CallOption) (*ValidResponse, error) {
	out := new(ValidResponse)
	err := c.cc.Invoke(ctx, "/test.ValidService/TestMethod2", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *validServiceClient) TestMethod3(ctx context.Context, in *ValidRequest, opts ...grpc.CallOption) (*ValidResponse, error) {
	out := new(ValidResponse)
	err := c.cc.Invoke(ctx, "/test.ValidService/TestMethod3", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *validServiceClient) TestMethod5(ctx context.Context, in *ValidNestedRequest, opts ...grpc.CallOption) (*ValidResponse, error) {
	out := new(ValidResponse)
	err := c.cc.Invoke(ctx, "/test.ValidService/TestMethod5", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *validServiceClient) TestMethod6(ctx context.Context, in *ValidNestedSharedRequest, opts ...grpc.CallOption) (*ValidResponse, error) {
	out := new(ValidResponse)
	err := c.cc.Invoke(ctx, "/test.ValidService/TestMethod6", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *validServiceClient) TestMethod7(ctx context.Context, in *ValidInnerNestedRequest, opts ...grpc.CallOption) (*ValidResponse, error) {
	out := new(ValidResponse)
	err := c.cc.Invoke(ctx, "/test.ValidService/TestMethod7", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *validServiceClient) TestMethod8(ctx context.Context, in *ValidStorageRequest, opts ...grpc.CallOption) (*ValidResponse, error) {
	out := new(ValidResponse)
	err := c.cc.Invoke(ctx, "/test.ValidService/TestMethod8", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *validServiceClient) TestMethod9(ctx context.Context, in *ValidStorageNestedRequest, opts ...grpc.CallOption) (*ValidResponse, error) {
	out := new(ValidResponse)
	err := c.cc.Invoke(ctx, "/test.ValidService/TestMethod9", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ValidServiceServer is the server API for ValidService service.
type ValidServiceServer interface {
	TestMethod(context.Context, *ValidRequest) (*ValidResponse, error)
	TestMethod2(context.Context, *ValidRequest) (*ValidResponse, error)
	TestMethod3(context.Context, *ValidRequest) (*ValidResponse, error)
	TestMethod5(context.Context, *ValidNestedRequest) (*ValidResponse, error)
	TestMethod6(context.Context, *ValidNestedSharedRequest) (*ValidResponse, error)
	TestMethod7(context.Context, *ValidInnerNestedRequest) (*ValidResponse, error)
	TestMethod8(context.Context, *ValidStorageRequest) (*ValidResponse, error)
	TestMethod9(context.Context, *ValidStorageNestedRequest) (*ValidResponse, error)
}

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

func (*UnimplementedValidServiceServer) TestMethod(ctx context.Context, req *ValidRequest) (*ValidResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method TestMethod not implemented")
}
func (*UnimplementedValidServiceServer) TestMethod2(ctx context.Context, req *ValidRequest) (*ValidResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method TestMethod2 not implemented")
}
func (*UnimplementedValidServiceServer) TestMethod3(ctx context.Context, req *ValidRequest) (*ValidResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method TestMethod3 not implemented")
}
func (*UnimplementedValidServiceServer) TestMethod5(ctx context.Context, req *ValidNestedRequest) (*ValidResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method TestMethod5 not implemented")
}
func (*UnimplementedValidServiceServer) TestMethod6(ctx context.Context, req *ValidNestedSharedRequest) (*ValidResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method TestMethod6 not implemented")
}
func (*UnimplementedValidServiceServer) TestMethod7(ctx context.Context, req *ValidInnerNestedRequest) (*ValidResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method TestMethod7 not implemented")
}
func (*UnimplementedValidServiceServer) TestMethod8(ctx context.Context, req *ValidStorageRequest) (*ValidResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method TestMethod8 not implemented")
}
func (*UnimplementedValidServiceServer) TestMethod9(ctx context.Context, req *ValidStorageNestedRequest) (*ValidResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method TestMethod9 not implemented")
}

func RegisterValidServiceServer(s *grpc.Server, srv ValidServiceServer) {
	s.RegisterService(&_ValidService_serviceDesc, srv)
}

func _ValidService_TestMethod_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ValidRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ValidServiceServer).TestMethod(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/test.ValidService/TestMethod",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ValidServiceServer).TestMethod(ctx, req.(*ValidRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ValidService_TestMethod2_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ValidRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ValidServiceServer).TestMethod2(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/test.ValidService/TestMethod2",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ValidServiceServer).TestMethod2(ctx, req.(*ValidRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ValidService_TestMethod3_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ValidRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ValidServiceServer).TestMethod3(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/test.ValidService/TestMethod3",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ValidServiceServer).TestMethod3(ctx, req.(*ValidRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ValidService_TestMethod5_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ValidNestedRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ValidServiceServer).TestMethod5(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/test.ValidService/TestMethod5",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ValidServiceServer).TestMethod5(ctx, req.(*ValidNestedRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ValidService_TestMethod6_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ValidNestedSharedRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ValidServiceServer).TestMethod6(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/test.ValidService/TestMethod6",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ValidServiceServer).TestMethod6(ctx, req.(*ValidNestedSharedRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ValidService_TestMethod7_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ValidInnerNestedRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ValidServiceServer).TestMethod7(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/test.ValidService/TestMethod7",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ValidServiceServer).TestMethod7(ctx, req.(*ValidInnerNestedRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ValidService_TestMethod8_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ValidStorageRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ValidServiceServer).TestMethod8(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/test.ValidService/TestMethod8",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ValidServiceServer).TestMethod8(ctx, req.(*ValidStorageRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ValidService_TestMethod9_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ValidStorageNestedRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ValidServiceServer).TestMethod9(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/test.ValidService/TestMethod9",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ValidServiceServer).TestMethod9(ctx, req.(*ValidStorageNestedRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _ValidService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "test.ValidService",
	HandlerType: (*ValidServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "TestMethod",
			Handler:    _ValidService_TestMethod_Handler,
		},
		{
			MethodName: "TestMethod2",
			Handler:    _ValidService_TestMethod2_Handler,
		},
		{
			MethodName: "TestMethod3",
			Handler:    _ValidService_TestMethod3_Handler,
		},
		{
			MethodName: "TestMethod5",
			Handler:    _ValidService_TestMethod5_Handler,
		},
		{
			MethodName: "TestMethod6",
			Handler:    _ValidService_TestMethod6_Handler,
		},
		{
			MethodName: "TestMethod7",
			Handler:    _ValidService_TestMethod7_Handler,
		},
		{
			MethodName: "TestMethod8",
			Handler:    _ValidService_TestMethod8_Handler,
		},
		{
			MethodName: "TestMethod9",
			Handler:    _ValidService_TestMethod9_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "go/internal/linter/testdata/valid.proto",
}
