// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.3.0
// - protoc             (unknown)
// source: dataflow/dataflow.proto

package dataflow

import (
	context "context"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
)

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

const (
	ConnProfileService_CreateConnProfile_FullMethodName            = "/dataflow.ConnProfileService/CreateConnProfile"
	ConnProfileService_GetIPWhiteList_FullMethodName               = "/dataflow.ConnProfileService/GetIPWhiteList"
	ConnProfileService_CreatePrivateLinkEndpoint_FullMethodName    = "/dataflow.ConnProfileService/CreatePrivateLinkEndpoint"
	ConnProfileService_GetPrivateLinkEndpoint_FullMethodName       = "/dataflow.ConnProfileService/GetPrivateLinkEndpoint"
	ConnProfileService_ValidateRemoteDBConnectivity_FullMethodName = "/dataflow.ConnProfileService/ValidateRemoteDBConnectivity"
	ConnProfileService_ValidateClusterConnectivity_FullMethodName  = "/dataflow.ConnProfileService/ValidateClusterConnectivity"
)

// ConnProfileServiceClient is the client API for ConnProfileService 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 ConnProfileServiceClient interface {
	CreateConnProfile(ctx context.Context, in *CreateConnProfileReq, opts ...grpc.CallOption) (*CreateConnProfileResp, error)
	GetIPWhiteList(ctx context.Context, in *GetIPWhiteListReq, opts ...grpc.CallOption) (*GetIPWhiteListResp, error)
	CreatePrivateLinkEndpoint(ctx context.Context, in *CreatePrivateLinkEndpointReq, opts ...grpc.CallOption) (*CreatePrivateLinkEndpointResp, error)
	GetPrivateLinkEndpoint(ctx context.Context, in *GetPrivateLinkEndpointReq, opts ...grpc.CallOption) (*GetPrivateLinkEndpointResp, error)
	// we're using 2 api to validate remote(dm source) and cluster connectivity
	// it's ok to merge into one to expose less apis, but their params and needed privileges is quite different.
	ValidateRemoteDBConnectivity(ctx context.Context, in *ValidateRemoteDBConnectivityReq, opts ...grpc.CallOption) (*ValidateRemoteDBConnectivityResp, error)
	ValidateClusterConnectivity(ctx context.Context, in *ValidateClusterConnectivityReq, opts ...grpc.CallOption) (*emptypb.Empty, error)
}

type connProfileServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewConnProfileServiceClient(cc grpc.ClientConnInterface) ConnProfileServiceClient {
	return &connProfileServiceClient{cc}
}

