api_grpc.pb.go

// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.2.0
// - protoc             v3.12.4
// source: mockgcp/cloud/bigquery/v2/api.proto

package bigquerypb

import (
	context "context"
	empty "github.com/golang/protobuf/ptypes/empty"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
)

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
// Requires gRPC-Go v1.32.0 or later.
const _ = grpc.SupportPackageIsVersion7

// DatasetsServerClient is the client API for DatasetsServer service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type DatasetsServerClient interface {
	DeleteDataset(ctx context.Context, in *DeleteDatasetRequest, opts ...grpc.CallOption) (*empty.Empty, error)
	GetDataset(ctx context.Context, in *GetDatasetRequest, opts ...grpc.CallOption) (*Dataset, error)
	InsertDataset(ctx context.Context, in *InsertDatasetRequest, opts ...grpc.CallOption) (*Dataset, error)
	ListDatasets(ctx context.Context, in *ListDatasetsRequest, opts ...grpc.CallOption) (*DatasetList, error)
	PatchDataset(ctx context.Context, in *PatchDatasetRequest, opts ...grpc.CallOption) (*Dataset, error)
	UndeleteDataset(ctx context.Context, in *UndeleteDatasetServiceRequest, opts ...grpc.CallOption) (*Dataset, error)
	UpdateDataset(ctx context.Context, in *UpdateDatasetRequest, opts ...grpc.CallOption) (*Dataset, error)
}

type datasetsServerClient struct {
	cc grpc.ClientConnInterface
}

func NewDatasetsServerClient(cc grpc.ClientConnInterface) DatasetsServerClient {
	return &datasetsServerClient{cc}
}

