// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.4.0
// - protoc             (unknown)
// source: regional/serverless/v1/services.proto

package serverlessv1

import (
	context "context"
	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.62.0 or later.
const _ = grpc.SupportPackageIsVersion8

const (
	ServerlessRegionalService_DescRegion_FullMethodName                  = "/regional.serverless.v1.ServerlessRegionalService/DescRegion"
	ServerlessRegionalService_CreateCluster_FullMethodName               = "/regional.serverless.v1.ServerlessRegionalService/CreateCluster"
	ServerlessRegionalService_GetCluster_FullMethodName                  = "/regional.serverless.v1.ServerlessRegionalService/GetCluster"
	ServerlessRegionalService_ListClusters_FullMethodName                = "/regional.serverless.v1.ServerlessRegionalService/ListClusters"
	ServerlessRegionalService_UpdateCluster_FullMethodName               = "/regional.serverless.v1.ServerlessRegionalService/UpdateCluster"
	ServerlessRegionalService_DeleteCluster_FullMethodName               = "/regional.serverless.v1.ServerlessRegionalService/DeleteCluster"
	ServerlessRegionalService_CheckCloudStoragePermission_FullMethodName = "/regional.serverless.v1.ServerlessRegionalService/CheckCloudStoragePermission"
)

// ServerlessRegionalServiceClient is the client API for ServerlessRegionalService 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 ServerlessRegionalServiceClient interface {
	// Self description
	DescRegion(ctx context.Context, in *ServerlessRegionalServiceDescRegionRequest, opts ...grpc.CallOption) (*ServerlessRegionalServiceDescRegionResponse, error)
	// Clusters CRUD
	CreateCluster(ctx context.Context, in *ServerlessRegionalServiceCreateClusterRequest, opts ...grpc.CallOption) (*ServerlessRegionalServiceCreateClusterResponse, error)
	GetCluster(ctx context.Context, in *ServerlessRegionalServiceGetClusterRequest, opts ...grpc.CallOption) (*ServerlessRegionalServiceGetClusterResponse, error)
	ListClusters(ctx context.Context, in *ServerlessRegionalServiceListClustersRequest, opts ...grpc.CallOption) (*ServerlessRegionalServiceListClustersResponse, error)
	UpdateCluster(ctx context.Context, in *ServerlessRegionalServiceUpdateClusterRequest, opts ...grpc.CallOption) (*ServerlessRegionalServiceUpdateClusterResponse, error)
	DeleteCluster(ctx context.Context, in *ServerlessRegionalServiceDeleteClusterRequest, opts ...grpc.CallOption) (*ServerlessRegionalServiceDeleteClusterResponse, error)
	CheckCloudStoragePermission(ctx context.Context, in *CheckCloudStoragePermissionRequest, opts ...grpc.CallOption) (*CheckCloudStoragePermissionResponse, error)
}

type serverlessRegionalServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewServerlessRegionalServiceClient(cc grpc.ClientConnInterface) ServerlessRegionalServiceClient {
	return &serverlessRegionalServiceClient{cc}
}

func (c *serverlessRegionalServiceClient) DescRegion(ctx context.Context, in *ServerlessRegionalServiceDescRegionRequest, opts ...grpc.CallOption) (*ServerlessRegionalServiceDescRegionResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ServerlessRegionalServiceDescRegionResponse)
	err := c.cc.Invoke(ctx, ServerlessRegionalService_DescRegion_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessRegionalServiceClient) CreateCluster(ctx context.Context, in *ServerlessRegionalServiceCreateClusterRequest, opts ...grpc.CallOption) (*ServerlessRegionalServiceCreateClusterResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ServerlessRegionalServiceCreateClusterResponse)
	err := c.cc.Invoke(ctx, ServerlessRegionalService_CreateCluster_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessRegionalServiceClient) GetCluster(ctx context.Context, in *ServerlessRegionalServiceGetClusterRequest, opts ...grpc.CallOption) (*ServerlessRegionalServiceGetClusterResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ServerlessRegionalServiceGetClusterResponse)
	err := c.cc.Invoke(ctx, ServerlessRegionalService_GetCluster_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessRegionalServiceClient) ListClusters(ctx context.Context, in *ServerlessRegionalServiceListClustersRequest, opts ...grpc.CallOption) (*ServerlessRegionalServiceListClustersResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ServerlessRegionalServiceListClustersResponse)
	err := c.cc.Invoke(ctx, ServerlessRegionalService_ListClusters_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessRegionalServiceClient) UpdateCluster(ctx context.Context, in *ServerlessRegionalServiceUpdateClusterRequest, opts ...grpc.CallOption) (*ServerlessRegionalServiceUpdateClusterResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ServerlessRegionalServiceUpdateClusterResponse)
	err := c.cc.Invoke(ctx, ServerlessRegionalService_UpdateCluster_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessRegionalServiceClient) DeleteCluster(ctx context.Context, in *ServerlessRegionalServiceDeleteClusterRequest, opts ...grpc.CallOption) (*ServerlessRegionalServiceDeleteClusterResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ServerlessRegionalServiceDeleteClusterResponse)
	err := c.cc.Invoke(ctx, ServerlessRegionalService_DeleteCluster_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessRegionalServiceClient) CheckCloudStoragePermission(ctx context.Context, in *CheckCloudStoragePermissionRequest, opts ...grpc.CallOption) (*CheckCloudStoragePermissionResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CheckCloudStoragePermissionResponse)
	err := c.cc.Invoke(ctx, ServerlessRegionalService_CheckCloudStoragePermission_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ServerlessRegionalServiceServer is the server API for ServerlessRegionalService service.
// All implementations should embed UnimplementedServerlessRegionalServiceServer
// for forward compatibility
type ServerlessRegionalServiceServer interface {
	// Self description
	DescRegion(context.Context, *ServerlessRegionalServiceDescRegionRequest) (*ServerlessRegionalServiceDescRegionResponse, error)
	// Clusters CRUD
	CreateCluster(context.Context, *ServerlessRegionalServiceCreateClusterRequest) (*ServerlessRegionalServiceCreateClusterResponse, error)
	GetCluster(context.Context, *ServerlessRegionalServiceGetClusterRequest) (*ServerlessRegionalServiceGetClusterResponse, error)
	ListClusters(context.Context, *ServerlessRegionalServiceListClustersRequest) (*ServerlessRegionalServiceListClustersResponse, error)
	UpdateCluster(context.Context, *ServerlessRegionalServiceUpdateClusterRequest) (*ServerlessRegionalServiceUpdateClusterResponse, error)
	DeleteCluster(context.Context, *ServerlessRegionalServiceDeleteClusterRequest) (*ServerlessRegionalServiceDeleteClusterResponse, error)
	CheckCloudStoragePermission(context.Context, *CheckCloudStoragePermissionRequest) (*CheckCloudStoragePermissionResponse, error)
}

// UnimplementedServerlessRegionalServiceServer should be embedded to have forward compatible implementations.
type UnimplementedServerlessRegionalServiceServer struct {
}

func (UnimplementedServerlessRegionalServiceServer) DescRegion(context.Context, *ServerlessRegionalServiceDescRegionRequest) (*ServerlessRegionalServiceDescRegionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DescRegion not implemented")
}
func (UnimplementedServerlessRegionalServiceServer) CreateCluster(context.Context, *ServerlessRegionalServiceCreateClusterRequest) (*ServerlessRegionalServiceCreateClusterResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateCluster not implemented")
}
func (UnimplementedServerlessRegionalServiceServer) GetCluster(context.Context, *ServerlessRegionalServiceGetClusterRequest) (*ServerlessRegionalServiceGetClusterResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetCluster not implemented")
}
func (UnimplementedServerlessRegionalServiceServer) ListClusters(context.Context, *ServerlessRegionalServiceListClustersRequest) (*ServerlessRegionalServiceListClustersResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListClusters not implemented")
}
func (UnimplementedServerlessRegionalServiceServer) UpdateCluster(context.Context, *ServerlessRegionalServiceUpdateClusterRequest) (*ServerlessRegionalServiceUpdateClusterResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateCluster not implemented")
}
func (UnimplementedServerlessRegionalServiceServer) DeleteCluster(context.Context, *ServerlessRegionalServiceDeleteClusterRequest) (*ServerlessRegionalServiceDeleteClusterResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteCluster not implemented")
}
func (UnimplementedServerlessRegionalServiceServer) CheckCloudStoragePermission(context.Context, *CheckCloudStoragePermissionRequest) (*CheckCloudStoragePermissionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CheckCloudStoragePermission not implemented")
}

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

func RegisterServerlessRegionalServiceServer(s grpc.ServiceRegistrar, srv ServerlessRegionalServiceServer) {
	s.RegisterService(&ServerlessRegionalService_ServiceDesc, srv)
}

func _ServerlessRegionalService_DescRegion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ServerlessRegionalServiceDescRegionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessRegionalServiceServer).DescRegion(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessRegionalService_DescRegion_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessRegionalServiceServer).DescRegion(ctx, req.(*ServerlessRegionalServiceDescRegionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

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

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

func _ServerlessRegionalService_ListClusters_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ServerlessRegionalServiceListClustersRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessRegionalServiceServer).ListClusters(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessRegionalService_ListClusters_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessRegionalServiceServer).ListClusters(ctx, req.(*ServerlessRegionalServiceListClustersRequest))
	}
	return interceptor(ctx, in, info, handler)
}

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

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

