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

package cm

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 (
	Cluster_GetCluster_FullMethodName                    = "/openapi.Cluster/GetCluster"
	Cluster_ListClustersOfProject_FullMethodName         = "/openapi.Cluster/ListClustersOfProject"
	Cluster_CreateCluster_FullMethodName                 = "/openapi.Cluster/CreateCluster"
	Cluster_UpdateCluster_FullMethodName                 = "/openapi.Cluster/UpdateCluster"
	Cluster_DeleteCluster_FullMethodName                 = "/openapi.Cluster/DeleteCluster"
	Cluster_ListProviderRegions_FullMethodName           = "/openapi.Cluster/ListProviderRegions"
	Cluster_CreateAwsCmek_FullMethodName                 = "/openapi.Cluster/CreateAwsCmek"
	Cluster_ListAwsCmek_FullMethodName                   = "/openapi.Cluster/ListAwsCmek"
	Cluster_CreatePrivateEndpointService_FullMethodName  = "/openapi.Cluster/CreatePrivateEndpointService"
	Cluster_GetPrivateEndpointService_FullMethodName     = "/openapi.Cluster/GetPrivateEndpointService"
	Cluster_ListPrivateEndpointsOfProject_FullMethodName = "/openapi.Cluster/ListPrivateEndpointsOfProject"
	Cluster_CreatePrivateEndpoint_FullMethodName         = "/openapi.Cluster/CreatePrivateEndpoint"
	Cluster_ListPrivateEndpoints_FullMethodName          = "/openapi.Cluster/ListPrivateEndpoints"
	Cluster_DeletePrivateEndpoint_FullMethodName         = "/openapi.Cluster/DeletePrivateEndpoint"
	Cluster_CreateAccesspoint_FullMethodName             = "/openapi.Cluster/CreateAccesspoint"
	Cluster_GetAccesspoint_FullMethodName                = "/openapi.Cluster/GetAccesspoint"
	Cluster_ListAccesspoints_FullMethodName              = "/openapi.Cluster/ListAccesspoints"
	Cluster_UpdateAccesspoint_FullMethodName             = "/openapi.Cluster/UpdateAccesspoint"
	Cluster_DeleteAccesspoint_FullMethodName             = "/openapi.Cluster/DeleteAccesspoint"
	Cluster_CreatePrivateLinkEndpoint_FullMethodName     = "/openapi.Cluster/CreatePrivateLinkEndpoint"
	Cluster_GetPrivateLinkEndpoint_FullMethodName        = "/openapi.Cluster/GetPrivateLinkEndpoint"
	Cluster_ListPrivateLinkEndpoints_FullMethodName      = "/openapi.Cluster/ListPrivateLinkEndpoints"
	Cluster_DeletePrivateLinkEndpoint_FullMethodName     = "/openapi.Cluster/DeletePrivateLinkEndpoint"
)