func (c *datasetsServerClient) DeleteDataset(ctx context.Context, in *DeleteDatasetRequest, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/google.cloud.bigquery.v2.DatasetsServer/DeleteDataset", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *datasetsServerClient) GetDataset(ctx context.Context, in *GetDatasetRequest, opts ...grpc.CallOption) (*Dataset, error) {
	out := new(Dataset)
	err := c.cc.Invoke(ctx, "/google.cloud.bigquery.v2.DatasetsServer/GetDataset", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *datasetsServerClient) InsertDataset(ctx context.Context, in *InsertDatasetRequest, opts ...grpc.CallOption) (*Dataset, error) {
	out := new(Dataset)
	err := c.cc.Invoke(ctx, "/google.cloud.bigquery.v2.DatasetsServer/InsertDataset", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *datasetsServerClient) ListDatasets(ctx context.Context, in *ListDatasetsRequest, opts ...grpc.CallOption) (*DatasetList, error) {
	out := new(DatasetList)
	err := c.cc.Invoke(ctx, "/google.cloud.bigquery.v2.DatasetsServer/ListDatasets", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *datasetsServerClient) PatchDataset(ctx context.Context, in *PatchDatasetRequest, opts ...grpc.CallOption) (*Dataset, error) {
	out := new(Dataset)
	err := c.cc.Invoke(ctx, "/google.cloud.bigquery.v2.DatasetsServer/PatchDataset", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *datasetsServerClient) UndeleteDataset(ctx context.Context, in *UndeleteDatasetServiceRequest, opts ...grpc.CallOption) (*Dataset, error) {
	out := new(Dataset)
	err := c.cc.Invoke(ctx, "/google.cloud.bigquery.v2.DatasetsServer/UndeleteDataset", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *datasetsServerClient) UpdateDataset(ctx context.Context, in *UpdateDatasetRequest, opts ...grpc.CallOption) (*Dataset, error) {
	out := new(Dataset)
	err := c.cc.Invoke(ctx, "/google.cloud.bigquery.v2.DatasetsServer/UpdateDataset", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// DatasetsServerServer is the server API for DatasetsServer service.
// All implementations must embed UnimplementedDatasetsServerServer
// for forward compatibility
type DatasetsServerServer interface {
	DeleteDataset(context.Context, *DeleteDatasetRequest) (*empty.Empty, error)
	GetDataset(context.Context, *GetDatasetRequest) (*Dataset, error)
	InsertDataset(context.Context, *InsertDatasetRequest) (*Dataset, error)
	ListDatasets(context.Context, *ListDatasetsRequest) (*DatasetList, error)
	PatchDataset(context.Context, *PatchDatasetRequest) (*Dataset, error)
	UndeleteDataset(context.Context, *UndeleteDatasetServiceRequest) (*Dataset, error)
	UpdateDataset(context.Context, *UpdateDatasetRequest) (*Dataset, error)
	mustEmbedUnimplementedDatasetsServerServer()
}

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

func (UnimplementedDatasetsServerServer) DeleteDataset(context.Context, *DeleteDatasetRequest) (*empty.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteDataset not implemented")
}
func (UnimplementedDatasetsServerServer) GetDataset(context.Context, *GetDatasetRequest) (*Dataset, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetDataset not implemented")
}
func (UnimplementedDatasetsServerServer) InsertDataset(context.Context, *InsertDatasetRequest) (*Dataset, error) {
	return nil, status.Errorf(codes.Unimplemented, "method InsertDataset not implemented")
}
func (UnimplementedDatasetsServerServer) ListDatasets(context.Context, *ListDatasetsRequest) (*DatasetList, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListDatasets not implemented")
}
func (UnimplementedDatasetsServerServer) PatchDataset(context.Context, *PatchDatasetRequest) (*Dataset, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PatchDataset not implemented")
}
func (UnimplementedDatasetsServerServer) UndeleteDataset(context.Context, *UndeleteDatasetServiceRequest) (*Dataset, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UndeleteDataset not implemented")
}
func (UnimplementedDatasetsServerServer) UpdateDataset(context.Context, *UpdateDatasetRequest) (*Dataset, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateDataset not implemented")
}
func (UnimplementedDatasetsServerServer) mustEmbedUnimplementedDatasetsServerServer() {}

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

func RegisterDatasetsServerServer(s grpc.ServiceRegistrar, srv DatasetsServerServer) {
	s.RegisterService(&DatasetsServer_ServiceDesc, srv)
}

func _DatasetsServer_DeleteDataset_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteDatasetRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DatasetsServerServer).DeleteDataset(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/google.cloud.bigquery.v2.DatasetsServer/DeleteDataset",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DatasetsServerServer).DeleteDataset(ctx, req.(*DeleteDatasetRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DatasetsServer_GetDataset_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetDatasetRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DatasetsServerServer).GetDataset(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/google.cloud.bigquery.v2.DatasetsServer/GetDataset",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DatasetsServerServer).GetDataset(ctx, req.(*GetDatasetRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DatasetsServer_InsertDataset_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InsertDatasetRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DatasetsServerServer).InsertDataset(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/google.cloud.bigquery.v2.DatasetsServer/InsertDataset",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DatasetsServerServer).InsertDataset(ctx, req.(*InsertDatasetRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DatasetsServer_ListDatasets_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListDatasetsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DatasetsServerServer).ListDatasets(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/google.cloud.bigquery.v2.DatasetsServer/ListDatasets",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DatasetsServerServer).ListDatasets(ctx, req.(*ListDatasetsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DatasetsServer_PatchDataset_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PatchDatasetRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DatasetsServerServer).PatchDataset(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/google.cloud.bigquery.v2.DatasetsServer/PatchDataset",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DatasetsServerServer).PatchDataset(ctx, req.(*PatchDatasetRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DatasetsServer_UndeleteDataset_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UndeleteDatasetServiceRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DatasetsServerServer).UndeleteDataset(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/google.cloud.bigquery.v2.DatasetsServer/UndeleteDataset",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DatasetsServerServer).UndeleteDataset(ctx, req.(*UndeleteDatasetServiceRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DatasetsServer_UpdateDataset_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateDatasetRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DatasetsServerServer).UpdateDataset(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/google.cloud.bigquery.v2.DatasetsServer/UpdateDataset",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DatasetsServerServer).UpdateDataset(ctx, req.(*UpdateDatasetRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// DatasetsServer_ServiceDesc is the grpc.ServiceDesc for DatasetsServer service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var DatasetsServer_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "google.cloud.bigquery.v2.DatasetsServer",
	HandlerType: (*DatasetsServerServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "DeleteDataset",
			Handler:    _DatasetsServer_DeleteDataset_Handler,
		},
		{
			MethodName: "GetDataset",
			Handler:    _DatasetsServer_GetDataset_Handler,
		},
		{
			MethodName: "InsertDataset",
			Handler:    _DatasetsServer_InsertDataset_Handler,
		},
		{
			MethodName: "ListDatasets",
			Handler:    _DatasetsServer_ListDatasets_Handler,
		},
		{
			MethodName: "PatchDataset",
			Handler:    _DatasetsServer_PatchDataset_Handler,
		},
		{
			MethodName: "UndeleteDataset",
			Handler:    _DatasetsServer_UndeleteDataset_Handler,
		},
		{
			MethodName: "UpdateDataset",
			Handler:    _DatasetsServer_UpdateDataset_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "mockgcp/cloud/bigquery/v2/api.proto",
}

// JobsServerClient is the client API for JobsServer service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type JobsServerClient interface {
	CancelJob(ctx context.Context, in *CancelJobRequest, opts ...grpc.CallOption) (*JobCancelResponse, error)
	DeleteJob(ctx context.Context, in *DeleteJobRequest, opts ...grpc.CallOption) (*empty.Empty, error)
	GetJob(ctx context.Context, in *GetJobRequest, opts ...grpc.CallOption) (*Job, error)
	GetQueryResultsJob(ctx context.Context, in *GetQueryResultsJobRequest, opts ...grpc.CallOption) (*GetQueryResultsResponse, error)
	InsertJob(ctx context.Context, in *InsertJobRequest, opts ...grpc.CallOption) (*Job, error)
	ListJobs(ctx context.Context, in *ListJobsRequest, opts ...grpc.CallOption) (*JobList, error)
	QueryJob(ctx context.Context, in *QueryJobRequest, opts ...grpc.CallOption) (*QueryResponse, error)
}

type jobsServerClient struct {
	cc grpc.ClientConnInterface
}

func NewJobsServerClient(cc grpc.ClientConnInterface) JobsServerClient {
	return &jobsServerClient{cc}
}

func (c *jobsServerClient) CancelJob(ctx context.Context, in *CancelJobRequest, opts ...grpc.CallOption) (*JobCancelResponse, error) {
	out := new(JobCancelResponse)
	err := c.cc.Invoke(ctx, "/google.cloud.bigquery.v2.JobsServer/CancelJob", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *jobsServerClient) DeleteJob(ctx context.Context, in *DeleteJobRequest, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/google.cloud.bigquery.v2.JobsServer/DeleteJob", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *jobsServerClient) GetJob(ctx context.Context, in *GetJobRequest, opts ...grpc.CallOption) (*Job, error) {
	out := new(Job)
	err := c.cc.Invoke(ctx, "/google.cloud.bigquery.v2.JobsServer/GetJob", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *jobsServerClient) GetQueryResultsJob(ctx context.Context, in *GetQueryResultsJobRequest, opts ...grpc.CallOption) (*GetQueryResultsResponse, error) {
	out := new(GetQueryResultsResponse)
	err := c.cc.Invoke(ctx, "/google.cloud.bigquery.v2.JobsServer/GetQueryResultsJob", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *jobsServerClient) InsertJob(ctx context.Context, in *InsertJobRequest, opts ...grpc.CallOption) (*Job, error) {
	out := new(Job)
	err := c.cc.Invoke(ctx, "/google.cloud.bigquery.v2.JobsServer/InsertJob", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *jobsServerClient) ListJobs(ctx context.Context, in *ListJobsRequest, opts ...grpc.CallOption) (*JobList, error) {
	out := new(JobList)
	err := c.cc.Invoke(ctx, "/google.cloud.bigquery.v2.JobsServer/ListJobs", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *jobsServerClient) QueryJob(ctx context.Context, in *QueryJobRequest, opts ...grpc.CallOption) (*QueryResponse, error) {
	out := new(QueryResponse)
	err := c.cc.Invoke(ctx, "/google.cloud.bigquery.v2.JobsServer/QueryJob", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// JobsServerServer is the server API for JobsServer service.
// All implementations must embed UnimplementedJobsServerServer
// for forward compatibility
type JobsServerServer interface {
	CancelJob(context.Context, *CancelJobRequest) (*JobCancelResponse, error)
	DeleteJob(context.Context, *DeleteJobRequest) (*empty.Empty, error)
	GetJob(context.Context, *GetJobRequest) (*Job, error)
	GetQueryResultsJob(context.Context, *GetQueryResultsJobRequest) (*GetQueryResultsResponse, error)
	InsertJob(context.Context, *InsertJobRequest) (*Job, error)
	ListJobs(context.Context, *ListJobsRequest) (*JobList, error)
	QueryJob(context.Context, *QueryJobRequest) (*QueryResponse, error)
	mustEmbedUnimplementedJobsServerServer()
}

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

func (UnimplementedJobsServerServer) CancelJob(context.Context, *CancelJobRequest) (*JobCancelResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CancelJob not implemented")
}
func (UnimplementedJobsServerServer) DeleteJob(context.Context, *DeleteJobRequest) (*empty.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteJob not implemented")
}
func (UnimplementedJobsServerServer) GetJob(context.Context, *GetJobRequest) (*Job, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetJob not implemented")
}
func (UnimplementedJobsServerServer) GetQueryResultsJob(context.Context, *GetQueryResultsJobRequest) (*GetQueryResultsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetQueryResultsJob not implemented")
}
func (UnimplementedJobsServerServer) InsertJob(context.Context, *InsertJobRequest) (*Job, error) {
	return nil, status.Errorf(codes.Unimplemented, "method InsertJob not implemented")
}
func (UnimplementedJobsServerServer) ListJobs(context.Context, *ListJobsRequest) (*JobList, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListJobs not implemented")
}
func (UnimplementedJobsServerServer) QueryJob(context.Context, *QueryJobRequest) (*QueryResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method QueryJob not implemented")
}
func (UnimplementedJobsServerServer) mustEmbedUnimplementedJobsServerServer() {}

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

func RegisterJobsServerServer(s grpc.ServiceRegistrar, srv JobsServerServer) {
	s.RegisterService(&JobsServer_ServiceDesc, srv)
}

func _JobsServer_CancelJob_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CancelJobRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(JobsServerServer).CancelJob(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/google.cloud.bigquery.v2.JobsServer/CancelJob",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(JobsServerServer).CancelJob(ctx, req.(*CancelJobRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _JobsServer_DeleteJob_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteJobRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(JobsServerServer).DeleteJob(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/google.cloud.bigquery.v2.JobsServer/DeleteJob",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(JobsServerServer).DeleteJob(ctx, req.(*DeleteJobRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _JobsServer_GetJob_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetJobRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(JobsServerServer).GetJob(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/google.cloud.bigquery.v2.JobsServer/GetJob",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(JobsServerServer).GetJob(ctx, req.(*GetJobRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _JobsServer_GetQueryResultsJob_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetQueryResultsJobRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(JobsServerServer).GetQueryResultsJob(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/google.cloud.bigquery.v2.JobsServer/GetQueryResultsJob",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(JobsServerServer).GetQueryResultsJob(ctx, req.(*GetQueryResultsJobRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _JobsServer_InsertJob_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InsertJobRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(JobsServerServer).InsertJob(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/google.cloud.bigquery.v2.JobsServer/InsertJob",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(JobsServerServer).InsertJob(ctx, req.(*InsertJobRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _JobsServer_ListJobs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListJobsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(JobsServerServer).ListJobs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/google.cloud.bigquery.v2.JobsServer/ListJobs",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(JobsServerServer).ListJobs(ctx, req.(*ListJobsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _JobsServer_QueryJob_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryJobRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(JobsServerServer).QueryJob(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/google.cloud.bigquery.v2.JobsServer/QueryJob",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(JobsServerServer).QueryJob(ctx, req.(*QueryJobRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// JobsServer_ServiceDesc is the grpc.ServiceDesc for JobsServer service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var JobsServer_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "google.cloud.bigquery.v2.JobsServer",
	HandlerType: (*JobsServerServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CancelJob",
			Handler:    _JobsServer_CancelJob_Handler,
		},
		{
			MethodName: "DeleteJob",
			Handler:    _JobsServer_DeleteJob_Handler,
		},
		{
			MethodName: "GetJob",
			Handler:    _JobsServer_GetJob_Handler,
		},
		{
			MethodName: "GetQueryResultsJob",
			Handler:    _JobsServer_GetQueryResultsJob_Handler,
		},
		{
			MethodName: "InsertJob",
			Handler:    _JobsServer_InsertJob_Handler,
		},
		{
			MethodName: "ListJobs",
			Handler:    _JobsServer_ListJobs_Handler,
		},
		{
			MethodName: "QueryJob",
			Handler:    _JobsServer_QueryJob_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "mockgcp/cloud/bigquery/v2/api.proto",
}

// ModelsServerClient is the client API for ModelsServer service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type ModelsServerClient interface {
	DeleteModel(ctx context.Context, in *DeleteModelRequest, opts ...grpc.CallOption) (*empty.Empty, error)
	GetModel(ctx context.Context, in *GetModelRequest, opts ...grpc.CallOption) (*Model, error)
	ListModels(ctx context.Context, in *ListModelsRequest, opts ...grpc.CallOption) (*ListModelsResponse, error)
	PatchModel(ctx context.Context, in *PatchModelRequest, opts ...grpc.CallOption) (*Model, error)
}

type modelsServerClient struct {
	cc grpc.ClientConnInterface
}

func NewModelsServerClient(cc grpc.ClientConnInterface) ModelsServerClient {
	return &modelsServerClient{cc}
}

func (c *modelsServerClient) DeleteModel(ctx context.Context, in *DeleteModelRequest, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/google.cloud.bigquery.v2.ModelsServer/DeleteModel", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *modelsServerClient) GetModel(ctx context.Context, in *GetModelRequest, opts ...grpc.CallOption) (*Model, error) {
	out := new(Model)
	err := c.cc.Invoke(ctx, "/google.cloud.bigquery.v2.ModelsServer/GetModel", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *modelsServerClient) ListModels(ctx context.Context, in *ListModelsRequest, opts ...grpc.CallOption) (*ListModelsResponse, error) {
	out := new(ListModelsResponse)
	err := c.cc.Invoke(ctx, "/google.cloud.bigquery.v2.ModelsServer/ListModels", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *modelsServerClient) PatchModel(ctx context.Context, in *PatchModelRequest, opts ...grpc.CallOption) (*Model, error) {
	out := new(Model)
	err := c.cc.Invoke(ctx, "/google.cloud.bigquery.v2.ModelsServer/PatchModel", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ModelsServerServer is the server API for ModelsServer service.
// All implementations must embed UnimplementedModelsServerServer
// for forward compatibility
type ModelsServerServer interface {
	DeleteModel(context.Context, *DeleteModelRequest) (*empty.Empty, error)
	GetModel(context.Context, *GetModelRequest) (*Model, error)
	ListModels(context.Context, *ListModelsRequest) (*ListModelsResponse, error)
	PatchModel(context.Context, *PatchModelRequest) (*Model, error)
	mustEmbedUnimplementedModelsServerServer()
}

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

func (UnimplementedModelsServerServer) DeleteModel(context.Context, *DeleteModelRequest) (*empty.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteModel not implemented")
}
func (UnimplementedModelsServerServer) GetModel(context.Context, *GetModelRequest) (*Model, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetModel not implemented")
}
func (UnimplementedModelsServerServer) ListModels(context.Context, *ListModelsRequest) (*ListModelsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListModels not implemented")
}
func (UnimplementedModelsServerServer) PatchModel(context.Context, *PatchModelRequest) (*Model, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PatchModel not implemented")
}
func (UnimplementedModelsServerServer) mustEmbedUnimplementedModelsServerServer() {}

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

func RegisterModelsServerServer(s grpc.ServiceRegistrar, srv ModelsServerServer) {
	s.RegisterService(&ModelsServer_ServiceDesc, srv)
}

func _ModelsServer_DeleteModel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteModelRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ModelsServerServer).DeleteModel(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/google.cloud.bigquery.v2.ModelsServer/DeleteModel",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ModelsServerServer).DeleteModel(ctx, req.(*DeleteModelRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ModelsServer_GetModel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetModelRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ModelsServerServer).GetModel(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/google.cloud.bigquery.v2.ModelsServer/GetModel",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ModelsServerServer).GetModel(ctx, req.(*GetModelRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ModelsServer_ListModels_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListModelsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ModelsServerServer).ListModels(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/google.cloud.bigquery.v2.ModelsServer/ListModels",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ModelsServerServer).ListModels(ctx, req.(*ListModelsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ModelsServer_PatchModel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PatchModelRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ModelsServerServer).PatchModel(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/google.cloud.bigquery.v2.ModelsServer/PatchModel",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ModelsServerServer).PatchModel(ctx, req.(*PatchModelRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// ModelsServer_ServiceDesc is the grpc.ServiceDesc for ModelsServer service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var ModelsServer_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "google.cloud.bigquery.v2.ModelsServer",
	HandlerType: (*ModelsServerServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "DeleteModel",
			Handler:    _ModelsServer_DeleteModel_Handler,
		},
		{
			MethodName: "GetModel",
			Handler:    _ModelsServer_GetModel_Handler,
		},
		{
			MethodName: "ListModels",
			Handler:    _ModelsServer_ListModels_Handler,
		},
		{
			MethodName: "PatchModel",
			Handler:    _ModelsServer_PatchModel_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "mockgcp/cloud/bigquery/v2/api.proto",
}

// ProjectsServerClient is the client API for ProjectsServer service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type ProjectsServerClient interface {
	GetServiceAccountProject(ctx context.Context, in *GetServiceAccountProjectRequest, opts ...grpc.CallOption) (*GetServiceAccountResponse, error)
	ListProjects(ctx context.Context, in *ListProjectsRequest, opts ...grpc.CallOption) (*ProjectList, error)
}

type projectsServerClient struct {
	cc grpc.ClientConnInterface
}

func NewProjectsServerClient(cc grpc.ClientConnInterface) ProjectsServerClient {
	return &projectsServerClient{cc}
}

func (c *projectsServerClient) GetServiceAccountProject(ctx context.Context, in *GetServiceAccountProjectRequest, opts ...grpc.CallOption) (*GetServiceAccountResponse, error) {
	out := new(GetServiceAccountResponse)
	err := c.cc.Invoke(ctx, "/google.cloud.bigquery.v2.ProjectsServer/GetServiceAccountProject", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *projectsServerClient) ListProjects(ctx context.Context, in *ListProjectsRequest, opts ...grpc.CallOption) (*ProjectList, error) {
	out := new(ProjectList)
	err := c.cc.Invoke(ctx, "/google.cloud.bigquery.v2.ProjectsServer/ListProjects", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ProjectsServerServer is the server API for ProjectsServer service.
// All implementations must embed UnimplementedProjectsServerServer
// for forward compatibility
type ProjectsServerServer interface {
	GetServiceAccountProject(context.Context, *GetServiceAccountProjectRequest) (*GetServiceAccountResponse, error)
	ListProjects(context.Context, *ListProjectsRequest) (*ProjectList, error)
	mustEmbedUnimplementedProjectsServerServer()
}

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

func (UnimplementedProjectsServerServer) GetServiceAccountProject(context.Context, *GetServiceAccountProjectRequest) (*GetServiceAccountResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetServiceAccountProject not implemented")
}
func (UnimplementedProjectsServerServer) ListProjects(context.Context, *ListProjectsRequest) (*ProjectList, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListProjects not implemented")
}
func (UnimplementedProjectsServerServer) mustEmbedUnimplementedProjectsServerServer() {}

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

func RegisterProjectsServerServer(s grpc.ServiceRegistrar, srv ProjectsServerServer) {
	s.RegisterService(&ProjectsServer_ServiceDesc, srv)
}

func _ProjectsServer_GetServiceAccountProject_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetServiceAccountProjectRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProjectsServerServer).GetServiceAccountProject(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/google.cloud.bigquery.v2.ProjectsServer/GetServiceAccountProject",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProjectsServerServer).GetServiceAccountProject(ctx, req.(*GetServiceAccountProjectRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ProjectsServer_ListProjects_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListProjectsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProjectsServerServer).ListProjects(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/google.cloud.bigquery.v2.ProjectsServer/ListProjects",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProjectsServerServer).ListProjects(ctx, req.(*ListProjectsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// ProjectsServer_ServiceDesc is the grpc.ServiceDesc for ProjectsServer service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var ProjectsServer_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "google.cloud.bigquery.v2.ProjectsServer",
	HandlerType: (*ProjectsServerServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetServiceAccountProject",
			Handler:    _ProjectsServer_GetServiceAccountProject_Handler,
		},
		{
			MethodName: "ListProjects",
			Handler:    _ProjectsServer_ListProjects_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "mockgcp/cloud/bigquery/v2/api.proto",
}

// RoutinesServerClient is the client API for RoutinesServer service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type RoutinesServerClient interface {
	DeleteRoutine(ctx context.Context, in *DeleteRoutineRequest, opts ...grpc.CallOption) (*empty.Empty, error)
	GetRoutine(ctx context.Context, in *GetRoutineRequest, opts ...grpc.CallOption) (*Routine, error)
	InsertRoutine(ctx context.Context, in *InsertRoutineRequest, opts ...grpc.CallOption) (*Routine, error)
	ListRoutines(ctx context.Context, in *ListRoutinesRequest, opts ...grpc.CallOption) (*ListRoutinesResponse, error)
	UpdateRoutine(ctx context.Context, in *UpdateRoutineRequest, opts ...grpc.CallOption) (*Routine, error)
}

type routinesServerClient struct {
	cc grpc.ClientConnInterface
}

func NewRoutinesServerClient(cc grpc.ClientConnInterface) RoutinesServerClient {
	return &routinesServerClient{cc}
}

func (c *routinesServerClient) DeleteRoutine(ctx context.Context, in *DeleteRoutineRequest, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/google.cloud.bigquery.v2.RoutinesServer/DeleteRoutine", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *routinesServerClient) GetRoutine(ctx context.Context, in *GetRoutineRequest, opts ...grpc.CallOption) (*Routine, error) {
	out := new(Routine)
	err := c.cc.Invoke(ctx, "/google.cloud.bigquery.v2.RoutinesServer/GetRoutine", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *routinesServerClient) InsertRoutine(ctx context.Context, in *InsertRoutineRequest, opts ...grpc.CallOption) (*Routine, error) {
	out := new(Routine)
	err := c.cc.Invoke(ctx, "/google.cloud.bigquery.v2.RoutinesServer/InsertRoutine", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *routinesServerClient) ListRoutines(ctx context.Context, in *ListRoutinesRequest, opts ...grpc.CallOption) (*ListRoutinesResponse, error) {
	out := new(ListRoutinesResponse)
	err := c.cc.Invoke(ctx, "/google.cloud.bigquery.v2.RoutinesServer/ListRoutines", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *routinesServerClient) UpdateRoutine(ctx context.Context, in *UpdateRoutineRequest, opts ...grpc.CallOption) (*Routine, error) {
	out := new(Routine)
	err := c.cc.Invoke(ctx, "/google.cloud.bigquery.v2.RoutinesServer/UpdateRoutine", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// RoutinesServerServer is the server API for RoutinesServer service.
// All implementations must embed UnimplementedRoutinesServerServer
// for forward compatibility
type RoutinesServerServer interface {
	DeleteRoutine(context.Context, *DeleteRoutineRequest) (*empty.Empty, error)
	GetRoutine(context.Context, *GetRoutineRequest) (*Routine, error)
	InsertRoutine(context.Context, *InsertRoutineRequest) (*Routine, error)
	ListRoutines(context.Context, *ListRoutinesRequest) (*ListRoutinesResponse, error)
	UpdateRoutine(context.Context, *UpdateRoutineRequest) (*Routine, error)
	mustEmbedUnimplementedRoutinesServerServer()
}

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

func (UnimplementedRoutinesServerServer) DeleteRoutine(context.Context, *DeleteRoutineRequest) (*empty.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteRoutine not implemented")
}
func (UnimplementedRoutinesServerServer) GetRoutine(context.Context, *GetRoutineRequest) (*Routine, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetRoutine not implemented")
}
func (UnimplementedRoutinesServerServer) InsertRoutine(context.Context, *InsertRoutineRequest) (*Routine, error) {
	return nil, status.Errorf(codes.Unimplemented, "method InsertRoutine not implemented")
}
func (UnimplementedRoutinesServerServer) ListRoutines(context.Context, *ListRoutinesRequest) (*ListRoutinesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListRoutines not implemented")
}
func (UnimplementedRoutinesServerServer) UpdateRoutine(context.Context, *UpdateRoutineRequest) (*Routine, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateRoutine not implemented")
}
func (UnimplementedRoutinesServerServer) mustEmbedUnimplementedRoutinesServerServer() {}

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

func RegisterRoutinesServerServer(s grpc.ServiceRegistrar, srv RoutinesServerServer) {
	s.RegisterService(&RoutinesServer_ServiceDesc, srv)
}

func _RoutinesServer_DeleteRoutine_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteRoutineRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RoutinesServerServer).DeleteRoutine(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/google.cloud.bigquery.v2.RoutinesServer/DeleteRoutine",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RoutinesServerServer).DeleteRoutine(ctx, req.(*DeleteRoutineRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RoutinesServer_GetRoutine_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetRoutineRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RoutinesServerServer).GetRoutine(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/google.cloud.bigquery.v2.RoutinesServer/GetRoutine",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RoutinesServerServer).GetRoutine(ctx, req.(*GetRoutineRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RoutinesServer_InsertRoutine_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InsertRoutineRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RoutinesServerServer).InsertRoutine(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/google.cloud.bigquery.v2.RoutinesServer/InsertRoutine",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RoutinesServerServer).InsertRoutine(ctx, req.(*InsertRoutineRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RoutinesServer_ListRoutines_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListRoutinesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RoutinesServerServer).ListRoutines(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/google.cloud.bigquery.v2.RoutinesServer/ListRoutines",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RoutinesServerServer).ListRoutines(ctx, req.(*ListRoutinesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RoutinesServer_UpdateRoutine_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateRoutineRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RoutinesServerServer).UpdateRoutine(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/google.cloud.bigquery.v2.RoutinesServer/UpdateRoutine",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RoutinesServerServer).UpdateRoutine(ctx, req.(*UpdateRoutineRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// RoutinesServer_ServiceDesc is the grpc.ServiceDesc for RoutinesServer service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var RoutinesServer_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "google.cloud.bigquery.v2.RoutinesServer",
	HandlerType: (*RoutinesServerServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "DeleteRoutine",
			Handler:    _RoutinesServer_DeleteRoutine_Handler,
		},
		{
			MethodName: "GetRoutine",
			Handler:    _RoutinesServer_GetRoutine_Handler,
		},
		{
			MethodName: "InsertRoutine",
			Handler:    _RoutinesServer_InsertRoutine_Handler,
		},
		{
			MethodName: "ListRoutines",
			Handler:    _RoutinesServer_ListRoutines_Handler,
		},
		{
			MethodName: "UpdateRoutine",
			Handler:    _RoutinesServer_UpdateRoutine_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "mockgcp/cloud/bigquery/v2/api.proto",
}

// RowAccessPoliciesServerClient is the client API for RowAccessPoliciesServer service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type RowAccessPoliciesServerClient interface {
	ListRowAccessPolicies(ctx context.Context, in *ListRowAccessPoliciesRequest, opts ...grpc.CallOption) (*ListRowAccessPoliciesResponse, error)
}

type rowAccessPoliciesServerClient struct {
	cc grpc.ClientConnInterface
}

func NewRowAccessPoliciesServerClient(cc grpc.ClientConnInterface) RowAccessPoliciesServerClient {
	return &rowAccessPoliciesServerClient{cc}
}

func (c *rowAccessPoliciesServerClient) ListRowAccessPolicies(ctx context.Context, in *ListRowAccessPoliciesRequest, opts ...grpc.CallOption) (*ListRowAccessPoliciesResponse, error) {
	out := new(ListRowAccessPoliciesResponse)
	err := c.cc.Invoke(ctx, "/google.cloud.bigquery.v2.RowAccessPoliciesServer/ListRowAccessPolicies", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// RowAccessPoliciesServerServer is the server API for RowAccessPoliciesServer service.
// All implementations must embed UnimplementedRowAccessPoliciesServerServer
// for forward compatibility
type RowAccessPoliciesServerServer interface {
	ListRowAccessPolicies(context.Context, *ListRowAccessPoliciesRequest) (*ListRowAccessPoliciesResponse, error)
	mustEmbedUnimplementedRowAccessPoliciesServerServer()
}

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

func (UnimplementedRowAccessPoliciesServerServer) ListRowAccessPolicies(context.Context, *ListRowAccessPoliciesRequest) (*ListRowAccessPoliciesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListRowAccessPolicies not implemented")
}
func (UnimplementedRowAccessPoliciesServerServer) mustEmbedUnimplementedRowAccessPoliciesServerServer() {
}

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

func RegisterRowAccessPoliciesServerServer(s grpc.ServiceRegistrar, srv RowAccessPoliciesServerServer) {
	s.RegisterService(&RowAccessPoliciesServer_ServiceDesc, srv)
}

func _RowAccessPoliciesServer_ListRowAccessPolicies_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListRowAccessPoliciesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RowAccessPoliciesServerServer).ListRowAccessPolicies(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/google.cloud.bigquery.v2.RowAccessPoliciesServer/ListRowAccessPolicies",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RowAccessPoliciesServerServer).ListRowAccessPolicies(ctx, req.(*ListRowAccessPoliciesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// RowAccessPoliciesServer_ServiceDesc is the grpc.ServiceDesc for RowAccessPoliciesServer service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var RowAccessPoliciesServer_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "google.cloud.bigquery.v2.RowAccessPoliciesServer",
	HandlerType: (*RowAccessPoliciesServerServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ListRowAccessPolicies",
			Handler:    _RowAccessPoliciesServer_ListRowAccessPolicies_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "mockgcp/cloud/bigquery/v2/api.proto",
}

// TabledataServerClient is the client API for TabledataServer service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type TabledataServerClient interface {
	InsertAllTabledata(ctx context.Context, in *InsertAllTabledataRequest, opts ...grpc.CallOption) (*TableDataInsertAllResponse, error)
	ListTabledata(ctx context.Context, in *ListTabledataRequest, opts ...grpc.CallOption) (*TableDataList, error)
}

type tabledataServerClient struct {
	cc grpc.ClientConnInterface
}

func NewTabledataServerClient(cc grpc.ClientConnInterface) TabledataServerClient {
	return &tabledataServerClient{cc}
}

func (c *tabledataServerClient) InsertAllTabledata(ctx context.Context, in *InsertAllTabledataRequest, opts ...grpc.CallOption) (*TableDataInsertAllResponse, error) {
	out := new(TableDataInsertAllResponse)
	err := c.cc.Invoke(ctx, "/google.cloud.bigquery.v2.TabledataServer/InsertAllTabledata", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tabledataServerClient) ListTabledata(ctx context.Context, in *ListTabledataRequest, opts ...grpc.CallOption) (*TableDataList, error) {
	out := new(TableDataList)
	err := c.cc.Invoke(ctx, "/google.cloud.bigquery.v2.TabledataServer/ListTabledata", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// TabledataServerServer is the server API for TabledataServer service.
// All implementations must embed UnimplementedTabledataServerServer
// for forward compatibility
type TabledataServerServer interface {
	InsertAllTabledata(context.Context, *InsertAllTabledataRequest) (*TableDataInsertAllResponse, error)
	ListTabledata(context.Context, *ListTabledataRequest) (*TableDataList, error)
	mustEmbedUnimplementedTabledataServerServer()
}

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

func (UnimplementedTabledataServerServer) InsertAllTabledata(context.Context, *InsertAllTabledataRequest) (*TableDataInsertAllResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method InsertAllTabledata not implemented")
}
func (UnimplementedTabledataServerServer) ListTabledata(context.Context, *ListTabledataRequest) (*TableDataList, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListTabledata not implemented")
}
func (UnimplementedTabledataServerServer) mustEmbedUnimplementedTabledataServerServer() {}

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

func RegisterTabledataServerServer(s grpc.ServiceRegistrar, srv TabledataServerServer) {
	s.RegisterService(&TabledataServer_ServiceDesc, srv)
}

func _TabledataServer_InsertAllTabledata_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InsertAllTabledataRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TabledataServerServer).InsertAllTabledata(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/google.cloud.bigquery.v2.TabledataServer/InsertAllTabledata",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TabledataServerServer).InsertAllTabledata(ctx, req.(*InsertAllTabledataRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TabledataServer_ListTabledata_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListTabledataRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TabledataServerServer).ListTabledata(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/google.cloud.bigquery.v2.TabledataServer/ListTabledata",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TabledataServerServer).ListTabledata(ctx, req.(*ListTabledataRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// TabledataServer_ServiceDesc is the grpc.ServiceDesc for TabledataServer service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var TabledataServer_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "google.cloud.bigquery.v2.TabledataServer",
	HandlerType: (*TabledataServerServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "InsertAllTabledata",
			Handler:    _TabledataServer_InsertAllTabledata_Handler,
		},
		{
			MethodName: "ListTabledata",
			Handler:    _TabledataServer_ListTabledata_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "mockgcp/cloud/bigquery/v2/api.proto",
}

// TablesServerClient is the client API for TablesServer service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type TablesServerClient interface {
	DeleteTable(ctx context.Context, in *DeleteTableRequest, opts ...grpc.CallOption) (*empty.Empty, error)
	GetTable(ctx context.Context, in *GetTableRequest, opts ...grpc.CallOption) (*Table, error)
	InsertTable(ctx context.Context, in *InsertTableRequest, opts ...grpc.CallOption) (*Table, error)
	ListTables(ctx context.Context, in *ListTablesRequest, opts ...grpc.CallOption) (*TableList, error)
	PatchTable(ctx context.Context, in *PatchTableRequest, opts ...grpc.CallOption) (*Table, error)
	UpdateTable(ctx context.Context, in *UpdateTableRequest, opts ...grpc.CallOption) (*Table, error)
}

type tablesServerClient struct {
	cc grpc.ClientConnInterface
}

func NewTablesServerClient(cc grpc.ClientConnInterface) TablesServerClient {
	return &tablesServerClient{cc}
}

func (c *tablesServerClient) DeleteTable(ctx context.Context, in *DeleteTableRequest, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/google.cloud.bigquery.v2.TablesServer/DeleteTable", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tablesServerClient) GetTable(ctx context.Context, in *GetTableRequest, opts ...grpc.CallOption) (*Table, error) {
	out := new(Table)
	err := c.cc.Invoke(ctx, "/google.cloud.bigquery.v2.TablesServer/GetTable", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tablesServerClient) InsertTable(ctx context.Context, in *InsertTableRequest, opts ...grpc.CallOption) (*Table, error) {
	out := new(Table)
	err := c.cc.Invoke(ctx, "/google.cloud.bigquery.v2.TablesServer/InsertTable", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tablesServerClient) ListTables(ctx context.Context, in *ListTablesRequest, opts ...grpc.CallOption) (*TableList, error) {
	out := new(TableList)
	err := c.cc.Invoke(ctx, "/google.cloud.bigquery.v2.TablesServer/ListTables", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tablesServerClient) PatchTable(ctx context.Context, in *PatchTableRequest, opts ...grpc.CallOption) (*Table, error) {
	out := new(Table)
	err := c.cc.Invoke(ctx, "/google.cloud.bigquery.v2.TablesServer/PatchTable", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tablesServerClient) UpdateTable(ctx context.Context, in *UpdateTableRequest, opts ...grpc.CallOption) (*Table, error) {
	out := new(Table)
	err := c.cc.Invoke(ctx, "/google.cloud.bigquery.v2.TablesServer/UpdateTable", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// TablesServerServer is the server API for TablesServer service.
// All implementations must embed UnimplementedTablesServerServer
// for forward compatibility
type TablesServerServer interface {
	DeleteTable(context.Context, *DeleteTableRequest) (*empty.Empty, error)
	GetTable(context.Context, *GetTableRequest) (*Table, error)
	InsertTable(context.Context, *InsertTableRequest) (*Table, error)
	ListTables(context.Context, *ListTablesRequest) (*TableList, error)
	PatchTable(context.Context, *PatchTableRequest) (*Table, error)
	UpdateTable(context.Context, *UpdateTableRequest) (*Table, error)
	mustEmbedUnimplementedTablesServerServer()
}

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

func (UnimplementedTablesServerServer) DeleteTable(context.Context, *DeleteTableRequest) (*empty.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteTable not implemented")
}
func (UnimplementedTablesServerServer) GetTable(context.Context, *GetTableRequest) (*Table, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetTable not implemented")
}
func (UnimplementedTablesServerServer) InsertTable(context.Context, *InsertTableRequest) (*Table, error) {
	return nil, status.Errorf(codes.Unimplemented, "method InsertTable not implemented")
}
func (UnimplementedTablesServerServer) ListTables(context.Context, *ListTablesRequest) (*TableList, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListTables not implemented")
}
func (UnimplementedTablesServerServer) PatchTable(context.Context, *PatchTableRequest) (*Table, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PatchTable not implemented")
}
func (UnimplementedTablesServerServer) UpdateTable(context.Context, *UpdateTableRequest) (*Table, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateTable not implemented")
}
func (UnimplementedTablesServerServer) mustEmbedUnimplementedTablesServerServer() {}

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

func RegisterTablesServerServer(s grpc.ServiceRegistrar, srv TablesServerServer) {
	s.RegisterService(&TablesServer_ServiceDesc, srv)
}

func _TablesServer_DeleteTable_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteTableRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TablesServerServer).DeleteTable(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/google.cloud.bigquery.v2.TablesServer/DeleteTable",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TablesServerServer).DeleteTable(ctx, req.(*DeleteTableRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TablesServer_GetTable_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetTableRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TablesServerServer).GetTable(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/google.cloud.bigquery.v2.TablesServer/GetTable",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TablesServerServer).GetTable(ctx, req.(*GetTableRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TablesServer_InsertTable_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InsertTableRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TablesServerServer).InsertTable(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/google.cloud.bigquery.v2.TablesServer/InsertTable",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TablesServerServer).InsertTable(ctx, req.(*InsertTableRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TablesServer_ListTables_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListTablesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TablesServerServer).ListTables(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/google.cloud.bigquery.v2.TablesServer/ListTables",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TablesServerServer).ListTables(ctx, req.(*ListTablesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TablesServer_PatchTable_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PatchTableRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TablesServerServer).PatchTable(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/google.cloud.bigquery.v2.TablesServer/PatchTable",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TablesServerServer).PatchTable(ctx, req.(*PatchTableRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TablesServer_UpdateTable_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateTableRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TablesServerServer).UpdateTable(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/google.cloud.bigquery.v2.TablesServer/UpdateTable",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TablesServerServer).UpdateTable(ctx, req.(*UpdateTableRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// TablesServer_ServiceDesc is the grpc.ServiceDesc for TablesServer service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var TablesServer_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "google.cloud.bigquery.v2.TablesServer",
	HandlerType: (*TablesServerServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "DeleteTable",
			Handler:    _TablesServer_DeleteTable_Handler,
		},
		{
			MethodName: "GetTable",
			Handler:    _TablesServer_GetTable_Handler,
		},
		{
			MethodName: "InsertTable",
			Handler:    _TablesServer_InsertTable_Handler,
		},
		{
			MethodName: "ListTables",
			Handler:    _TablesServer_ListTables_Handler,
		},
		{
			MethodName: "PatchTable",
			Handler:    _TablesServer_PatchTable_Handler,
		},
		{
			MethodName: "UpdateTable",
			Handler:    _TablesServer_UpdateTable_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "mockgcp/cloud/bigquery/v2/api.proto",
}