func (c *connProfileServiceClient) CreateConnProfile(ctx context.Context, in *CreateConnProfileReq, opts ...grpc.CallOption) (*CreateConnProfileResp, error) {
	out := new(CreateConnProfileResp)
	err := c.cc.Invoke(ctx, ConnProfileService_CreateConnProfile_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *connProfileServiceClient) GetIPWhiteList(ctx context.Context, in *GetIPWhiteListReq, opts ...grpc.CallOption) (*GetIPWhiteListResp, error) {
	out := new(GetIPWhiteListResp)
	err := c.cc.Invoke(ctx, ConnProfileService_GetIPWhiteList_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *connProfileServiceClient) CreatePrivateLinkEndpoint(ctx context.Context, in *CreatePrivateLinkEndpointReq, opts ...grpc.CallOption) (*CreatePrivateLinkEndpointResp, error) {
	out := new(CreatePrivateLinkEndpointResp)
	err := c.cc.Invoke(ctx, ConnProfileService_CreatePrivateLinkEndpoint_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *connProfileServiceClient) GetPrivateLinkEndpoint(ctx context.Context, in *GetPrivateLinkEndpointReq, opts ...grpc.CallOption) (*GetPrivateLinkEndpointResp, error) {
	out := new(GetPrivateLinkEndpointResp)
	err := c.cc.Invoke(ctx, ConnProfileService_GetPrivateLinkEndpoint_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *connProfileServiceClient) ValidateRemoteDBConnectivity(ctx context.Context, in *ValidateRemoteDBConnectivityReq, opts ...grpc.CallOption) (*ValidateRemoteDBConnectivityResp, error) {
	out := new(ValidateRemoteDBConnectivityResp)
	err := c.cc.Invoke(ctx, ConnProfileService_ValidateRemoteDBConnectivity_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *connProfileServiceClient) ValidateClusterConnectivity(ctx context.Context, in *ValidateClusterConnectivityReq, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, ConnProfileService_ValidateClusterConnectivity_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ConnProfileServiceServer is the server API for ConnProfileService service.
// All implementations must embed UnimplementedConnProfileServiceServer
// for forward compatibility
type ConnProfileServiceServer interface {
	CreateConnProfile(context.Context, *CreateConnProfileReq) (*CreateConnProfileResp, error)
	GetIPWhiteList(context.Context, *GetIPWhiteListReq) (*GetIPWhiteListResp, error)
	CreatePrivateLinkEndpoint(context.Context, *CreatePrivateLinkEndpointReq) (*CreatePrivateLinkEndpointResp, error)
	GetPrivateLinkEndpoint(context.Context, *GetPrivateLinkEndpointReq) (*GetPrivateLinkEndpointResp, error)
	// we're using 2 api to validate remote(dm source) and cluster connectivity
	// it's ok to merge into one to expose less apis, but their params and needed privileges is quite different.
	ValidateRemoteDBConnectivity(context.Context, *ValidateRemoteDBConnectivityReq) (*ValidateRemoteDBConnectivityResp, error)
	ValidateClusterConnectivity(context.Context, *ValidateClusterConnectivityReq) (*emptypb.Empty, error)
	mustEmbedUnimplementedConnProfileServiceServer()
}

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

func (UnimplementedConnProfileServiceServer) CreateConnProfile(context.Context, *CreateConnProfileReq) (*CreateConnProfileResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateConnProfile not implemented")
}
func (UnimplementedConnProfileServiceServer) GetIPWhiteList(context.Context, *GetIPWhiteListReq) (*GetIPWhiteListResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetIPWhiteList not implemented")
}
func (UnimplementedConnProfileServiceServer) CreatePrivateLinkEndpoint(context.Context, *CreatePrivateLinkEndpointReq) (*CreatePrivateLinkEndpointResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreatePrivateLinkEndpoint not implemented")
}
func (UnimplementedConnProfileServiceServer) GetPrivateLinkEndpoint(context.Context, *GetPrivateLinkEndpointReq) (*GetPrivateLinkEndpointResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetPrivateLinkEndpoint not implemented")
}
func (UnimplementedConnProfileServiceServer) ValidateRemoteDBConnectivity(context.Context, *ValidateRemoteDBConnectivityReq) (*ValidateRemoteDBConnectivityResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ValidateRemoteDBConnectivity not implemented")
}
func (UnimplementedConnProfileServiceServer) ValidateClusterConnectivity(context.Context, *ValidateClusterConnectivityReq) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ValidateClusterConnectivity not implemented")
}
func (UnimplementedConnProfileServiceServer) mustEmbedUnimplementedConnProfileServiceServer() {}

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

func RegisterConnProfileServiceServer(s grpc.ServiceRegistrar, srv ConnProfileServiceServer) {
	s.RegisterService(&ConnProfileService_ServiceDesc, srv)
}

func _ConnProfileService_CreateConnProfile_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateConnProfileReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConnProfileServiceServer).CreateConnProfile(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ConnProfileService_CreateConnProfile_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConnProfileServiceServer).CreateConnProfile(ctx, req.(*CreateConnProfileReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ConnProfileService_GetIPWhiteList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetIPWhiteListReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConnProfileServiceServer).GetIPWhiteList(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ConnProfileService_GetIPWhiteList_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConnProfileServiceServer).GetIPWhiteList(ctx, req.(*GetIPWhiteListReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ConnProfileService_CreatePrivateLinkEndpoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreatePrivateLinkEndpointReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConnProfileServiceServer).CreatePrivateLinkEndpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ConnProfileService_CreatePrivateLinkEndpoint_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConnProfileServiceServer).CreatePrivateLinkEndpoint(ctx, req.(*CreatePrivateLinkEndpointReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ConnProfileService_GetPrivateLinkEndpoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetPrivateLinkEndpointReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConnProfileServiceServer).GetPrivateLinkEndpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ConnProfileService_GetPrivateLinkEndpoint_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConnProfileServiceServer).GetPrivateLinkEndpoint(ctx, req.(*GetPrivateLinkEndpointReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ConnProfileService_ValidateRemoteDBConnectivity_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ValidateRemoteDBConnectivityReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConnProfileServiceServer).ValidateRemoteDBConnectivity(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ConnProfileService_ValidateRemoteDBConnectivity_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConnProfileServiceServer).ValidateRemoteDBConnectivity(ctx, req.(*ValidateRemoteDBConnectivityReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ConnProfileService_ValidateClusterConnectivity_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ValidateClusterConnectivityReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConnProfileServiceServer).ValidateClusterConnectivity(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ConnProfileService_ValidateClusterConnectivity_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConnProfileServiceServer).ValidateClusterConnectivity(ctx, req.(*ValidateClusterConnectivityReq))
	}
	return interceptor(ctx, in, info, handler)
}

// ConnProfileService_ServiceDesc is the grpc.ServiceDesc for ConnProfileService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var ConnProfileService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "dataflow.ConnProfileService",
	HandlerType: (*ConnProfileServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateConnProfile",
			Handler:    _ConnProfileService_CreateConnProfile_Handler,
		},
		{
			MethodName: "GetIPWhiteList",
			Handler:    _ConnProfileService_GetIPWhiteList_Handler,
		},
		{
			MethodName: "CreatePrivateLinkEndpoint",
			Handler:    _ConnProfileService_CreatePrivateLinkEndpoint_Handler,
		},
		{
			MethodName: "GetPrivateLinkEndpoint",
			Handler:    _ConnProfileService_GetPrivateLinkEndpoint_Handler,
		},
		{
			MethodName: "ValidateRemoteDBConnectivity",
			Handler:    _ConnProfileService_ValidateRemoteDBConnectivity_Handler,
		},
		{
			MethodName: "ValidateClusterConnectivity",
			Handler:    _ConnProfileService_ValidateClusterConnectivity_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "dataflow/dataflow.proto",
}