// ClusterClient is the client API for Cluster 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 ClusterClient interface {
	GetCluster(ctx context.Context, in *GetClusterReq, opts ...grpc.CallOption) (*ClusterItem, error)
	ListClustersOfProject(ctx context.Context, in *ListClustersOfProjectReq, opts ...grpc.CallOption) (*ListClustersOfProjectResp, error)
	CreateCluster(ctx context.Context, in *CreateClusterReq, opts ...grpc.CallOption) (*CreateClusterResp, error)
	UpdateCluster(ctx context.Context, in *UpdateClusterReq, opts ...grpc.CallOption) (*emptypb.Empty, error)
	DeleteCluster(ctx context.Context, in *DeleteClusterReq, opts ...grpc.CallOption) (*emptypb.Empty, error)
	ListProviderRegions(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*ListProviderRegionsResp, error)
	CreateAwsCmek(ctx context.Context, in *CreateAwsCmekReq, opts ...grpc.CallOption) (*emptypb.Empty, error)
	ListAwsCmek(ctx context.Context, in *ListAwsCmekReq, opts ...grpc.CallOption) (*ListAwsCmekResp, error)
	// Private Endpoint Service
	CreatePrivateEndpointService(ctx context.Context, in *CreatePrivateEndpointServiceReq, opts ...grpc.CallOption) (*CreatePrivateEndpointServiceResp, error)
	GetPrivateEndpointService(ctx context.Context, in *GetPrivateEndpointServiceReq, opts ...grpc.CallOption) (*GetPrivateEndpointServiceResp, error)
	// Private Endpoint
	ListPrivateEndpointsOfProject(ctx context.Context, in *ListPrivateEndpointsOfProjectReq, opts ...grpc.CallOption) (*ListPrivateEndpointsOfProjectResp, error)
	CreatePrivateEndpoint(ctx context.Context, in *CreatePrivateEndpointReq, opts ...grpc.CallOption) (*CreatePrivateEndpointResp, error)
	ListPrivateEndpoints(ctx context.Context, in *ListPrivateEndpointsReq, opts ...grpc.CallOption) (*ListPrivateEndpointsResp, error)
	DeletePrivateEndpoint(ctx context.Context, in *DeletePrivateEndpointReq, opts ...grpc.CallOption) (*emptypb.Empty, error)
	CreateAccesspoint(ctx context.Context, in *CreateAccesspointReq, opts ...grpc.CallOption) (*CreateAccesspointResp, error)
	GetAccesspoint(ctx context.Context, in *GetAccesspointReq, opts ...grpc.CallOption) (*Accesspoint, error)
	ListAccesspoints(ctx context.Context, in *ListAccesspointsReq, opts ...grpc.CallOption) (*ListAccesspointsResp, error)
	UpdateAccesspoint(ctx context.Context, in *UpdateAccesspointReq, opts ...grpc.CallOption) (*emptypb.Empty, error)
	DeleteAccesspoint(ctx context.Context, in *DeleteAccesspointReq, opts ...grpc.CallOption) (*emptypb.Empty, error)
	CreatePrivateLinkEndpoint(ctx context.Context, in *CreatePrivateLinkEndpointReq, opts ...grpc.CallOption) (*CreatePrivateLinkEndpointResp, error)
	GetPrivateLinkEndpoint(ctx context.Context, in *GetPrivateLinkEndpointReq, opts ...grpc.CallOption) (*PrivateLinkEndpoint, error)
	ListPrivateLinkEndpoints(ctx context.Context, in *ListPrivateLinkEndpointsReq, opts ...grpc.CallOption) (*ListPrivateLinkEndpointsResp, error)
	DeletePrivateLinkEndpoint(ctx context.Context, in *DeletePrivateLinkEndpointReq, opts ...grpc.CallOption) (*emptypb.Empty, error)
}

type clusterClient struct {
	cc grpc.ClientConnInterface
}

func NewClusterClient(cc grpc.ClientConnInterface) ClusterClient {
	return &clusterClient{cc}
}