func _ServerlessRegionalService_CheckCloudStoragePermission_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CheckCloudStoragePermissionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessRegionalServiceServer).CheckCloudStoragePermission(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessRegionalService_CheckCloudStoragePermission_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessRegionalServiceServer).CheckCloudStoragePermission(ctx, req.(*CheckCloudStoragePermissionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// ServerlessRegionalService_ServiceDesc is the grpc.ServiceDesc for ServerlessRegionalService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var ServerlessRegionalService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "regional.serverless.v1.ServerlessRegionalService",
	HandlerType: (*ServerlessRegionalServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "DescRegion",
			Handler:    _ServerlessRegionalService_DescRegion_Handler,
		},
		{
			MethodName: "CreateCluster",
			Handler:    _ServerlessRegionalService_CreateCluster_Handler,
		},
		{
			MethodName: "GetCluster",
			Handler:    _ServerlessRegionalService_GetCluster_Handler,
		},
		{
			MethodName: "ListClusters",
			Handler:    _ServerlessRegionalService_ListClusters_Handler,
		},
		{
			MethodName: "UpdateCluster",
			Handler:    _ServerlessRegionalService_UpdateCluster_Handler,
		},
		{
			MethodName: "DeleteCluster",
			Handler:    _ServerlessRegionalService_DeleteCluster_Handler,
		},
		{
			MethodName: "CheckCloudStoragePermission",
			Handler:    _ServerlessRegionalService_CheckCloudStoragePermission_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "regional/serverless/v1/services.proto",
}

const (
	ServerlessImportRegionalService_CheckImportPermission_FullMethodName = "/regional.serverless.v1.ServerlessImportRegionalService/CheckImportPermission"
	ServerlessImportRegionalService_Precheck_FullMethodName              = "/regional.serverless.v1.ServerlessImportRegionalService/Precheck"
)

// ServerlessImportRegionalServiceClient is the client API for ServerlessImportRegionalService 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 ServerlessImportRegionalServiceClient interface {
	CheckImportPermission(ctx context.Context, in *CheckImportPermissionRequest, opts ...grpc.CallOption) (*CheckImportPermissionResponse, error)
	Precheck(ctx context.Context, in *PrecheckRequest, opts ...grpc.CallOption) (*PrecheckResponse, error)
}

type serverlessImportRegionalServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewServerlessImportRegionalServiceClient(cc grpc.ClientConnInterface) ServerlessImportRegionalServiceClient {
	return &serverlessImportRegionalServiceClient{cc}
}

func (c *serverlessImportRegionalServiceClient) CheckImportPermission(ctx context.Context, in *CheckImportPermissionRequest, opts ...grpc.CallOption) (*CheckImportPermissionResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CheckImportPermissionResponse)
	err := c.cc.Invoke(ctx, ServerlessImportRegionalService_CheckImportPermission_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessImportRegionalServiceClient) Precheck(ctx context.Context, in *PrecheckRequest, opts ...grpc.CallOption) (*PrecheckResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(PrecheckResponse)
	err := c.cc.Invoke(ctx, ServerlessImportRegionalService_Precheck_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ServerlessImportRegionalServiceServer is the server API for ServerlessImportRegionalService service.
// All implementations should embed UnimplementedServerlessImportRegionalServiceServer
// for forward compatibility
type ServerlessImportRegionalServiceServer interface {
	CheckImportPermission(context.Context, *CheckImportPermissionRequest) (*CheckImportPermissionResponse, error)
	Precheck(context.Context, *PrecheckRequest) (*PrecheckResponse, error)
}

// UnimplementedServerlessImportRegionalServiceServer should be embedded to have forward compatible implementations.
type UnimplementedServerlessImportRegionalServiceServer struct {
}

func (UnimplementedServerlessImportRegionalServiceServer) CheckImportPermission(context.Context, *CheckImportPermissionRequest) (*CheckImportPermissionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CheckImportPermission not implemented")
}
func (UnimplementedServerlessImportRegionalServiceServer) Precheck(context.Context, *PrecheckRequest) (*PrecheckResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Precheck not implemented")
}

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

func RegisterServerlessImportRegionalServiceServer(s grpc.ServiceRegistrar, srv ServerlessImportRegionalServiceServer) {
	s.RegisterService(&ServerlessImportRegionalService_ServiceDesc, srv)
}

func _ServerlessImportRegionalService_CheckImportPermission_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CheckImportPermissionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessImportRegionalServiceServer).CheckImportPermission(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessImportRegionalService_CheckImportPermission_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessImportRegionalServiceServer).CheckImportPermission(ctx, req.(*CheckImportPermissionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessImportRegionalService_Precheck_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PrecheckRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessImportRegionalServiceServer).Precheck(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessImportRegionalService_Precheck_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessImportRegionalServiceServer).Precheck(ctx, req.(*PrecheckRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// ServerlessImportRegionalService_ServiceDesc is the grpc.ServiceDesc for ServerlessImportRegionalService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var ServerlessImportRegionalService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "regional.serverless.v1.ServerlessImportRegionalService",
	HandlerType: (*ServerlessImportRegionalServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CheckImportPermission",
			Handler:    _ServerlessImportRegionalService_CheckImportPermission_Handler,
		},
		{
			MethodName: "Precheck",
			Handler:    _ServerlessImportRegionalService_Precheck_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "regional/serverless/v1/services.proto",
}

const (
	ServerlessDMRegionalService_Precheck_FullMethodName                  = "/regional.serverless.v1.ServerlessDMRegionalService/Precheck"
	ServerlessDMRegionalService_CreateVpcEndpoint_FullMethodName         = "/regional.serverless.v1.ServerlessDMRegionalService/CreateVpcEndpoint"
	ServerlessDMRegionalService_DescribeVpcEndpoint_FullMethodName       = "/regional.serverless.v1.ServerlessDMRegionalService/DescribeVpcEndpoint"
	ServerlessDMRegionalService_DeleteVpcEndpoint_FullMethodName         = "/regional.serverless.v1.ServerlessDMRegionalService/DeleteVpcEndpoint"
	ServerlessDMRegionalService_ListVpcEndpointZones_FullMethodName      = "/regional.serverless.v1.ServerlessDMRegionalService/ListVpcEndpointZones"
	ServerlessDMRegionalService_RemoveZoneFromVpcEndpoint_FullMethodName = "/regional.serverless.v1.ServerlessDMRegionalService/RemoveZoneFromVpcEndpoint"
)

// ServerlessDMRegionalServiceClient is the client API for ServerlessDMRegionalService 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 ServerlessDMRegionalServiceClient interface {
	Precheck(ctx context.Context, in *ServerlessDMRegionalServicePrecheckRequest, opts ...grpc.CallOption) (*ServerlessDMRegionalServicePrecheckResponse, error)
	CreateVpcEndpoint(ctx context.Context, in *CreateVpcEndpointRequest, opts ...grpc.CallOption) (*CreateVpcEndpointResponse, error)
	DescribeVpcEndpoint(ctx context.Context, in *DescribeVpcEndpointRequest, opts ...grpc.CallOption) (*DescribeVpcEndpointResponse, error)
	DeleteVpcEndpoint(ctx context.Context, in *DeleteVpcEndpointRequest, opts ...grpc.CallOption) (*DeleteVpcEndpointResponse, error)
	// List zones of a VPC endpoint
	ListVpcEndpointZones(ctx context.Context, in *ListVpcEndpointZonesRequest, opts ...grpc.CallOption) (*ListVpcEndpointZonesResponse, error)
	// Remove a zone from a VPC endpoint
	RemoveZoneFromVpcEndpoint(ctx context.Context, in *RemoveZoneFromVpcEndpointRequest, opts ...grpc.CallOption) (*RemoveZoneFromVpcEndpointResponse, error)
}

type serverlessDMRegionalServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewServerlessDMRegionalServiceClient(cc grpc.ClientConnInterface) ServerlessDMRegionalServiceClient {
	return &serverlessDMRegionalServiceClient{cc}
}

func (c *serverlessDMRegionalServiceClient) Precheck(ctx context.Context, in *ServerlessDMRegionalServicePrecheckRequest, opts ...grpc.CallOption) (*ServerlessDMRegionalServicePrecheckResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ServerlessDMRegionalServicePrecheckResponse)
	err := c.cc.Invoke(ctx, ServerlessDMRegionalService_Precheck_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessDMRegionalServiceClient) CreateVpcEndpoint(ctx context.Context, in *CreateVpcEndpointRequest, opts ...grpc.CallOption) (*CreateVpcEndpointResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CreateVpcEndpointResponse)
	err := c.cc.Invoke(ctx, ServerlessDMRegionalService_CreateVpcEndpoint_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessDMRegionalServiceClient) DescribeVpcEndpoint(ctx context.Context, in *DescribeVpcEndpointRequest, opts ...grpc.CallOption) (*DescribeVpcEndpointResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DescribeVpcEndpointResponse)
	err := c.cc.Invoke(ctx, ServerlessDMRegionalService_DescribeVpcEndpoint_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessDMRegionalServiceClient) DeleteVpcEndpoint(ctx context.Context, in *DeleteVpcEndpointRequest, opts ...grpc.CallOption) (*DeleteVpcEndpointResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DeleteVpcEndpointResponse)
	err := c.cc.Invoke(ctx, ServerlessDMRegionalService_DeleteVpcEndpoint_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessDMRegionalServiceClient) ListVpcEndpointZones(ctx context.Context, in *ListVpcEndpointZonesRequest, opts ...grpc.CallOption) (*ListVpcEndpointZonesResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListVpcEndpointZonesResponse)
	err := c.cc.Invoke(ctx, ServerlessDMRegionalService_ListVpcEndpointZones_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessDMRegionalServiceClient) RemoveZoneFromVpcEndpoint(ctx context.Context, in *RemoveZoneFromVpcEndpointRequest, opts ...grpc.CallOption) (*RemoveZoneFromVpcEndpointResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(RemoveZoneFromVpcEndpointResponse)
	err := c.cc.Invoke(ctx, ServerlessDMRegionalService_RemoveZoneFromVpcEndpoint_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ServerlessDMRegionalServiceServer is the server API for ServerlessDMRegionalService service.
// All implementations should embed UnimplementedServerlessDMRegionalServiceServer
// for forward compatibility
type ServerlessDMRegionalServiceServer interface {
	Precheck(context.Context, *ServerlessDMRegionalServicePrecheckRequest) (*ServerlessDMRegionalServicePrecheckResponse, error)
	CreateVpcEndpoint(context.Context, *CreateVpcEndpointRequest) (*CreateVpcEndpointResponse, error)
	DescribeVpcEndpoint(context.Context, *DescribeVpcEndpointRequest) (*DescribeVpcEndpointResponse, error)
	DeleteVpcEndpoint(context.Context, *DeleteVpcEndpointRequest) (*DeleteVpcEndpointResponse, error)
	// List zones of a VPC endpoint
	ListVpcEndpointZones(context.Context, *ListVpcEndpointZonesRequest) (*ListVpcEndpointZonesResponse, error)
	// Remove a zone from a VPC endpoint
	RemoveZoneFromVpcEndpoint(context.Context, *RemoveZoneFromVpcEndpointRequest) (*RemoveZoneFromVpcEndpointResponse, error)
}

// UnimplementedServerlessDMRegionalServiceServer should be embedded to have forward compatible implementations.
type UnimplementedServerlessDMRegionalServiceServer struct {
}

func (UnimplementedServerlessDMRegionalServiceServer) Precheck(context.Context, *ServerlessDMRegionalServicePrecheckRequest) (*ServerlessDMRegionalServicePrecheckResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Precheck not implemented")
}
func (UnimplementedServerlessDMRegionalServiceServer) CreateVpcEndpoint(context.Context, *CreateVpcEndpointRequest) (*CreateVpcEndpointResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateVpcEndpoint not implemented")
}
func (UnimplementedServerlessDMRegionalServiceServer) DescribeVpcEndpoint(context.Context, *DescribeVpcEndpointRequest) (*DescribeVpcEndpointResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DescribeVpcEndpoint not implemented")
}
func (UnimplementedServerlessDMRegionalServiceServer) DeleteVpcEndpoint(context.Context, *DeleteVpcEndpointRequest) (*DeleteVpcEndpointResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteVpcEndpoint not implemented")
}
func (UnimplementedServerlessDMRegionalServiceServer) ListVpcEndpointZones(context.Context, *ListVpcEndpointZonesRequest) (*ListVpcEndpointZonesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListVpcEndpointZones not implemented")
}
func (UnimplementedServerlessDMRegionalServiceServer) RemoveZoneFromVpcEndpoint(context.Context, *RemoveZoneFromVpcEndpointRequest) (*RemoveZoneFromVpcEndpointResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RemoveZoneFromVpcEndpoint not implemented")
}

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

func RegisterServerlessDMRegionalServiceServer(s grpc.ServiceRegistrar, srv ServerlessDMRegionalServiceServer) {
	s.RegisterService(&ServerlessDMRegionalService_ServiceDesc, srv)
}

func _ServerlessDMRegionalService_Precheck_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ServerlessDMRegionalServicePrecheckRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessDMRegionalServiceServer).Precheck(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessDMRegionalService_Precheck_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessDMRegionalServiceServer).Precheck(ctx, req.(*ServerlessDMRegionalServicePrecheckRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessDMRegionalService_CreateVpcEndpoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateVpcEndpointRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessDMRegionalServiceServer).CreateVpcEndpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessDMRegionalService_CreateVpcEndpoint_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessDMRegionalServiceServer).CreateVpcEndpoint(ctx, req.(*CreateVpcEndpointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessDMRegionalService_DescribeVpcEndpoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DescribeVpcEndpointRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessDMRegionalServiceServer).DescribeVpcEndpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessDMRegionalService_DescribeVpcEndpoint_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessDMRegionalServiceServer).DescribeVpcEndpoint(ctx, req.(*DescribeVpcEndpointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessDMRegionalService_DeleteVpcEndpoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteVpcEndpointRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessDMRegionalServiceServer).DeleteVpcEndpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessDMRegionalService_DeleteVpcEndpoint_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessDMRegionalServiceServer).DeleteVpcEndpoint(ctx, req.(*DeleteVpcEndpointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessDMRegionalService_ListVpcEndpointZones_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListVpcEndpointZonesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessDMRegionalServiceServer).ListVpcEndpointZones(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessDMRegionalService_ListVpcEndpointZones_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessDMRegionalServiceServer).ListVpcEndpointZones(ctx, req.(*ListVpcEndpointZonesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessDMRegionalService_RemoveZoneFromVpcEndpoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RemoveZoneFromVpcEndpointRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessDMRegionalServiceServer).RemoveZoneFromVpcEndpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessDMRegionalService_RemoveZoneFromVpcEndpoint_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessDMRegionalServiceServer).RemoveZoneFromVpcEndpoint(ctx, req.(*RemoveZoneFromVpcEndpointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// ServerlessDMRegionalService_ServiceDesc is the grpc.ServiceDesc for ServerlessDMRegionalService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var ServerlessDMRegionalService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "regional.serverless.v1.ServerlessDMRegionalService",
	HandlerType: (*ServerlessDMRegionalServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Precheck",
			Handler:    _ServerlessDMRegionalService_Precheck_Handler,
		},
		{
			MethodName: "CreateVpcEndpoint",
			Handler:    _ServerlessDMRegionalService_CreateVpcEndpoint_Handler,
		},
		{
			MethodName: "DescribeVpcEndpoint",
			Handler:    _ServerlessDMRegionalService_DescribeVpcEndpoint_Handler,
		},
		{
			MethodName: "DeleteVpcEndpoint",
			Handler:    _ServerlessDMRegionalService_DeleteVpcEndpoint_Handler,
		},
		{
			MethodName: "ListVpcEndpointZones",
			Handler:    _ServerlessDMRegionalService_ListVpcEndpointZones_Handler,
		},
		{
			MethodName: "RemoveZoneFromVpcEndpoint",
			Handler:    _ServerlessDMRegionalService_RemoveZoneFromVpcEndpoint_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "regional/serverless/v1/services.proto",
}

const (
	ServerlessPrivateLinkConnectionRegionalService_CreateAWSVpcEndpoint_FullMethodName                      = "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/CreateAWSVpcEndpoint"
	ServerlessPrivateLinkConnectionRegionalService_DescribeAWSVpcEndpoint_FullMethodName                    = "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/DescribeAWSVpcEndpoint"
	ServerlessPrivateLinkConnectionRegionalService_DeleteAWSVpcEndpoint_FullMethodName                      = "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/DeleteAWSVpcEndpoint"
	ServerlessPrivateLinkConnectionRegionalService_CreateAliCloudVpcEndpoint_FullMethodName                 = "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/CreateAliCloudVpcEndpoint"
	ServerlessPrivateLinkConnectionRegionalService_DescribeAliCloudVpcEndpoint_FullMethodName               = "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/DescribeAliCloudVpcEndpoint"
	ServerlessPrivateLinkConnectionRegionalService_DeleteAliCloudVpcEndpoint_FullMethodName                 = "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/DeleteAliCloudVpcEndpoint"
	ServerlessPrivateLinkConnectionRegionalService_GetZoneIds_FullMethodName                                = "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/GetZoneIds"
	ServerlessPrivateLinkConnectionRegionalService_ListAliCloudVpcEndpointZones_FullMethodName              = "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/ListAliCloudVpcEndpointZones"
	ServerlessPrivateLinkConnectionRegionalService_RemoveAliCloudZoneFromVpcEndpoint_FullMethodName         = "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/RemoveAliCloudZoneFromVpcEndpoint"
	ServerlessPrivateLinkConnectionRegionalService_CreateAliCloudDNSRecord_FullMethodName                   = "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/CreateAliCloudDNSRecord"
	ServerlessPrivateLinkConnectionRegionalService_DeleteAliCloudDNSRecord_FullMethodName                   = "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/DeleteAliCloudDNSRecord"
	ServerlessPrivateLinkConnectionRegionalService_CreateAWSRoute53Records_FullMethodName                   = "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/CreateAWSRoute53Records"
	ServerlessPrivateLinkConnectionRegionalService_DeleteAWSRoute53Records_FullMethodName                   = "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/DeleteAWSRoute53Records"
	ServerlessPrivateLinkConnectionRegionalService_GetAWSRoute53Change_FullMethodName                       = "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/GetAWSRoute53Change"
	ServerlessPrivateLinkConnectionRegionalService_CreateAWSRoute53PrivateHostedZone_FullMethodName         = "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/CreateAWSRoute53PrivateHostedZone"
	ServerlessPrivateLinkConnectionRegionalService_DeleteAWSRoute53PrivateHostedZone_FullMethodName         = "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/DeleteAWSRoute53PrivateHostedZone"
	ServerlessPrivateLinkConnectionRegionalService_CreateAliCloudDNSPrivateHostedZone_FullMethodName        = "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/CreateAliCloudDNSPrivateHostedZone"
	ServerlessPrivateLinkConnectionRegionalService_DeleteAliCloudDNSPrivateHostedZone_FullMethodName        = "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/DeleteAliCloudDNSPrivateHostedZone"
	ServerlessPrivateLinkConnectionRegionalService_AttachVpcToAliCloudDNSPrivateHostedZone_FullMethodName   = "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/AttachVpcToAliCloudDNSPrivateHostedZone"
	ServerlessPrivateLinkConnectionRegionalService_DetachVpcFromAliCloudDNSPrivateHostedZone_FullMethodName = "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/DetachVpcFromAliCloudDNSPrivateHostedZone"
	ServerlessPrivateLinkConnectionRegionalService_CreateMSKVPCConnection_FullMethodName                    = "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/CreateMSKVPCConnection"
	ServerlessPrivateLinkConnectionRegionalService_DeleteMSKVPCConnection_FullMethodName                    = "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/DeleteMSKVPCConnection"
	ServerlessPrivateLinkConnectionRegionalService_GetMSKVPCConnection_FullMethodName                       = "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/GetMSKVPCConnection"
)

// ServerlessPrivateLinkConnectionRegionalServiceClient is the client API for ServerlessPrivateLinkConnectionRegionalService 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 ServerlessPrivateLinkConnectionRegionalServiceClient interface {
	CreateAWSVpcEndpoint(ctx context.Context, in *CreateAWSVpcEndpointRequest, opts ...grpc.CallOption) (*CreateAWSVpcEndpointResponse, error)
	DescribeAWSVpcEndpoint(ctx context.Context, in *DescribeAWSVpcEndpointRequest, opts ...grpc.CallOption) (*DescribeAWSVpcEndpointResponse, error)
	DeleteAWSVpcEndpoint(ctx context.Context, in *DeleteAWSVpcEndpointRequest, opts ...grpc.CallOption) (*DeleteAWSVpcEndpointResponse, error)
	CreateAliCloudVpcEndpoint(ctx context.Context, in *CreateAliCloudVpcEndpointRequest, opts ...grpc.CallOption) (*CreateAliCloudVpcEndpointResponse, error)
	DescribeAliCloudVpcEndpoint(ctx context.Context, in *DescribeAliCloudVpcEndpointRequest, opts ...grpc.CallOption) (*DescribeAliCloudVpcEndpointResponse, error)
	DeleteAliCloudVpcEndpoint(ctx context.Context, in *DeleteAliCloudVpcEndpointRequest, opts ...grpc.CallOption) (*DeleteAliCloudVpcEndpointResponse, error)
	GetZoneIds(ctx context.Context, in *GetZoneIdsRequest, opts ...grpc.CallOption) (*GetZoneIdsResponse, error)
	// List zones of a VPC endpoint
	ListAliCloudVpcEndpointZones(ctx context.Context, in *ListAliCloudVpcEndpointZonesRequest, opts ...grpc.CallOption) (*ListAliCloudVpcEndpointZonesResponse, error)
	// Remove a zone from a VPC endpoint
	RemoveAliCloudZoneFromVpcEndpoint(ctx context.Context, in *RemoveAliCloudZoneFromVpcEndpointRequest, opts ...grpc.CallOption) (*RemoveAliCloudZoneFromVpcEndpointResponse, error)
	CreateAliCloudDNSRecord(ctx context.Context, in *CreateAliCloudDNSRecordRequest, opts ...grpc.CallOption) (*CreateAliCloudDNSRecordResponse, error)
	DeleteAliCloudDNSRecord(ctx context.Context, in *DeleteAliCloudDNSRecordRequest, opts ...grpc.CallOption) (*DeleteAliCloudDNSRecordResponse, error)
	CreateAWSRoute53Records(ctx context.Context, in *CreateAWSRoute53RecordsRequest, opts ...grpc.CallOption) (*CreateAWSRoute53RecordsResponse, error)
	DeleteAWSRoute53Records(ctx context.Context, in *DeleteAWSRoute53RecordsRequest, opts ...grpc.CallOption) (*DeleteAWSRoute53RecordsResponse, error)
	GetAWSRoute53Change(ctx context.Context, in *GetAWSRoute53ChangeRequest, opts ...grpc.CallOption) (*GetAWSRoute53ChangeResponse, error)
	CreateAWSRoute53PrivateHostedZone(ctx context.Context, in *CreateAWSRoute53PrivateHostedZoneRequest, opts ...grpc.CallOption) (*CreateAWSRoute53PrivateHostedZoneResponse, error)
	DeleteAWSRoute53PrivateHostedZone(ctx context.Context, in *DeleteAWSRoute53PrivateHostedZoneRequest, opts ...grpc.CallOption) (*DeleteAWSRoute53PrivateHostedZoneResponse, error)
	CreateAliCloudDNSPrivateHostedZone(ctx context.Context, in *CreateAliCloudDNSPrivateHostedZoneRequest, opts ...grpc.CallOption) (*CreateAliCloudDNSPrivateHostedZoneResponse, error)
	DeleteAliCloudDNSPrivateHostedZone(ctx context.Context, in *DeleteAliCloudDNSPrivateHostedZoneRequest, opts ...grpc.CallOption) (*DeleteAliCloudDNSPrivateHostedZoneResponse, error)
	AttachVpcToAliCloudDNSPrivateHostedZone(ctx context.Context, in *AttachVpcToAliCloudDNSPrivateHostedZoneRequest, opts ...grpc.CallOption) (*AttachVpcToAliCloudDNSPrivateHostedZoneResponse, error)
	DetachVpcFromAliCloudDNSPrivateHostedZone(ctx context.Context, in *DetachVpcFromAliCloudDNSPrivateHostedZoneRequest, opts ...grpc.CallOption) (*DetachVpcFromAliCloudDNSPrivateHostedZoneResponse, error)
	CreateMSKVPCConnection(ctx context.Context, in *CreateMSKVPCConnectionRequest, opts ...grpc.CallOption) (*CreateMSKVPCConnectionResponse, error)
	DeleteMSKVPCConnection(ctx context.Context, in *DeleteMSKVPCConnectionRequest, opts ...grpc.CallOption) (*DeleteMSKVPCConnectionResponse, error)
	GetMSKVPCConnection(ctx context.Context, in *GetMSKVPCConnectionRequest, opts ...grpc.CallOption) (*GetMSKVPCConnectionResponse, error)
}

type serverlessPrivateLinkConnectionRegionalServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewServerlessPrivateLinkConnectionRegionalServiceClient(cc grpc.ClientConnInterface) ServerlessPrivateLinkConnectionRegionalServiceClient {
	return &serverlessPrivateLinkConnectionRegionalServiceClient{cc}
}

func (c *serverlessPrivateLinkConnectionRegionalServiceClient) CreateAWSVpcEndpoint(ctx context.Context, in *CreateAWSVpcEndpointRequest, opts ...grpc.CallOption) (*CreateAWSVpcEndpointResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CreateAWSVpcEndpointResponse)
	err := c.cc.Invoke(ctx, ServerlessPrivateLinkConnectionRegionalService_CreateAWSVpcEndpoint_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessPrivateLinkConnectionRegionalServiceClient) DescribeAWSVpcEndpoint(ctx context.Context, in *DescribeAWSVpcEndpointRequest, opts ...grpc.CallOption) (*DescribeAWSVpcEndpointResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DescribeAWSVpcEndpointResponse)
	err := c.cc.Invoke(ctx, ServerlessPrivateLinkConnectionRegionalService_DescribeAWSVpcEndpoint_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessPrivateLinkConnectionRegionalServiceClient) DeleteAWSVpcEndpoint(ctx context.Context, in *DeleteAWSVpcEndpointRequest, opts ...grpc.CallOption) (*DeleteAWSVpcEndpointResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DeleteAWSVpcEndpointResponse)
	err := c.cc.Invoke(ctx, ServerlessPrivateLinkConnectionRegionalService_DeleteAWSVpcEndpoint_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessPrivateLinkConnectionRegionalServiceClient) CreateAliCloudVpcEndpoint(ctx context.Context, in *CreateAliCloudVpcEndpointRequest, opts ...grpc.CallOption) (*CreateAliCloudVpcEndpointResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CreateAliCloudVpcEndpointResponse)
	err := c.cc.Invoke(ctx, ServerlessPrivateLinkConnectionRegionalService_CreateAliCloudVpcEndpoint_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessPrivateLinkConnectionRegionalServiceClient) DescribeAliCloudVpcEndpoint(ctx context.Context, in *DescribeAliCloudVpcEndpointRequest, opts ...grpc.CallOption) (*DescribeAliCloudVpcEndpointResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DescribeAliCloudVpcEndpointResponse)
	err := c.cc.Invoke(ctx, ServerlessPrivateLinkConnectionRegionalService_DescribeAliCloudVpcEndpoint_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessPrivateLinkConnectionRegionalServiceClient) DeleteAliCloudVpcEndpoint(ctx context.Context, in *DeleteAliCloudVpcEndpointRequest, opts ...grpc.CallOption) (*DeleteAliCloudVpcEndpointResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DeleteAliCloudVpcEndpointResponse)
	err := c.cc.Invoke(ctx, ServerlessPrivateLinkConnectionRegionalService_DeleteAliCloudVpcEndpoint_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessPrivateLinkConnectionRegionalServiceClient) GetZoneIds(ctx context.Context, in *GetZoneIdsRequest, opts ...grpc.CallOption) (*GetZoneIdsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetZoneIdsResponse)
	err := c.cc.Invoke(ctx, ServerlessPrivateLinkConnectionRegionalService_GetZoneIds_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessPrivateLinkConnectionRegionalServiceClient) ListAliCloudVpcEndpointZones(ctx context.Context, in *ListAliCloudVpcEndpointZonesRequest, opts ...grpc.CallOption) (*ListAliCloudVpcEndpointZonesResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListAliCloudVpcEndpointZonesResponse)
	err := c.cc.Invoke(ctx, ServerlessPrivateLinkConnectionRegionalService_ListAliCloudVpcEndpointZones_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessPrivateLinkConnectionRegionalServiceClient) RemoveAliCloudZoneFromVpcEndpoint(ctx context.Context, in *RemoveAliCloudZoneFromVpcEndpointRequest, opts ...grpc.CallOption) (*RemoveAliCloudZoneFromVpcEndpointResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(RemoveAliCloudZoneFromVpcEndpointResponse)
	err := c.cc.Invoke(ctx, ServerlessPrivateLinkConnectionRegionalService_RemoveAliCloudZoneFromVpcEndpoint_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessPrivateLinkConnectionRegionalServiceClient) CreateAliCloudDNSRecord(ctx context.Context, in *CreateAliCloudDNSRecordRequest, opts ...grpc.CallOption) (*CreateAliCloudDNSRecordResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CreateAliCloudDNSRecordResponse)
	err := c.cc.Invoke(ctx, ServerlessPrivateLinkConnectionRegionalService_CreateAliCloudDNSRecord_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessPrivateLinkConnectionRegionalServiceClient) DeleteAliCloudDNSRecord(ctx context.Context, in *DeleteAliCloudDNSRecordRequest, opts ...grpc.CallOption) (*DeleteAliCloudDNSRecordResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DeleteAliCloudDNSRecordResponse)
	err := c.cc.Invoke(ctx, ServerlessPrivateLinkConnectionRegionalService_DeleteAliCloudDNSRecord_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessPrivateLinkConnectionRegionalServiceClient) CreateAWSRoute53Records(ctx context.Context, in *CreateAWSRoute53RecordsRequest, opts ...grpc.CallOption) (*CreateAWSRoute53RecordsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CreateAWSRoute53RecordsResponse)
	err := c.cc.Invoke(ctx, ServerlessPrivateLinkConnectionRegionalService_CreateAWSRoute53Records_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessPrivateLinkConnectionRegionalServiceClient) DeleteAWSRoute53Records(ctx context.Context, in *DeleteAWSRoute53RecordsRequest, opts ...grpc.CallOption) (*DeleteAWSRoute53RecordsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DeleteAWSRoute53RecordsResponse)
	err := c.cc.Invoke(ctx, ServerlessPrivateLinkConnectionRegionalService_DeleteAWSRoute53Records_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessPrivateLinkConnectionRegionalServiceClient) GetAWSRoute53Change(ctx context.Context, in *GetAWSRoute53ChangeRequest, opts ...grpc.CallOption) (*GetAWSRoute53ChangeResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetAWSRoute53ChangeResponse)
	err := c.cc.Invoke(ctx, ServerlessPrivateLinkConnectionRegionalService_GetAWSRoute53Change_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessPrivateLinkConnectionRegionalServiceClient) CreateAWSRoute53PrivateHostedZone(ctx context.Context, in *CreateAWSRoute53PrivateHostedZoneRequest, opts ...grpc.CallOption) (*CreateAWSRoute53PrivateHostedZoneResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CreateAWSRoute53PrivateHostedZoneResponse)
	err := c.cc.Invoke(ctx, ServerlessPrivateLinkConnectionRegionalService_CreateAWSRoute53PrivateHostedZone_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessPrivateLinkConnectionRegionalServiceClient) DeleteAWSRoute53PrivateHostedZone(ctx context.Context, in *DeleteAWSRoute53PrivateHostedZoneRequest, opts ...grpc.CallOption) (*DeleteAWSRoute53PrivateHostedZoneResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DeleteAWSRoute53PrivateHostedZoneResponse)
	err := c.cc.Invoke(ctx, ServerlessPrivateLinkConnectionRegionalService_DeleteAWSRoute53PrivateHostedZone_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessPrivateLinkConnectionRegionalServiceClient) CreateAliCloudDNSPrivateHostedZone(ctx context.Context, in *CreateAliCloudDNSPrivateHostedZoneRequest, opts ...grpc.CallOption) (*CreateAliCloudDNSPrivateHostedZoneResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CreateAliCloudDNSPrivateHostedZoneResponse)
	err := c.cc.Invoke(ctx, ServerlessPrivateLinkConnectionRegionalService_CreateAliCloudDNSPrivateHostedZone_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessPrivateLinkConnectionRegionalServiceClient) DeleteAliCloudDNSPrivateHostedZone(ctx context.Context, in *DeleteAliCloudDNSPrivateHostedZoneRequest, opts ...grpc.CallOption) (*DeleteAliCloudDNSPrivateHostedZoneResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DeleteAliCloudDNSPrivateHostedZoneResponse)
	err := c.cc.Invoke(ctx, ServerlessPrivateLinkConnectionRegionalService_DeleteAliCloudDNSPrivateHostedZone_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessPrivateLinkConnectionRegionalServiceClient) AttachVpcToAliCloudDNSPrivateHostedZone(ctx context.Context, in *AttachVpcToAliCloudDNSPrivateHostedZoneRequest, opts ...grpc.CallOption) (*AttachVpcToAliCloudDNSPrivateHostedZoneResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(AttachVpcToAliCloudDNSPrivateHostedZoneResponse)
	err := c.cc.Invoke(ctx, ServerlessPrivateLinkConnectionRegionalService_AttachVpcToAliCloudDNSPrivateHostedZone_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessPrivateLinkConnectionRegionalServiceClient) DetachVpcFromAliCloudDNSPrivateHostedZone(ctx context.Context, in *DetachVpcFromAliCloudDNSPrivateHostedZoneRequest, opts ...grpc.CallOption) (*DetachVpcFromAliCloudDNSPrivateHostedZoneResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DetachVpcFromAliCloudDNSPrivateHostedZoneResponse)
	err := c.cc.Invoke(ctx, ServerlessPrivateLinkConnectionRegionalService_DetachVpcFromAliCloudDNSPrivateHostedZone_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessPrivateLinkConnectionRegionalServiceClient) CreateMSKVPCConnection(ctx context.Context, in *CreateMSKVPCConnectionRequest, opts ...grpc.CallOption) (*CreateMSKVPCConnectionResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CreateMSKVPCConnectionResponse)
	err := c.cc.Invoke(ctx, ServerlessPrivateLinkConnectionRegionalService_CreateMSKVPCConnection_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessPrivateLinkConnectionRegionalServiceClient) DeleteMSKVPCConnection(ctx context.Context, in *DeleteMSKVPCConnectionRequest, opts ...grpc.CallOption) (*DeleteMSKVPCConnectionResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DeleteMSKVPCConnectionResponse)
	err := c.cc.Invoke(ctx, ServerlessPrivateLinkConnectionRegionalService_DeleteMSKVPCConnection_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessPrivateLinkConnectionRegionalServiceClient) GetMSKVPCConnection(ctx context.Context, in *GetMSKVPCConnectionRequest, opts ...grpc.CallOption) (*GetMSKVPCConnectionResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetMSKVPCConnectionResponse)
	err := c.cc.Invoke(ctx, ServerlessPrivateLinkConnectionRegionalService_GetMSKVPCConnection_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ServerlessPrivateLinkConnectionRegionalServiceServer is the server API for ServerlessPrivateLinkConnectionRegionalService service.
// All implementations should embed UnimplementedServerlessPrivateLinkConnectionRegionalServiceServer
// for forward compatibility
type ServerlessPrivateLinkConnectionRegionalServiceServer interface {
	CreateAWSVpcEndpoint(context.Context, *CreateAWSVpcEndpointRequest) (*CreateAWSVpcEndpointResponse, error)
	DescribeAWSVpcEndpoint(context.Context, *DescribeAWSVpcEndpointRequest) (*DescribeAWSVpcEndpointResponse, error)
	DeleteAWSVpcEndpoint(context.Context, *DeleteAWSVpcEndpointRequest) (*DeleteAWSVpcEndpointResponse, error)
	CreateAliCloudVpcEndpoint(context.Context, *CreateAliCloudVpcEndpointRequest) (*CreateAliCloudVpcEndpointResponse, error)
	DescribeAliCloudVpcEndpoint(context.Context, *DescribeAliCloudVpcEndpointRequest) (*DescribeAliCloudVpcEndpointResponse, error)
	DeleteAliCloudVpcEndpoint(context.Context, *DeleteAliCloudVpcEndpointRequest) (*DeleteAliCloudVpcEndpointResponse, error)
	GetZoneIds(context.Context, *GetZoneIdsRequest) (*GetZoneIdsResponse, error)
	// List zones of a VPC endpoint
	ListAliCloudVpcEndpointZones(context.Context, *ListAliCloudVpcEndpointZonesRequest) (*ListAliCloudVpcEndpointZonesResponse, error)
	// Remove a zone from a VPC endpoint
	RemoveAliCloudZoneFromVpcEndpoint(context.Context, *RemoveAliCloudZoneFromVpcEndpointRequest) (*RemoveAliCloudZoneFromVpcEndpointResponse, error)
	CreateAliCloudDNSRecord(context.Context, *CreateAliCloudDNSRecordRequest) (*CreateAliCloudDNSRecordResponse, error)
	DeleteAliCloudDNSRecord(context.Context, *DeleteAliCloudDNSRecordRequest) (*DeleteAliCloudDNSRecordResponse, error)
	CreateAWSRoute53Records(context.Context, *CreateAWSRoute53RecordsRequest) (*CreateAWSRoute53RecordsResponse, error)
	DeleteAWSRoute53Records(context.Context, *DeleteAWSRoute53RecordsRequest) (*DeleteAWSRoute53RecordsResponse, error)
	GetAWSRoute53Change(context.Context, *GetAWSRoute53ChangeRequest) (*GetAWSRoute53ChangeResponse, error)
	CreateAWSRoute53PrivateHostedZone(context.Context, *CreateAWSRoute53PrivateHostedZoneRequest) (*CreateAWSRoute53PrivateHostedZoneResponse, error)
	DeleteAWSRoute53PrivateHostedZone(context.Context, *DeleteAWSRoute53PrivateHostedZoneRequest) (*DeleteAWSRoute53PrivateHostedZoneResponse, error)
	CreateAliCloudDNSPrivateHostedZone(context.Context, *CreateAliCloudDNSPrivateHostedZoneRequest) (*CreateAliCloudDNSPrivateHostedZoneResponse, error)
	DeleteAliCloudDNSPrivateHostedZone(context.Context, *DeleteAliCloudDNSPrivateHostedZoneRequest) (*DeleteAliCloudDNSPrivateHostedZoneResponse, error)
	AttachVpcToAliCloudDNSPrivateHostedZone(context.Context, *AttachVpcToAliCloudDNSPrivateHostedZoneRequest) (*AttachVpcToAliCloudDNSPrivateHostedZoneResponse, error)
	DetachVpcFromAliCloudDNSPrivateHostedZone(context.Context, *DetachVpcFromAliCloudDNSPrivateHostedZoneRequest) (*DetachVpcFromAliCloudDNSPrivateHostedZoneResponse, error)
	CreateMSKVPCConnection(context.Context, *CreateMSKVPCConnectionRequest) (*CreateMSKVPCConnectionResponse, error)
	DeleteMSKVPCConnection(context.Context, *DeleteMSKVPCConnectionRequest) (*DeleteMSKVPCConnectionResponse, error)
	GetMSKVPCConnection(context.Context, *GetMSKVPCConnectionRequest) (*GetMSKVPCConnectionResponse, error)
}

// UnimplementedServerlessPrivateLinkConnectionRegionalServiceServer should be embedded to have forward compatible implementations.
type UnimplementedServerlessPrivateLinkConnectionRegionalServiceServer struct {
}

func (UnimplementedServerlessPrivateLinkConnectionRegionalServiceServer) CreateAWSVpcEndpoint(context.Context, *CreateAWSVpcEndpointRequest) (*CreateAWSVpcEndpointResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateAWSVpcEndpoint not implemented")
}
func (UnimplementedServerlessPrivateLinkConnectionRegionalServiceServer) DescribeAWSVpcEndpoint(context.Context, *DescribeAWSVpcEndpointRequest) (*DescribeAWSVpcEndpointResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DescribeAWSVpcEndpoint not implemented")
}
func (UnimplementedServerlessPrivateLinkConnectionRegionalServiceServer) DeleteAWSVpcEndpoint(context.Context, *DeleteAWSVpcEndpointRequest) (*DeleteAWSVpcEndpointResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteAWSVpcEndpoint not implemented")
}
func (UnimplementedServerlessPrivateLinkConnectionRegionalServiceServer) CreateAliCloudVpcEndpoint(context.Context, *CreateAliCloudVpcEndpointRequest) (*CreateAliCloudVpcEndpointResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateAliCloudVpcEndpoint not implemented")
}
func (UnimplementedServerlessPrivateLinkConnectionRegionalServiceServer) DescribeAliCloudVpcEndpoint(context.Context, *DescribeAliCloudVpcEndpointRequest) (*DescribeAliCloudVpcEndpointResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DescribeAliCloudVpcEndpoint not implemented")
}
func (UnimplementedServerlessPrivateLinkConnectionRegionalServiceServer) DeleteAliCloudVpcEndpoint(context.Context, *DeleteAliCloudVpcEndpointRequest) (*DeleteAliCloudVpcEndpointResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteAliCloudVpcEndpoint not implemented")
}
func (UnimplementedServerlessPrivateLinkConnectionRegionalServiceServer) GetZoneIds(context.Context, *GetZoneIdsRequest) (*GetZoneIdsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetZoneIds not implemented")
}
func (UnimplementedServerlessPrivateLinkConnectionRegionalServiceServer) ListAliCloudVpcEndpointZones(context.Context, *ListAliCloudVpcEndpointZonesRequest) (*ListAliCloudVpcEndpointZonesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListAliCloudVpcEndpointZones not implemented")
}
func (UnimplementedServerlessPrivateLinkConnectionRegionalServiceServer) RemoveAliCloudZoneFromVpcEndpoint(context.Context, *RemoveAliCloudZoneFromVpcEndpointRequest) (*RemoveAliCloudZoneFromVpcEndpointResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RemoveAliCloudZoneFromVpcEndpoint not implemented")
}
func (UnimplementedServerlessPrivateLinkConnectionRegionalServiceServer) CreateAliCloudDNSRecord(context.Context, *CreateAliCloudDNSRecordRequest) (*CreateAliCloudDNSRecordResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateAliCloudDNSRecord not implemented")
}
func (UnimplementedServerlessPrivateLinkConnectionRegionalServiceServer) DeleteAliCloudDNSRecord(context.Context, *DeleteAliCloudDNSRecordRequest) (*DeleteAliCloudDNSRecordResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteAliCloudDNSRecord not implemented")
}
func (UnimplementedServerlessPrivateLinkConnectionRegionalServiceServer) CreateAWSRoute53Records(context.Context, *CreateAWSRoute53RecordsRequest) (*CreateAWSRoute53RecordsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateAWSRoute53Records not implemented")
}
func (UnimplementedServerlessPrivateLinkConnectionRegionalServiceServer) DeleteAWSRoute53Records(context.Context, *DeleteAWSRoute53RecordsRequest) (*DeleteAWSRoute53RecordsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteAWSRoute53Records not implemented")
}
func (UnimplementedServerlessPrivateLinkConnectionRegionalServiceServer) GetAWSRoute53Change(context.Context, *GetAWSRoute53ChangeRequest) (*GetAWSRoute53ChangeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetAWSRoute53Change not implemented")
}
func (UnimplementedServerlessPrivateLinkConnectionRegionalServiceServer) CreateAWSRoute53PrivateHostedZone(context.Context, *CreateAWSRoute53PrivateHostedZoneRequest) (*CreateAWSRoute53PrivateHostedZoneResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateAWSRoute53PrivateHostedZone not implemented")
}
func (UnimplementedServerlessPrivateLinkConnectionRegionalServiceServer) DeleteAWSRoute53PrivateHostedZone(context.Context, *DeleteAWSRoute53PrivateHostedZoneRequest) (*DeleteAWSRoute53PrivateHostedZoneResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteAWSRoute53PrivateHostedZone not implemented")
}
func (UnimplementedServerlessPrivateLinkConnectionRegionalServiceServer) CreateAliCloudDNSPrivateHostedZone(context.Context, *CreateAliCloudDNSPrivateHostedZoneRequest) (*CreateAliCloudDNSPrivateHostedZoneResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateAliCloudDNSPrivateHostedZone not implemented")
}
func (UnimplementedServerlessPrivateLinkConnectionRegionalServiceServer) DeleteAliCloudDNSPrivateHostedZone(context.Context, *DeleteAliCloudDNSPrivateHostedZoneRequest) (*DeleteAliCloudDNSPrivateHostedZoneResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteAliCloudDNSPrivateHostedZone not implemented")
}
func (UnimplementedServerlessPrivateLinkConnectionRegionalServiceServer) AttachVpcToAliCloudDNSPrivateHostedZone(context.Context, *AttachVpcToAliCloudDNSPrivateHostedZoneRequest) (*AttachVpcToAliCloudDNSPrivateHostedZoneResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AttachVpcToAliCloudDNSPrivateHostedZone not implemented")
}
func (UnimplementedServerlessPrivateLinkConnectionRegionalServiceServer) DetachVpcFromAliCloudDNSPrivateHostedZone(context.Context, *DetachVpcFromAliCloudDNSPrivateHostedZoneRequest) (*DetachVpcFromAliCloudDNSPrivateHostedZoneResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DetachVpcFromAliCloudDNSPrivateHostedZone not implemented")
}
func (UnimplementedServerlessPrivateLinkConnectionRegionalServiceServer) CreateMSKVPCConnection(context.Context, *CreateMSKVPCConnectionRequest) (*CreateMSKVPCConnectionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateMSKVPCConnection not implemented")
}
func (UnimplementedServerlessPrivateLinkConnectionRegionalServiceServer) DeleteMSKVPCConnection(context.Context, *DeleteMSKVPCConnectionRequest) (*DeleteMSKVPCConnectionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteMSKVPCConnection not implemented")
}
func (UnimplementedServerlessPrivateLinkConnectionRegionalServiceServer) GetMSKVPCConnection(context.Context, *GetMSKVPCConnectionRequest) (*GetMSKVPCConnectionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetMSKVPCConnection not implemented")
}

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

func RegisterServerlessPrivateLinkConnectionRegionalServiceServer(s grpc.ServiceRegistrar, srv ServerlessPrivateLinkConnectionRegionalServiceServer) {
	s.RegisterService(&ServerlessPrivateLinkConnectionRegionalService_ServiceDesc, srv)
}

func _ServerlessPrivateLinkConnectionRegionalService_CreateAWSVpcEndpoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateAWSVpcEndpointRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessPrivateLinkConnectionRegionalServiceServer).CreateAWSVpcEndpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPrivateLinkConnectionRegionalService_CreateAWSVpcEndpoint_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPrivateLinkConnectionRegionalServiceServer).CreateAWSVpcEndpoint(ctx, req.(*CreateAWSVpcEndpointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessPrivateLinkConnectionRegionalService_DescribeAWSVpcEndpoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DescribeAWSVpcEndpointRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessPrivateLinkConnectionRegionalServiceServer).DescribeAWSVpcEndpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPrivateLinkConnectionRegionalService_DescribeAWSVpcEndpoint_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPrivateLinkConnectionRegionalServiceServer).DescribeAWSVpcEndpoint(ctx, req.(*DescribeAWSVpcEndpointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessPrivateLinkConnectionRegionalService_DeleteAWSVpcEndpoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteAWSVpcEndpointRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessPrivateLinkConnectionRegionalServiceServer).DeleteAWSVpcEndpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPrivateLinkConnectionRegionalService_DeleteAWSVpcEndpoint_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPrivateLinkConnectionRegionalServiceServer).DeleteAWSVpcEndpoint(ctx, req.(*DeleteAWSVpcEndpointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessPrivateLinkConnectionRegionalService_CreateAliCloudVpcEndpoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateAliCloudVpcEndpointRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessPrivateLinkConnectionRegionalServiceServer).CreateAliCloudVpcEndpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPrivateLinkConnectionRegionalService_CreateAliCloudVpcEndpoint_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPrivateLinkConnectionRegionalServiceServer).CreateAliCloudVpcEndpoint(ctx, req.(*CreateAliCloudVpcEndpointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessPrivateLinkConnectionRegionalService_DescribeAliCloudVpcEndpoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DescribeAliCloudVpcEndpointRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessPrivateLinkConnectionRegionalServiceServer).DescribeAliCloudVpcEndpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPrivateLinkConnectionRegionalService_DescribeAliCloudVpcEndpoint_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPrivateLinkConnectionRegionalServiceServer).DescribeAliCloudVpcEndpoint(ctx, req.(*DescribeAliCloudVpcEndpointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessPrivateLinkConnectionRegionalService_DeleteAliCloudVpcEndpoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteAliCloudVpcEndpointRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessPrivateLinkConnectionRegionalServiceServer).DeleteAliCloudVpcEndpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPrivateLinkConnectionRegionalService_DeleteAliCloudVpcEndpoint_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPrivateLinkConnectionRegionalServiceServer).DeleteAliCloudVpcEndpoint(ctx, req.(*DeleteAliCloudVpcEndpointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessPrivateLinkConnectionRegionalService_GetZoneIds_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetZoneIdsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessPrivateLinkConnectionRegionalServiceServer).GetZoneIds(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPrivateLinkConnectionRegionalService_GetZoneIds_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPrivateLinkConnectionRegionalServiceServer).GetZoneIds(ctx, req.(*GetZoneIdsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessPrivateLinkConnectionRegionalService_ListAliCloudVpcEndpointZones_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListAliCloudVpcEndpointZonesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessPrivateLinkConnectionRegionalServiceServer).ListAliCloudVpcEndpointZones(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPrivateLinkConnectionRegionalService_ListAliCloudVpcEndpointZones_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPrivateLinkConnectionRegionalServiceServer).ListAliCloudVpcEndpointZones(ctx, req.(*ListAliCloudVpcEndpointZonesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessPrivateLinkConnectionRegionalService_RemoveAliCloudZoneFromVpcEndpoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RemoveAliCloudZoneFromVpcEndpointRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessPrivateLinkConnectionRegionalServiceServer).RemoveAliCloudZoneFromVpcEndpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPrivateLinkConnectionRegionalService_RemoveAliCloudZoneFromVpcEndpoint_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPrivateLinkConnectionRegionalServiceServer).RemoveAliCloudZoneFromVpcEndpoint(ctx, req.(*RemoveAliCloudZoneFromVpcEndpointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessPrivateLinkConnectionRegionalService_CreateAliCloudDNSRecord_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateAliCloudDNSRecordRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessPrivateLinkConnectionRegionalServiceServer).CreateAliCloudDNSRecord(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPrivateLinkConnectionRegionalService_CreateAliCloudDNSRecord_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPrivateLinkConnectionRegionalServiceServer).CreateAliCloudDNSRecord(ctx, req.(*CreateAliCloudDNSRecordRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessPrivateLinkConnectionRegionalService_DeleteAliCloudDNSRecord_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteAliCloudDNSRecordRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessPrivateLinkConnectionRegionalServiceServer).DeleteAliCloudDNSRecord(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPrivateLinkConnectionRegionalService_DeleteAliCloudDNSRecord_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPrivateLinkConnectionRegionalServiceServer).DeleteAliCloudDNSRecord(ctx, req.(*DeleteAliCloudDNSRecordRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessPrivateLinkConnectionRegionalService_CreateAWSRoute53Records_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateAWSRoute53RecordsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessPrivateLinkConnectionRegionalServiceServer).CreateAWSRoute53Records(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPrivateLinkConnectionRegionalService_CreateAWSRoute53Records_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPrivateLinkConnectionRegionalServiceServer).CreateAWSRoute53Records(ctx, req.(*CreateAWSRoute53RecordsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessPrivateLinkConnectionRegionalService_DeleteAWSRoute53Records_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteAWSRoute53RecordsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessPrivateLinkConnectionRegionalServiceServer).DeleteAWSRoute53Records(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPrivateLinkConnectionRegionalService_DeleteAWSRoute53Records_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPrivateLinkConnectionRegionalServiceServer).DeleteAWSRoute53Records(ctx, req.(*DeleteAWSRoute53RecordsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessPrivateLinkConnectionRegionalService_GetAWSRoute53Change_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetAWSRoute53ChangeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessPrivateLinkConnectionRegionalServiceServer).GetAWSRoute53Change(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPrivateLinkConnectionRegionalService_GetAWSRoute53Change_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPrivateLinkConnectionRegionalServiceServer).GetAWSRoute53Change(ctx, req.(*GetAWSRoute53ChangeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessPrivateLinkConnectionRegionalService_CreateAWSRoute53PrivateHostedZone_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateAWSRoute53PrivateHostedZoneRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessPrivateLinkConnectionRegionalServiceServer).CreateAWSRoute53PrivateHostedZone(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPrivateLinkConnectionRegionalService_CreateAWSRoute53PrivateHostedZone_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPrivateLinkConnectionRegionalServiceServer).CreateAWSRoute53PrivateHostedZone(ctx, req.(*CreateAWSRoute53PrivateHostedZoneRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessPrivateLinkConnectionRegionalService_DeleteAWSRoute53PrivateHostedZone_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteAWSRoute53PrivateHostedZoneRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessPrivateLinkConnectionRegionalServiceServer).DeleteAWSRoute53PrivateHostedZone(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPrivateLinkConnectionRegionalService_DeleteAWSRoute53PrivateHostedZone_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPrivateLinkConnectionRegionalServiceServer).DeleteAWSRoute53PrivateHostedZone(ctx, req.(*DeleteAWSRoute53PrivateHostedZoneRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessPrivateLinkConnectionRegionalService_CreateAliCloudDNSPrivateHostedZone_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateAliCloudDNSPrivateHostedZoneRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessPrivateLinkConnectionRegionalServiceServer).CreateAliCloudDNSPrivateHostedZone(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPrivateLinkConnectionRegionalService_CreateAliCloudDNSPrivateHostedZone_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPrivateLinkConnectionRegionalServiceServer).CreateAliCloudDNSPrivateHostedZone(ctx, req.(*CreateAliCloudDNSPrivateHostedZoneRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessPrivateLinkConnectionRegionalService_DeleteAliCloudDNSPrivateHostedZone_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteAliCloudDNSPrivateHostedZoneRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessPrivateLinkConnectionRegionalServiceServer).DeleteAliCloudDNSPrivateHostedZone(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPrivateLinkConnectionRegionalService_DeleteAliCloudDNSPrivateHostedZone_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPrivateLinkConnectionRegionalServiceServer).DeleteAliCloudDNSPrivateHostedZone(ctx, req.(*DeleteAliCloudDNSPrivateHostedZoneRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessPrivateLinkConnectionRegionalService_AttachVpcToAliCloudDNSPrivateHostedZone_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AttachVpcToAliCloudDNSPrivateHostedZoneRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessPrivateLinkConnectionRegionalServiceServer).AttachVpcToAliCloudDNSPrivateHostedZone(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPrivateLinkConnectionRegionalService_AttachVpcToAliCloudDNSPrivateHostedZone_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPrivateLinkConnectionRegionalServiceServer).AttachVpcToAliCloudDNSPrivateHostedZone(ctx, req.(*AttachVpcToAliCloudDNSPrivateHostedZoneRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessPrivateLinkConnectionRegionalService_DetachVpcFromAliCloudDNSPrivateHostedZone_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DetachVpcFromAliCloudDNSPrivateHostedZoneRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessPrivateLinkConnectionRegionalServiceServer).DetachVpcFromAliCloudDNSPrivateHostedZone(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPrivateLinkConnectionRegionalService_DetachVpcFromAliCloudDNSPrivateHostedZone_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPrivateLinkConnectionRegionalServiceServer).DetachVpcFromAliCloudDNSPrivateHostedZone(ctx, req.(*DetachVpcFromAliCloudDNSPrivateHostedZoneRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessPrivateLinkConnectionRegionalService_CreateMSKVPCConnection_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateMSKVPCConnectionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessPrivateLinkConnectionRegionalServiceServer).CreateMSKVPCConnection(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPrivateLinkConnectionRegionalService_CreateMSKVPCConnection_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPrivateLinkConnectionRegionalServiceServer).CreateMSKVPCConnection(ctx, req.(*CreateMSKVPCConnectionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessPrivateLinkConnectionRegionalService_DeleteMSKVPCConnection_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteMSKVPCConnectionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessPrivateLinkConnectionRegionalServiceServer).DeleteMSKVPCConnection(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPrivateLinkConnectionRegionalService_DeleteMSKVPCConnection_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPrivateLinkConnectionRegionalServiceServer).DeleteMSKVPCConnection(ctx, req.(*DeleteMSKVPCConnectionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessPrivateLinkConnectionRegionalService_GetMSKVPCConnection_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetMSKVPCConnectionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessPrivateLinkConnectionRegionalServiceServer).GetMSKVPCConnection(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPrivateLinkConnectionRegionalService_GetMSKVPCConnection_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPrivateLinkConnectionRegionalServiceServer).GetMSKVPCConnection(ctx, req.(*GetMSKVPCConnectionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// ServerlessPrivateLinkConnectionRegionalService_ServiceDesc is the grpc.ServiceDesc for ServerlessPrivateLinkConnectionRegionalService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var ServerlessPrivateLinkConnectionRegionalService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService",
	HandlerType: (*ServerlessPrivateLinkConnectionRegionalServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateAWSVpcEndpoint",
			Handler:    _ServerlessPrivateLinkConnectionRegionalService_CreateAWSVpcEndpoint_Handler,
		},
		{
			MethodName: "DescribeAWSVpcEndpoint",
			Handler:    _ServerlessPrivateLinkConnectionRegionalService_DescribeAWSVpcEndpoint_Handler,
		},
		{
			MethodName: "DeleteAWSVpcEndpoint",
			Handler:    _ServerlessPrivateLinkConnectionRegionalService_DeleteAWSVpcEndpoint_Handler,
		},
		{
			MethodName: "CreateAliCloudVpcEndpoint",
			Handler:    _ServerlessPrivateLinkConnectionRegionalService_CreateAliCloudVpcEndpoint_Handler,
		},
		{
			MethodName: "DescribeAliCloudVpcEndpoint",
			Handler:    _ServerlessPrivateLinkConnectionRegionalService_DescribeAliCloudVpcEndpoint_Handler,
		},
		{
			MethodName: "DeleteAliCloudVpcEndpoint",
			Handler:    _ServerlessPrivateLinkConnectionRegionalService_DeleteAliCloudVpcEndpoint_Handler,
		},
		{
			MethodName: "GetZoneIds",
			Handler:    _ServerlessPrivateLinkConnectionRegionalService_GetZoneIds_Handler,
		},
		{
			MethodName: "ListAliCloudVpcEndpointZones",
			Handler:    _ServerlessPrivateLinkConnectionRegionalService_ListAliCloudVpcEndpointZones_Handler,
		},
		{
			MethodName: "RemoveAliCloudZoneFromVpcEndpoint",
			Handler:    _ServerlessPrivateLinkConnectionRegionalService_RemoveAliCloudZoneFromVpcEndpoint_Handler,
		},
		{
			MethodName: "CreateAliCloudDNSRecord",
			Handler:    _ServerlessPrivateLinkConnectionRegionalService_CreateAliCloudDNSRecord_Handler,
		},
		{
			MethodName: "DeleteAliCloudDNSRecord",
			Handler:    _ServerlessPrivateLinkConnectionRegionalService_DeleteAliCloudDNSRecord_Handler,
		},
		{
			MethodName: "CreateAWSRoute53Records",
			Handler:    _ServerlessPrivateLinkConnectionRegionalService_CreateAWSRoute53Records_Handler,
		},
		{
			MethodName: "DeleteAWSRoute53Records",
			Handler:    _ServerlessPrivateLinkConnectionRegionalService_DeleteAWSRoute53Records_Handler,
		},
		{
			MethodName: "GetAWSRoute53Change",
			Handler:    _ServerlessPrivateLinkConnectionRegionalService_GetAWSRoute53Change_Handler,
		},
		{
			MethodName: "CreateAWSRoute53PrivateHostedZone",
			Handler:    _ServerlessPrivateLinkConnectionRegionalService_CreateAWSRoute53PrivateHostedZone_Handler,
		},
		{
			MethodName: "DeleteAWSRoute53PrivateHostedZone",
			Handler:    _ServerlessPrivateLinkConnectionRegionalService_DeleteAWSRoute53PrivateHostedZone_Handler,
		},
		{
			MethodName: "CreateAliCloudDNSPrivateHostedZone",
			Handler:    _ServerlessPrivateLinkConnectionRegionalService_CreateAliCloudDNSPrivateHostedZone_Handler,
		},
		{
			MethodName: "DeleteAliCloudDNSPrivateHostedZone",
			Handler:    _ServerlessPrivateLinkConnectionRegionalService_DeleteAliCloudDNSPrivateHostedZone_Handler,
		},
		{
			MethodName: "AttachVpcToAliCloudDNSPrivateHostedZone",
			Handler:    _ServerlessPrivateLinkConnectionRegionalService_AttachVpcToAliCloudDNSPrivateHostedZone_Handler,
		},
		{
			MethodName: "DetachVpcFromAliCloudDNSPrivateHostedZone",
			Handler:    _ServerlessPrivateLinkConnectionRegionalService_DetachVpcFromAliCloudDNSPrivateHostedZone_Handler,
		},
		{
			MethodName: "CreateMSKVPCConnection",
			Handler:    _ServerlessPrivateLinkConnectionRegionalService_CreateMSKVPCConnection_Handler,
		},
		{
			MethodName: "DeleteMSKVPCConnection",
			Handler:    _ServerlessPrivateLinkConnectionRegionalService_DeleteMSKVPCConnection_Handler,
		},
		{
			MethodName: "GetMSKVPCConnection",
			Handler:    _ServerlessPrivateLinkConnectionRegionalService_GetMSKVPCConnection_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "regional/serverless/v1/services.proto",
}