func (c *clusterClient) GetCluster(ctx context.Context, in *GetClusterReq, opts ...grpc.CallOption) (*ClusterItem, error) {
	out := new(ClusterItem)
	err := c.cc.Invoke(ctx, Cluster_GetCluster_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterClient) ListClustersOfProject(ctx context.Context, in *ListClustersOfProjectReq, opts ...grpc.CallOption) (*ListClustersOfProjectResp, error) {
	out := new(ListClustersOfProjectResp)
	err := c.cc.Invoke(ctx, Cluster_ListClustersOfProject_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterClient) CreateCluster(ctx context.Context, in *CreateClusterReq, opts ...grpc.CallOption) (*CreateClusterResp, error) {
	out := new(CreateClusterResp)
	err := c.cc.Invoke(ctx, Cluster_CreateCluster_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterClient) UpdateCluster(ctx context.Context, in *UpdateClusterReq, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, Cluster_UpdateCluster_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterClient) DeleteCluster(ctx context.Context, in *DeleteClusterReq, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, Cluster_DeleteCluster_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterClient) ListProviderRegions(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*ListProviderRegionsResp, error) {
	out := new(ListProviderRegionsResp)
	err := c.cc.Invoke(ctx, Cluster_ListProviderRegions_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterClient) CreateAwsCmek(ctx context.Context, in *CreateAwsCmekReq, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, Cluster_CreateAwsCmek_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterClient) ListAwsCmek(ctx context.Context, in *ListAwsCmekReq, opts ...grpc.CallOption) (*ListAwsCmekResp, error) {
	out := new(ListAwsCmekResp)
	err := c.cc.Invoke(ctx, Cluster_ListAwsCmek_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterClient) CreatePrivateEndpointService(ctx context.Context, in *CreatePrivateEndpointServiceReq, opts ...grpc.CallOption) (*CreatePrivateEndpointServiceResp, error) {
	out := new(CreatePrivateEndpointServiceResp)
	err := c.cc.Invoke(ctx, Cluster_CreatePrivateEndpointService_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterClient) GetPrivateEndpointService(ctx context.Context, in *GetPrivateEndpointServiceReq, opts ...grpc.CallOption) (*GetPrivateEndpointServiceResp, error) {
	out := new(GetPrivateEndpointServiceResp)
	err := c.cc.Invoke(ctx, Cluster_GetPrivateEndpointService_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterClient) ListPrivateEndpointsOfProject(ctx context.Context, in *ListPrivateEndpointsOfProjectReq, opts ...grpc.CallOption) (*ListPrivateEndpointsOfProjectResp, error) {
	out := new(ListPrivateEndpointsOfProjectResp)
	err := c.cc.Invoke(ctx, Cluster_ListPrivateEndpointsOfProject_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterClient) CreatePrivateEndpoint(ctx context.Context, in *CreatePrivateEndpointReq, opts ...grpc.CallOption) (*CreatePrivateEndpointResp, error) {
	out := new(CreatePrivateEndpointResp)
	err := c.cc.Invoke(ctx, Cluster_CreatePrivateEndpoint_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterClient) ListPrivateEndpoints(ctx context.Context, in *ListPrivateEndpointsReq, opts ...grpc.CallOption) (*ListPrivateEndpointsResp, error) {
	out := new(ListPrivateEndpointsResp)
	err := c.cc.Invoke(ctx, Cluster_ListPrivateEndpoints_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterClient) DeletePrivateEndpoint(ctx context.Context, in *DeletePrivateEndpointReq, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, Cluster_DeletePrivateEndpoint_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterClient) CreateAccesspoint(ctx context.Context, in *CreateAccesspointReq, opts ...grpc.CallOption) (*CreateAccesspointResp, error) {
	out := new(CreateAccesspointResp)
	err := c.cc.Invoke(ctx, Cluster_CreateAccesspoint_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterClient) GetAccesspoint(ctx context.Context, in *GetAccesspointReq, opts ...grpc.CallOption) (*Accesspoint, error) {
	out := new(Accesspoint)
	err := c.cc.Invoke(ctx, Cluster_GetAccesspoint_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterClient) ListAccesspoints(ctx context.Context, in *ListAccesspointsReq, opts ...grpc.CallOption) (*ListAccesspointsResp, error) {
	out := new(ListAccesspointsResp)
	err := c.cc.Invoke(ctx, Cluster_ListAccesspoints_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterClient) UpdateAccesspoint(ctx context.Context, in *UpdateAccesspointReq, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, Cluster_UpdateAccesspoint_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterClient) DeleteAccesspoint(ctx context.Context, in *DeleteAccesspointReq, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, Cluster_DeleteAccesspoint_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

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

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

func (c *clusterClient) ListPrivateLinkEndpoints(ctx context.Context, in *ListPrivateLinkEndpointsReq, opts ...grpc.CallOption) (*ListPrivateLinkEndpointsResp, error) {
	out := new(ListPrivateLinkEndpointsResp)
	err := c.cc.Invoke(ctx, Cluster_ListPrivateLinkEndpoints_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *clusterClient) DeletePrivateLinkEndpoint(ctx context.Context, in *DeletePrivateLinkEndpointReq, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, Cluster_DeletePrivateLinkEndpoint_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ClusterServer is the server API for Cluster service.
// All implementations must embed UnimplementedClusterServer
// for forward compatibility
type ClusterServer interface {
	GetCluster(context.Context, *GetClusterReq) (*ClusterItem, error)
	ListClustersOfProject(context.Context, *ListClustersOfProjectReq) (*ListClustersOfProjectResp, error)
	CreateCluster(context.Context, *CreateClusterReq) (*CreateClusterResp, error)
	UpdateCluster(context.Context, *UpdateClusterReq) (*emptypb.Empty, error)
	DeleteCluster(context.Context, *DeleteClusterReq) (*emptypb.Empty, error)
	ListProviderRegions(context.Context, *emptypb.Empty) (*ListProviderRegionsResp, error)
	CreateAwsCmek(context.Context, *CreateAwsCmekReq) (*emptypb.Empty, error)
	ListAwsCmek(context.Context, *ListAwsCmekReq) (*ListAwsCmekResp, error)
	// Private Endpoint Service
	CreatePrivateEndpointService(context.Context, *CreatePrivateEndpointServiceReq) (*CreatePrivateEndpointServiceResp, error)
	GetPrivateEndpointService(context.Context, *GetPrivateEndpointServiceReq) (*GetPrivateEndpointServiceResp, error)
	// Private Endpoint
	ListPrivateEndpointsOfProject(context.Context, *ListPrivateEndpointsOfProjectReq) (*ListPrivateEndpointsOfProjectResp, error)
	CreatePrivateEndpoint(context.Context, *CreatePrivateEndpointReq) (*CreatePrivateEndpointResp, error)
	ListPrivateEndpoints(context.Context, *ListPrivateEndpointsReq) (*ListPrivateEndpointsResp, error)
	DeletePrivateEndpoint(context.Context, *DeletePrivateEndpointReq) (*emptypb.Empty, error)
	CreateAccesspoint(context.Context, *CreateAccesspointReq) (*CreateAccesspointResp, error)
	GetAccesspoint(context.Context, *GetAccesspointReq) (*Accesspoint, error)
	ListAccesspoints(context.Context, *ListAccesspointsReq) (*ListAccesspointsResp, error)
	UpdateAccesspoint(context.Context, *UpdateAccesspointReq) (*emptypb.Empty, error)
	DeleteAccesspoint(context.Context, *DeleteAccesspointReq) (*emptypb.Empty, error)
	CreatePrivateLinkEndpoint(context.Context, *CreatePrivateLinkEndpointReq) (*CreatePrivateLinkEndpointResp, error)
	GetPrivateLinkEndpoint(context.Context, *GetPrivateLinkEndpointReq) (*PrivateLinkEndpoint, error)
	ListPrivateLinkEndpoints(context.Context, *ListPrivateLinkEndpointsReq) (*ListPrivateLinkEndpointsResp, error)
	DeletePrivateLinkEndpoint(context.Context, *DeletePrivateLinkEndpointReq) (*emptypb.Empty, error)
	mustEmbedUnimplementedClusterServer()
}

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

func (UnimplementedClusterServer) GetCluster(context.Context, *GetClusterReq) (*ClusterItem, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetCluster not implemented")
}
func (UnimplementedClusterServer) ListClustersOfProject(context.Context, *ListClustersOfProjectReq) (*ListClustersOfProjectResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListClustersOfProject not implemented")
}
func (UnimplementedClusterServer) CreateCluster(context.Context, *CreateClusterReq) (*CreateClusterResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateCluster not implemented")
}
func (UnimplementedClusterServer) UpdateCluster(context.Context, *UpdateClusterReq) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateCluster not implemented")
}
func (UnimplementedClusterServer) DeleteCluster(context.Context, *DeleteClusterReq) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteCluster not implemented")
}
func (UnimplementedClusterServer) ListProviderRegions(context.Context, *emptypb.Empty) (*ListProviderRegionsResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListProviderRegions not implemented")
}
func (UnimplementedClusterServer) CreateAwsCmek(context.Context, *CreateAwsCmekReq) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateAwsCmek not implemented")
}
func (UnimplementedClusterServer) ListAwsCmek(context.Context, *ListAwsCmekReq) (*ListAwsCmekResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListAwsCmek not implemented")
}
func (UnimplementedClusterServer) CreatePrivateEndpointService(context.Context, *CreatePrivateEndpointServiceReq) (*CreatePrivateEndpointServiceResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreatePrivateEndpointService not implemented")
}
func (UnimplementedClusterServer) GetPrivateEndpointService(context.Context, *GetPrivateEndpointServiceReq) (*GetPrivateEndpointServiceResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetPrivateEndpointService not implemented")
}
func (UnimplementedClusterServer) ListPrivateEndpointsOfProject(context.Context, *ListPrivateEndpointsOfProjectReq) (*ListPrivateEndpointsOfProjectResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListPrivateEndpointsOfProject not implemented")
}
func (UnimplementedClusterServer) CreatePrivateEndpoint(context.Context, *CreatePrivateEndpointReq) (*CreatePrivateEndpointResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreatePrivateEndpoint not implemented")
}
func (UnimplementedClusterServer) ListPrivateEndpoints(context.Context, *ListPrivateEndpointsReq) (*ListPrivateEndpointsResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListPrivateEndpoints not implemented")
}
func (UnimplementedClusterServer) DeletePrivateEndpoint(context.Context, *DeletePrivateEndpointReq) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeletePrivateEndpoint not implemented")
}
func (UnimplementedClusterServer) CreateAccesspoint(context.Context, *CreateAccesspointReq) (*CreateAccesspointResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateAccesspoint not implemented")
}
func (UnimplementedClusterServer) GetAccesspoint(context.Context, *GetAccesspointReq) (*Accesspoint, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetAccesspoint not implemented")
}
func (UnimplementedClusterServer) ListAccesspoints(context.Context, *ListAccesspointsReq) (*ListAccesspointsResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListAccesspoints not implemented")
}
func (UnimplementedClusterServer) UpdateAccesspoint(context.Context, *UpdateAccesspointReq) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateAccesspoint not implemented")
}
func (UnimplementedClusterServer) DeleteAccesspoint(context.Context, *DeleteAccesspointReq) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteAccesspoint not implemented")
}
func (UnimplementedClusterServer) CreatePrivateLinkEndpoint(context.Context, *CreatePrivateLinkEndpointReq) (*CreatePrivateLinkEndpointResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreatePrivateLinkEndpoint not implemented")
}
func (UnimplementedClusterServer) GetPrivateLinkEndpoint(context.Context, *GetPrivateLinkEndpointReq) (*PrivateLinkEndpoint, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetPrivateLinkEndpoint not implemented")
}
func (UnimplementedClusterServer) ListPrivateLinkEndpoints(context.Context, *ListPrivateLinkEndpointsReq) (*ListPrivateLinkEndpointsResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListPrivateLinkEndpoints not implemented")
}
func (UnimplementedClusterServer) DeletePrivateLinkEndpoint(context.Context, *DeletePrivateLinkEndpointReq) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeletePrivateLinkEndpoint not implemented")
}
func (UnimplementedClusterServer) mustEmbedUnimplementedClusterServer() {}

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

func RegisterClusterServer(s grpc.ServiceRegistrar, srv ClusterServer) {
	s.RegisterService(&Cluster_ServiceDesc, srv)
}

func _Cluster_GetCluster_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetClusterReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServer).GetCluster(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Cluster_GetCluster_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServer).GetCluster(ctx, req.(*GetClusterReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Cluster_ListClustersOfProject_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListClustersOfProjectReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServer).ListClustersOfProject(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Cluster_ListClustersOfProject_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServer).ListClustersOfProject(ctx, req.(*ListClustersOfProjectReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Cluster_CreateCluster_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateClusterReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServer).CreateCluster(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Cluster_CreateCluster_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServer).CreateCluster(ctx, req.(*CreateClusterReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Cluster_UpdateCluster_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateClusterReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServer).UpdateCluster(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Cluster_UpdateCluster_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServer).UpdateCluster(ctx, req.(*UpdateClusterReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Cluster_DeleteCluster_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteClusterReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServer).DeleteCluster(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Cluster_DeleteCluster_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServer).DeleteCluster(ctx, req.(*DeleteClusterReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Cluster_ListProviderRegions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServer).ListProviderRegions(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Cluster_ListProviderRegions_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServer).ListProviderRegions(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _Cluster_CreateAwsCmek_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateAwsCmekReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServer).CreateAwsCmek(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Cluster_CreateAwsCmek_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServer).CreateAwsCmek(ctx, req.(*CreateAwsCmekReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Cluster_ListAwsCmek_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListAwsCmekReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServer).ListAwsCmek(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Cluster_ListAwsCmek_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServer).ListAwsCmek(ctx, req.(*ListAwsCmekReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Cluster_CreatePrivateEndpointService_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreatePrivateEndpointServiceReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServer).CreatePrivateEndpointService(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Cluster_CreatePrivateEndpointService_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServer).CreatePrivateEndpointService(ctx, req.(*CreatePrivateEndpointServiceReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Cluster_GetPrivateEndpointService_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetPrivateEndpointServiceReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServer).GetPrivateEndpointService(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Cluster_GetPrivateEndpointService_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServer).GetPrivateEndpointService(ctx, req.(*GetPrivateEndpointServiceReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Cluster_ListPrivateEndpointsOfProject_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListPrivateEndpointsOfProjectReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServer).ListPrivateEndpointsOfProject(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Cluster_ListPrivateEndpointsOfProject_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServer).ListPrivateEndpointsOfProject(ctx, req.(*ListPrivateEndpointsOfProjectReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Cluster_CreatePrivateEndpoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreatePrivateEndpointReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServer).CreatePrivateEndpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Cluster_CreatePrivateEndpoint_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServer).CreatePrivateEndpoint(ctx, req.(*CreatePrivateEndpointReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Cluster_ListPrivateEndpoints_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListPrivateEndpointsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServer).ListPrivateEndpoints(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Cluster_ListPrivateEndpoints_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServer).ListPrivateEndpoints(ctx, req.(*ListPrivateEndpointsReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Cluster_DeletePrivateEndpoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeletePrivateEndpointReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServer).DeletePrivateEndpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Cluster_DeletePrivateEndpoint_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServer).DeletePrivateEndpoint(ctx, req.(*DeletePrivateEndpointReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Cluster_CreateAccesspoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateAccesspointReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServer).CreateAccesspoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Cluster_CreateAccesspoint_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServer).CreateAccesspoint(ctx, req.(*CreateAccesspointReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Cluster_GetAccesspoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetAccesspointReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServer).GetAccesspoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Cluster_GetAccesspoint_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServer).GetAccesspoint(ctx, req.(*GetAccesspointReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Cluster_ListAccesspoints_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListAccesspointsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServer).ListAccesspoints(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Cluster_ListAccesspoints_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServer).ListAccesspoints(ctx, req.(*ListAccesspointsReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Cluster_UpdateAccesspoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateAccesspointReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServer).UpdateAccesspoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Cluster_UpdateAccesspoint_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServer).UpdateAccesspoint(ctx, req.(*UpdateAccesspointReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Cluster_DeleteAccesspoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteAccesspointReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServer).DeleteAccesspoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Cluster_DeleteAccesspoint_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServer).DeleteAccesspoint(ctx, req.(*DeleteAccesspointReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Cluster_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.(ClusterServer).CreatePrivateLinkEndpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Cluster_CreatePrivateLinkEndpoint_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServer).CreatePrivateLinkEndpoint(ctx, req.(*CreatePrivateLinkEndpointReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Cluster_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.(ClusterServer).GetPrivateLinkEndpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Cluster_GetPrivateLinkEndpoint_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServer).GetPrivateLinkEndpoint(ctx, req.(*GetPrivateLinkEndpointReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Cluster_ListPrivateLinkEndpoints_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListPrivateLinkEndpointsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServer).ListPrivateLinkEndpoints(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Cluster_ListPrivateLinkEndpoints_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServer).ListPrivateLinkEndpoints(ctx, req.(*ListPrivateLinkEndpointsReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Cluster_DeletePrivateLinkEndpoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeletePrivateLinkEndpointReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterServer).DeletePrivateLinkEndpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Cluster_DeletePrivateLinkEndpoint_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterServer).DeletePrivateLinkEndpoint(ctx, req.(*DeletePrivateLinkEndpointReq))
	}
	return interceptor(ctx, in, info, handler)
}

// Cluster_ServiceDesc is the grpc.ServiceDesc for Cluster service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var Cluster_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "openapi.Cluster",
	HandlerType: (*ClusterServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetCluster",
			Handler:    _Cluster_GetCluster_Handler,
		},
		{
			MethodName: "ListClustersOfProject",
			Handler:    _Cluster_ListClustersOfProject_Handler,
		},
		{
			MethodName: "CreateCluster",
			Handler:    _Cluster_CreateCluster_Handler,
		},
		{
			MethodName: "UpdateCluster",
			Handler:    _Cluster_UpdateCluster_Handler,
		},
		{
			MethodName: "DeleteCluster",
			Handler:    _Cluster_DeleteCluster_Handler,
		},
		{
			MethodName: "ListProviderRegions",
			Handler:    _Cluster_ListProviderRegions_Handler,
		},
		{
			MethodName: "CreateAwsCmek",
			Handler:    _Cluster_CreateAwsCmek_Handler,
		},
		{
			MethodName: "ListAwsCmek",
			Handler:    _Cluster_ListAwsCmek_Handler,
		},
		{
			MethodName: "CreatePrivateEndpointService",
			Handler:    _Cluster_CreatePrivateEndpointService_Handler,
		},
		{
			MethodName: "GetPrivateEndpointService",
			Handler:    _Cluster_GetPrivateEndpointService_Handler,
		},
		{
			MethodName: "ListPrivateEndpointsOfProject",
			Handler:    _Cluster_ListPrivateEndpointsOfProject_Handler,
		},
		{
			MethodName: "CreatePrivateEndpoint",
			Handler:    _Cluster_CreatePrivateEndpoint_Handler,
		},
		{
			MethodName: "ListPrivateEndpoints",
			Handler:    _Cluster_ListPrivateEndpoints_Handler,
		},
		{
			MethodName: "DeletePrivateEndpoint",
			Handler:    _Cluster_DeletePrivateEndpoint_Handler,
		},
		{
			MethodName: "CreateAccesspoint",
			Handler:    _Cluster_CreateAccesspoint_Handler,
		},
		{
			MethodName: "GetAccesspoint",
			Handler:    _Cluster_GetAccesspoint_Handler,
		},
		{
			MethodName: "ListAccesspoints",
			Handler:    _Cluster_ListAccesspoints_Handler,
		},
		{
			MethodName: "UpdateAccesspoint",
			Handler:    _Cluster_UpdateAccesspoint_Handler,
		},
		{
			MethodName: "DeleteAccesspoint",
			Handler:    _Cluster_DeleteAccesspoint_Handler,
		},
		{
			MethodName: "CreatePrivateLinkEndpoint",
			Handler:    _Cluster_CreatePrivateLinkEndpoint_Handler,
		},
		{
			MethodName: "GetPrivateLinkEndpoint",
			Handler:    _Cluster_GetPrivateLinkEndpoint_Handler,
		},
		{
			MethodName: "ListPrivateLinkEndpoints",
			Handler:    _Cluster_ListPrivateLinkEndpoints_Handler,
		},
		{
			MethodName: "DeletePrivateLinkEndpoint",
			Handler:    _Cluster_DeletePrivateLinkEndpoint_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "openapi/cm/cm.proto",
}