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

package serverlessv1

import (
	context "context"
	v1 "github.com/tidbcloud/tidb-management-service/api/spec/global/common/v1"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
)

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

const (
	ServerlessService_Create_FullMethodName                      = "/global.serverless.v1.ServerlessService/Create"
	ServerlessService_Update_FullMethodName                      = "/global.serverless.v1.ServerlessService/Update"
	ServerlessService_List_FullMethodName                        = "/global.serverless.v1.ServerlessService/List"
	ServerlessService_Delete_FullMethodName                      = "/global.serverless.v1.ServerlessService/Delete"
	ServerlessService_GetEncryptedCloudAdminPwd_FullMethodName   = "/global.serverless.v1.ServerlessService/GetEncryptedCloudAdminPwd"
	ServerlessService_CountClusters_FullMethodName               = "/global.serverless.v1.ServerlessService/CountClusters"
	ServerlessService_CheckCloudStoragePermission_FullMethodName = "/global.serverless.v1.ServerlessService/CheckCloudStoragePermission"
	ServerlessService_UpdateAuditLogConfig_FullMethodName        = "/global.serverless.v1.ServerlessService/UpdateAuditLogConfig"
)

// ServerlessServiceClient is the client API for ServerlessService 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 ServerlessServiceClient interface {
	Create(ctx context.Context, in *ServerlessServiceCreateRequest, opts ...grpc.CallOption) (*ServerlessServiceCreateResponse, error)
	Update(ctx context.Context, in *ServerlessServiceUpdateRequest, opts ...grpc.CallOption) (*ServerlessServiceUpdateResponse, error)
	List(ctx context.Context, in *ServerlessServiceListRequest, opts ...grpc.CallOption) (*ServerlessServiceListResponse, error)
	Delete(ctx context.Context, in *ServerlessServiceDeleteRequest, opts ...grpc.CallOption) (*ServerlessServiceDeleteResponse, error)
	GetEncryptedCloudAdminPwd(ctx context.Context, in *ServerlessServiceGetEncryptedCloudAdminPwdRequest, opts ...grpc.CallOption) (*ServerlessServiceGetEncryptedCloudAdminPwdResponse, error)
	CountClusters(ctx context.Context, in *ServerlessServiceCountClustersRequest, opts ...grpc.CallOption) (*ServerlessServiceCountClustersResponse, error)
	// rpc UpdateRootPassword(UpdateRootPasswordRequest) returns(ServerlessServiceUpdateRootPasswordResponse) {}
	// rpc GetProxyEndpoint() returns {}??
	// rpc GetPublicEndpoint(ServerlessServiceGetPublicEndpointRequest) returns (ServerlessServiceGetPublicEndpointResponse) {}
	// rpc GetPrivateEndpoint(ServerlessServiceGetPrivateEndpointRequest) returns (ServerlessServiceGetPrivateEndpointResponse) {}
	// rpc GetPrivateEndpointService(ServerlessServiceGetPrivateEndpointServiceRequest) returns (ServerlessServiceGetPrivateEndpointServiceResponse) {}
	CheckCloudStoragePermission(ctx context.Context, in *CheckCloudStoragePermissionRequest, opts ...grpc.CallOption) (*CheckCloudStoragePermissionResponse, error)
	UpdateAuditLogConfig(ctx context.Context, in *UpdateAuditLogConfigRequest, opts ...grpc.CallOption) (*UpdateAuditLogConfigResponse, error)
}

type serverlessServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewServerlessServiceClient(cc grpc.ClientConnInterface) ServerlessServiceClient {
	return &serverlessServiceClient{cc}
}

func (c *serverlessServiceClient) Create(ctx context.Context, in *ServerlessServiceCreateRequest, opts ...grpc.CallOption) (*ServerlessServiceCreateResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ServerlessServiceCreateResponse)
	err := c.cc.Invoke(ctx, ServerlessService_Create_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessServiceClient) Update(ctx context.Context, in *ServerlessServiceUpdateRequest, opts ...grpc.CallOption) (*ServerlessServiceUpdateResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ServerlessServiceUpdateResponse)
	err := c.cc.Invoke(ctx, ServerlessService_Update_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessServiceClient) List(ctx context.Context, in *ServerlessServiceListRequest, opts ...grpc.CallOption) (*ServerlessServiceListResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ServerlessServiceListResponse)
	err := c.cc.Invoke(ctx, ServerlessService_List_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessServiceClient) Delete(ctx context.Context, in *ServerlessServiceDeleteRequest, opts ...grpc.CallOption) (*ServerlessServiceDeleteResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ServerlessServiceDeleteResponse)
	err := c.cc.Invoke(ctx, ServerlessService_Delete_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessServiceClient) GetEncryptedCloudAdminPwd(ctx context.Context, in *ServerlessServiceGetEncryptedCloudAdminPwdRequest, opts ...grpc.CallOption) (*ServerlessServiceGetEncryptedCloudAdminPwdResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ServerlessServiceGetEncryptedCloudAdminPwdResponse)
	err := c.cc.Invoke(ctx, ServerlessService_GetEncryptedCloudAdminPwd_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessServiceClient) CountClusters(ctx context.Context, in *ServerlessServiceCountClustersRequest, opts ...grpc.CallOption) (*ServerlessServiceCountClustersResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ServerlessServiceCountClustersResponse)
	err := c.cc.Invoke(ctx, ServerlessService_CountClusters_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessServiceClient) 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, ServerlessService_CheckCloudStoragePermission_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessServiceClient) UpdateAuditLogConfig(ctx context.Context, in *UpdateAuditLogConfigRequest, opts ...grpc.CallOption) (*UpdateAuditLogConfigResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(UpdateAuditLogConfigResponse)
	err := c.cc.Invoke(ctx, ServerlessService_UpdateAuditLogConfig_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ServerlessServiceServer is the server API for ServerlessService service.
// All implementations should embed UnimplementedServerlessServiceServer
// for forward compatibility
type ServerlessServiceServer interface {
	Create(context.Context, *ServerlessServiceCreateRequest) (*ServerlessServiceCreateResponse, error)
	Update(context.Context, *ServerlessServiceUpdateRequest) (*ServerlessServiceUpdateResponse, error)
	List(context.Context, *ServerlessServiceListRequest) (*ServerlessServiceListResponse, error)
	Delete(context.Context, *ServerlessServiceDeleteRequest) (*ServerlessServiceDeleteResponse, error)
	GetEncryptedCloudAdminPwd(context.Context, *ServerlessServiceGetEncryptedCloudAdminPwdRequest) (*ServerlessServiceGetEncryptedCloudAdminPwdResponse, error)
	CountClusters(context.Context, *ServerlessServiceCountClustersRequest) (*ServerlessServiceCountClustersResponse, error)
	// rpc UpdateRootPassword(UpdateRootPasswordRequest) returns(ServerlessServiceUpdateRootPasswordResponse) {}
	// rpc GetProxyEndpoint() returns {}??
	// rpc GetPublicEndpoint(ServerlessServiceGetPublicEndpointRequest) returns (ServerlessServiceGetPublicEndpointResponse) {}
	// rpc GetPrivateEndpoint(ServerlessServiceGetPrivateEndpointRequest) returns (ServerlessServiceGetPrivateEndpointResponse) {}
	// rpc GetPrivateEndpointService(ServerlessServiceGetPrivateEndpointServiceRequest) returns (ServerlessServiceGetPrivateEndpointServiceResponse) {}
	CheckCloudStoragePermission(context.Context, *CheckCloudStoragePermissionRequest) (*CheckCloudStoragePermissionResponse, error)
	UpdateAuditLogConfig(context.Context, *UpdateAuditLogConfigRequest) (*UpdateAuditLogConfigResponse, error)
}

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

func (UnimplementedServerlessServiceServer) Create(context.Context, *ServerlessServiceCreateRequest) (*ServerlessServiceCreateResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Create not implemented")
}
func (UnimplementedServerlessServiceServer) Update(context.Context, *ServerlessServiceUpdateRequest) (*ServerlessServiceUpdateResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Update not implemented")
}
func (UnimplementedServerlessServiceServer) List(context.Context, *ServerlessServiceListRequest) (*ServerlessServiceListResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method List not implemented")
}
func (UnimplementedServerlessServiceServer) Delete(context.Context, *ServerlessServiceDeleteRequest) (*ServerlessServiceDeleteResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Delete not implemented")
}
func (UnimplementedServerlessServiceServer) GetEncryptedCloudAdminPwd(context.Context, *ServerlessServiceGetEncryptedCloudAdminPwdRequest) (*ServerlessServiceGetEncryptedCloudAdminPwdResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetEncryptedCloudAdminPwd not implemented")
}
func (UnimplementedServerlessServiceServer) CountClusters(context.Context, *ServerlessServiceCountClustersRequest) (*ServerlessServiceCountClustersResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CountClusters not implemented")
}
func (UnimplementedServerlessServiceServer) CheckCloudStoragePermission(context.Context, *CheckCloudStoragePermissionRequest) (*CheckCloudStoragePermissionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CheckCloudStoragePermission not implemented")
}
func (UnimplementedServerlessServiceServer) UpdateAuditLogConfig(context.Context, *UpdateAuditLogConfigRequest) (*UpdateAuditLogConfigResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateAuditLogConfig not implemented")
}

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

func RegisterServerlessServiceServer(s grpc.ServiceRegistrar, srv ServerlessServiceServer) {
	s.RegisterService(&ServerlessService_ServiceDesc, srv)
}

func _ServerlessService_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ServerlessServiceCreateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessServiceServer).Create(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessService_Create_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessServiceServer).Create(ctx, req.(*ServerlessServiceCreateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessService_Update_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ServerlessServiceUpdateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessServiceServer).Update(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessService_Update_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessServiceServer).Update(ctx, req.(*ServerlessServiceUpdateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ServerlessServiceListRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessServiceServer).List(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessService_List_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessServiceServer).List(ctx, req.(*ServerlessServiceListRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessService_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ServerlessServiceDeleteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessServiceServer).Delete(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessService_Delete_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessServiceServer).Delete(ctx, req.(*ServerlessServiceDeleteRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessService_GetEncryptedCloudAdminPwd_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ServerlessServiceGetEncryptedCloudAdminPwdRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessServiceServer).GetEncryptedCloudAdminPwd(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessService_GetEncryptedCloudAdminPwd_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessServiceServer).GetEncryptedCloudAdminPwd(ctx, req.(*ServerlessServiceGetEncryptedCloudAdminPwdRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessService_CountClusters_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ServerlessServiceCountClustersRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessServiceServer).CountClusters(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessService_CountClusters_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessServiceServer).CountClusters(ctx, req.(*ServerlessServiceCountClustersRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessService_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.(ServerlessServiceServer).CheckCloudStoragePermission(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessService_CheckCloudStoragePermission_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessServiceServer).CheckCloudStoragePermission(ctx, req.(*CheckCloudStoragePermissionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessService_UpdateAuditLogConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateAuditLogConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessServiceServer).UpdateAuditLogConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessService_UpdateAuditLogConfig_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessServiceServer).UpdateAuditLogConfig(ctx, req.(*UpdateAuditLogConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// ServerlessService_ServiceDesc is the grpc.ServiceDesc for ServerlessService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var ServerlessService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "global.serverless.v1.ServerlessService",
	HandlerType: (*ServerlessServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Create",
			Handler:    _ServerlessService_Create_Handler,
		},
		{
			MethodName: "Update",
			Handler:    _ServerlessService_Update_Handler,
		},
		{
			MethodName: "List",
			Handler:    _ServerlessService_List_Handler,
		},
		{
			MethodName: "Delete",
			Handler:    _ServerlessService_Delete_Handler,
		},
		{
			MethodName: "GetEncryptedCloudAdminPwd",
			Handler:    _ServerlessService_GetEncryptedCloudAdminPwd_Handler,
		},
		{
			MethodName: "CountClusters",
			Handler:    _ServerlessService_CountClusters_Handler,
		},
		{
			MethodName: "CheckCloudStoragePermission",
			Handler:    _ServerlessService_CheckCloudStoragePermission_Handler,
		},
		{
			MethodName: "UpdateAuditLogConfig",
			Handler:    _ServerlessService_UpdateAuditLogConfig_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "global/serverless/v1/services.proto",
}

const (
	SqlUserService_ChangeSqlUserPasswd_FullMethodName = "/global.serverless.v1.SqlUserService/ChangeSqlUserPasswd"
	SqlUserService_RotateRootPassword_FullMethodName  = "/global.serverless.v1.SqlUserService/RotateRootPassword"
	SqlUserService_RedeemRootPassword_FullMethodName  = "/global.serverless.v1.SqlUserService/RedeemRootPassword"
	SqlUserService_CreateSqlUser_FullMethodName       = "/global.serverless.v1.SqlUserService/CreateSqlUser"
	SqlUserService_UpdateSqlUser_FullMethodName       = "/global.serverless.v1.SqlUserService/UpdateSqlUser"
	SqlUserService_DeleteSqlUser_FullMethodName       = "/global.serverless.v1.SqlUserService/DeleteSqlUser"
	SqlUserService_GetSqlUser_FullMethodName          = "/global.serverless.v1.SqlUserService/GetSqlUser"
	SqlUserService_IsSqlUserExisting_FullMethodName   = "/global.serverless.v1.SqlUserService/IsSqlUserExisting"
	SqlUserService_CreateSqlRole_FullMethodName       = "/global.serverless.v1.SqlUserService/CreateSqlRole"
	SqlUserService_UpdateSqlRole_FullMethodName       = "/global.serverless.v1.SqlUserService/UpdateSqlRole"
	SqlUserService_ListSqlUsers_FullMethodName        = "/global.serverless.v1.SqlUserService/ListSqlUsers"
)

// SqlUserServiceClient is the client API for SqlUserService 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 SqlUserServiceClient interface {
	ChangeSqlUserPasswd(ctx context.Context, in *ChangeSqlUserPasswdRequest, opts ...grpc.CallOption) (*ChangeSqlUserPasswdResponse, error)
	RotateRootPassword(ctx context.Context, in *RotateRootPasswordRequest, opts ...grpc.CallOption) (*RotateRootPasswordResponse, error)
	RedeemRootPassword(ctx context.Context, in *RedeemRootPasswordRequest, opts ...grpc.CallOption) (*RedeemRootPasswordResponse, error)
	CreateSqlUser(ctx context.Context, in *SqlUserServiceCreateSqlUserRequest, opts ...grpc.CallOption) (*SqlUserServiceCreateSqlUserResponse, error)
	UpdateSqlUser(ctx context.Context, in *SqlUserServiceUpdateSqlUserRequest, opts ...grpc.CallOption) (*SqlUserServiceUpdateSqlUserResponse, error)
	DeleteSqlUser(ctx context.Context, in *SqlUserServiceDeleteSqlUserRequest, opts ...grpc.CallOption) (*SqlUserServiceDeleteSqlUserResponse, error)
	GetSqlUser(ctx context.Context, in *SqlUserServiceGetSqlUserRequest, opts ...grpc.CallOption) (*SqlUserServiceGetSqlUserResponse, error)
	IsSqlUserExisting(ctx context.Context, in *SqlUserServiceIsSqlUserExistingRequest, opts ...grpc.CallOption) (*SqlUserServiceIsSqlUserExistingResponse, error)
	CreateSqlRole(ctx context.Context, in *SqlUserServiceCreateSqlRoleRequest, opts ...grpc.CallOption) (*SqlUserServiceCreateSqlRoleResponse, error)
	UpdateSqlRole(ctx context.Context, in *SqlUserServiceUpdateSqlRoleRequest, opts ...grpc.CallOption) (*SqlUserServiceUpdateSqlRoleResponse, error)
	ListSqlUsers(ctx context.Context, in *ListSqlUsersRequest, opts ...grpc.CallOption) (*ListSqlUsersResponse, error)
}

type sqlUserServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewSqlUserServiceClient(cc grpc.ClientConnInterface) SqlUserServiceClient {
	return &sqlUserServiceClient{cc}
}

func (c *sqlUserServiceClient) ChangeSqlUserPasswd(ctx context.Context, in *ChangeSqlUserPasswdRequest, opts ...grpc.CallOption) (*ChangeSqlUserPasswdResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ChangeSqlUserPasswdResponse)
	err := c.cc.Invoke(ctx, SqlUserService_ChangeSqlUserPasswd_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sqlUserServiceClient) RotateRootPassword(ctx context.Context, in *RotateRootPasswordRequest, opts ...grpc.CallOption) (*RotateRootPasswordResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(RotateRootPasswordResponse)
	err := c.cc.Invoke(ctx, SqlUserService_RotateRootPassword_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sqlUserServiceClient) RedeemRootPassword(ctx context.Context, in *RedeemRootPasswordRequest, opts ...grpc.CallOption) (*RedeemRootPasswordResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(RedeemRootPasswordResponse)
	err := c.cc.Invoke(ctx, SqlUserService_RedeemRootPassword_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sqlUserServiceClient) CreateSqlUser(ctx context.Context, in *SqlUserServiceCreateSqlUserRequest, opts ...grpc.CallOption) (*SqlUserServiceCreateSqlUserResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(SqlUserServiceCreateSqlUserResponse)
	err := c.cc.Invoke(ctx, SqlUserService_CreateSqlUser_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sqlUserServiceClient) UpdateSqlUser(ctx context.Context, in *SqlUserServiceUpdateSqlUserRequest, opts ...grpc.CallOption) (*SqlUserServiceUpdateSqlUserResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(SqlUserServiceUpdateSqlUserResponse)
	err := c.cc.Invoke(ctx, SqlUserService_UpdateSqlUser_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sqlUserServiceClient) DeleteSqlUser(ctx context.Context, in *SqlUserServiceDeleteSqlUserRequest, opts ...grpc.CallOption) (*SqlUserServiceDeleteSqlUserResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(SqlUserServiceDeleteSqlUserResponse)
	err := c.cc.Invoke(ctx, SqlUserService_DeleteSqlUser_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sqlUserServiceClient) GetSqlUser(ctx context.Context, in *SqlUserServiceGetSqlUserRequest, opts ...grpc.CallOption) (*SqlUserServiceGetSqlUserResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(SqlUserServiceGetSqlUserResponse)
	err := c.cc.Invoke(ctx, SqlUserService_GetSqlUser_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sqlUserServiceClient) IsSqlUserExisting(ctx context.Context, in *SqlUserServiceIsSqlUserExistingRequest, opts ...grpc.CallOption) (*SqlUserServiceIsSqlUserExistingResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(SqlUserServiceIsSqlUserExistingResponse)
	err := c.cc.Invoke(ctx, SqlUserService_IsSqlUserExisting_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sqlUserServiceClient) CreateSqlRole(ctx context.Context, in *SqlUserServiceCreateSqlRoleRequest, opts ...grpc.CallOption) (*SqlUserServiceCreateSqlRoleResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(SqlUserServiceCreateSqlRoleResponse)
	err := c.cc.Invoke(ctx, SqlUserService_CreateSqlRole_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sqlUserServiceClient) UpdateSqlRole(ctx context.Context, in *SqlUserServiceUpdateSqlRoleRequest, opts ...grpc.CallOption) (*SqlUserServiceUpdateSqlRoleResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(SqlUserServiceUpdateSqlRoleResponse)
	err := c.cc.Invoke(ctx, SqlUserService_UpdateSqlRole_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sqlUserServiceClient) ListSqlUsers(ctx context.Context, in *ListSqlUsersRequest, opts ...grpc.CallOption) (*ListSqlUsersResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListSqlUsersResponse)
	err := c.cc.Invoke(ctx, SqlUserService_ListSqlUsers_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// SqlUserServiceServer is the server API for SqlUserService service.
// All implementations should embed UnimplementedSqlUserServiceServer
// for forward compatibility
type SqlUserServiceServer interface {
	ChangeSqlUserPasswd(context.Context, *ChangeSqlUserPasswdRequest) (*ChangeSqlUserPasswdResponse, error)
	RotateRootPassword(context.Context, *RotateRootPasswordRequest) (*RotateRootPasswordResponse, error)
	RedeemRootPassword(context.Context, *RedeemRootPasswordRequest) (*RedeemRootPasswordResponse, error)
	CreateSqlUser(context.Context, *SqlUserServiceCreateSqlUserRequest) (*SqlUserServiceCreateSqlUserResponse, error)
	UpdateSqlUser(context.Context, *SqlUserServiceUpdateSqlUserRequest) (*SqlUserServiceUpdateSqlUserResponse, error)
	DeleteSqlUser(context.Context, *SqlUserServiceDeleteSqlUserRequest) (*SqlUserServiceDeleteSqlUserResponse, error)
	GetSqlUser(context.Context, *SqlUserServiceGetSqlUserRequest) (*SqlUserServiceGetSqlUserResponse, error)
	IsSqlUserExisting(context.Context, *SqlUserServiceIsSqlUserExistingRequest) (*SqlUserServiceIsSqlUserExistingResponse, error)
	CreateSqlRole(context.Context, *SqlUserServiceCreateSqlRoleRequest) (*SqlUserServiceCreateSqlRoleResponse, error)
	UpdateSqlRole(context.Context, *SqlUserServiceUpdateSqlRoleRequest) (*SqlUserServiceUpdateSqlRoleResponse, error)
	ListSqlUsers(context.Context, *ListSqlUsersRequest) (*ListSqlUsersResponse, error)
}

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

func (UnimplementedSqlUserServiceServer) ChangeSqlUserPasswd(context.Context, *ChangeSqlUserPasswdRequest) (*ChangeSqlUserPasswdResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ChangeSqlUserPasswd not implemented")
}
func (UnimplementedSqlUserServiceServer) RotateRootPassword(context.Context, *RotateRootPasswordRequest) (*RotateRootPasswordResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RotateRootPassword not implemented")
}
func (UnimplementedSqlUserServiceServer) RedeemRootPassword(context.Context, *RedeemRootPasswordRequest) (*RedeemRootPasswordResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RedeemRootPassword not implemented")
}
func (UnimplementedSqlUserServiceServer) CreateSqlUser(context.Context, *SqlUserServiceCreateSqlUserRequest) (*SqlUserServiceCreateSqlUserResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateSqlUser not implemented")
}
func (UnimplementedSqlUserServiceServer) UpdateSqlUser(context.Context, *SqlUserServiceUpdateSqlUserRequest) (*SqlUserServiceUpdateSqlUserResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateSqlUser not implemented")
}
func (UnimplementedSqlUserServiceServer) DeleteSqlUser(context.Context, *SqlUserServiceDeleteSqlUserRequest) (*SqlUserServiceDeleteSqlUserResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteSqlUser not implemented")
}
func (UnimplementedSqlUserServiceServer) GetSqlUser(context.Context, *SqlUserServiceGetSqlUserRequest) (*SqlUserServiceGetSqlUserResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetSqlUser not implemented")
}
func (UnimplementedSqlUserServiceServer) IsSqlUserExisting(context.Context, *SqlUserServiceIsSqlUserExistingRequest) (*SqlUserServiceIsSqlUserExistingResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method IsSqlUserExisting not implemented")
}
func (UnimplementedSqlUserServiceServer) CreateSqlRole(context.Context, *SqlUserServiceCreateSqlRoleRequest) (*SqlUserServiceCreateSqlRoleResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateSqlRole not implemented")
}
func (UnimplementedSqlUserServiceServer) UpdateSqlRole(context.Context, *SqlUserServiceUpdateSqlRoleRequest) (*SqlUserServiceUpdateSqlRoleResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateSqlRole not implemented")
}
func (UnimplementedSqlUserServiceServer) ListSqlUsers(context.Context, *ListSqlUsersRequest) (*ListSqlUsersResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListSqlUsers not implemented")
}

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

func RegisterSqlUserServiceServer(s grpc.ServiceRegistrar, srv SqlUserServiceServer) {
	s.RegisterService(&SqlUserService_ServiceDesc, srv)
}

func _SqlUserService_ChangeSqlUserPasswd_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ChangeSqlUserPasswdRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SqlUserServiceServer).ChangeSqlUserPasswd(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SqlUserService_ChangeSqlUserPasswd_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SqlUserServiceServer).ChangeSqlUserPasswd(ctx, req.(*ChangeSqlUserPasswdRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SqlUserService_RotateRootPassword_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RotateRootPasswordRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SqlUserServiceServer).RotateRootPassword(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SqlUserService_RotateRootPassword_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SqlUserServiceServer).RotateRootPassword(ctx, req.(*RotateRootPasswordRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SqlUserService_RedeemRootPassword_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RedeemRootPasswordRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SqlUserServiceServer).RedeemRootPassword(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SqlUserService_RedeemRootPassword_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SqlUserServiceServer).RedeemRootPassword(ctx, req.(*RedeemRootPasswordRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SqlUserService_CreateSqlUser_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SqlUserServiceCreateSqlUserRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SqlUserServiceServer).CreateSqlUser(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SqlUserService_CreateSqlUser_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SqlUserServiceServer).CreateSqlUser(ctx, req.(*SqlUserServiceCreateSqlUserRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SqlUserService_UpdateSqlUser_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SqlUserServiceUpdateSqlUserRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SqlUserServiceServer).UpdateSqlUser(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SqlUserService_UpdateSqlUser_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SqlUserServiceServer).UpdateSqlUser(ctx, req.(*SqlUserServiceUpdateSqlUserRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SqlUserService_DeleteSqlUser_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SqlUserServiceDeleteSqlUserRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SqlUserServiceServer).DeleteSqlUser(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SqlUserService_DeleteSqlUser_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SqlUserServiceServer).DeleteSqlUser(ctx, req.(*SqlUserServiceDeleteSqlUserRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SqlUserService_GetSqlUser_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SqlUserServiceGetSqlUserRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SqlUserServiceServer).GetSqlUser(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SqlUserService_GetSqlUser_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SqlUserServiceServer).GetSqlUser(ctx, req.(*SqlUserServiceGetSqlUserRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SqlUserService_IsSqlUserExisting_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SqlUserServiceIsSqlUserExistingRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SqlUserServiceServer).IsSqlUserExisting(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SqlUserService_IsSqlUserExisting_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SqlUserServiceServer).IsSqlUserExisting(ctx, req.(*SqlUserServiceIsSqlUserExistingRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SqlUserService_CreateSqlRole_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SqlUserServiceCreateSqlRoleRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SqlUserServiceServer).CreateSqlRole(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SqlUserService_CreateSqlRole_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SqlUserServiceServer).CreateSqlRole(ctx, req.(*SqlUserServiceCreateSqlRoleRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SqlUserService_UpdateSqlRole_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SqlUserServiceUpdateSqlRoleRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SqlUserServiceServer).UpdateSqlRole(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SqlUserService_UpdateSqlRole_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SqlUserServiceServer).UpdateSqlRole(ctx, req.(*SqlUserServiceUpdateSqlRoleRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SqlUserService_ListSqlUsers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListSqlUsersRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SqlUserServiceServer).ListSqlUsers(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SqlUserService_ListSqlUsers_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SqlUserServiceServer).ListSqlUsers(ctx, req.(*ListSqlUsersRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// SqlUserService_ServiceDesc is the grpc.ServiceDesc for SqlUserService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var SqlUserService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "global.serverless.v1.SqlUserService",
	HandlerType: (*SqlUserServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ChangeSqlUserPasswd",
			Handler:    _SqlUserService_ChangeSqlUserPasswd_Handler,
		},
		{
			MethodName: "RotateRootPassword",
			Handler:    _SqlUserService_RotateRootPassword_Handler,
		},
		{
			MethodName: "RedeemRootPassword",
			Handler:    _SqlUserService_RedeemRootPassword_Handler,
		},
		{
			MethodName: "CreateSqlUser",
			Handler:    _SqlUserService_CreateSqlUser_Handler,
		},
		{
			MethodName: "UpdateSqlUser",
			Handler:    _SqlUserService_UpdateSqlUser_Handler,
		},
		{
			MethodName: "DeleteSqlUser",
			Handler:    _SqlUserService_DeleteSqlUser_Handler,
		},
		{
			MethodName: "GetSqlUser",
			Handler:    _SqlUserService_GetSqlUser_Handler,
		},
		{
			MethodName: "IsSqlUserExisting",
			Handler:    _SqlUserService_IsSqlUserExisting_Handler,
		},
		{
			MethodName: "CreateSqlRole",
			Handler:    _SqlUserService_CreateSqlRole_Handler,
		},
		{
			MethodName: "UpdateSqlRole",
			Handler:    _SqlUserService_UpdateSqlRole_Handler,
		},
		{
			MethodName: "ListSqlUsers",
			Handler:    _SqlUserService_ListSqlUsers_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "global/serverless/v1/services.proto",
}

const (
	CloudProviderService_Register_FullMethodName = "/global.serverless.v1.CloudProviderService/Register"
	CloudProviderService_List_FullMethodName     = "/global.serverless.v1.CloudProviderService/List"
)

// CloudProviderServiceClient is the client API for CloudProviderService 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 CloudProviderServiceClient interface {
	Register(ctx context.Context, in *CloudProviderServiceRegisterRequest, opts ...grpc.CallOption) (*v1.CloudProvider, error)
	List(ctx context.Context, in *CloudProviderServiceListRequest, opts ...grpc.CallOption) (*CloudProviderServiceListResponse, error)
}

type cloudProviderServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewCloudProviderServiceClient(cc grpc.ClientConnInterface) CloudProviderServiceClient {
	return &cloudProviderServiceClient{cc}
}

func (c *cloudProviderServiceClient) Register(ctx context.Context, in *CloudProviderServiceRegisterRequest, opts ...grpc.CallOption) (*v1.CloudProvider, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(v1.CloudProvider)
	err := c.cc.Invoke(ctx, CloudProviderService_Register_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cloudProviderServiceClient) List(ctx context.Context, in *CloudProviderServiceListRequest, opts ...grpc.CallOption) (*CloudProviderServiceListResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CloudProviderServiceListResponse)
	err := c.cc.Invoke(ctx, CloudProviderService_List_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// CloudProviderServiceServer is the server API for CloudProviderService service.
// All implementations should embed UnimplementedCloudProviderServiceServer
// for forward compatibility
type CloudProviderServiceServer interface {
	Register(context.Context, *CloudProviderServiceRegisterRequest) (*v1.CloudProvider, error)
	List(context.Context, *CloudProviderServiceListRequest) (*CloudProviderServiceListResponse, error)
}

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

func (UnimplementedCloudProviderServiceServer) Register(context.Context, *CloudProviderServiceRegisterRequest) (*v1.CloudProvider, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Register not implemented")
}
func (UnimplementedCloudProviderServiceServer) List(context.Context, *CloudProviderServiceListRequest) (*CloudProviderServiceListResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method List not implemented")
}

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

func RegisterCloudProviderServiceServer(s grpc.ServiceRegistrar, srv CloudProviderServiceServer) {
	s.RegisterService(&CloudProviderService_ServiceDesc, srv)
}

func _CloudProviderService_Register_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CloudProviderServiceRegisterRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CloudProviderServiceServer).Register(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CloudProviderService_Register_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CloudProviderServiceServer).Register(ctx, req.(*CloudProviderServiceRegisterRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CloudProviderService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CloudProviderServiceListRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CloudProviderServiceServer).List(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CloudProviderService_List_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CloudProviderServiceServer).List(ctx, req.(*CloudProviderServiceListRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// CloudProviderService_ServiceDesc is the grpc.ServiceDesc for CloudProviderService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var CloudProviderService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "global.serverless.v1.CloudProviderService",
	HandlerType: (*CloudProviderServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Register",
			Handler:    _CloudProviderService_Register_Handler,
		},
		{
			MethodName: "List",
			Handler:    _CloudProviderService_List_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "global/serverless/v1/services.proto",
}

const (
	RegionService_Register_FullMethodName = "/global.serverless.v1.RegionService/Register"
	RegionService_List_FullMethodName     = "/global.serverless.v1.RegionService/List"
	RegionService_Update_FullMethodName   = "/global.serverless.v1.RegionService/Update"
	RegionService_Get_FullMethodName      = "/global.serverless.v1.RegionService/Get"
	RegionService_Delete_FullMethodName   = "/global.serverless.v1.RegionService/Delete"
)

// RegionServiceClient is the client API for RegionService 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 RegionServiceClient interface {
	Register(ctx context.Context, in *RegionServiceRegisterRequest, opts ...grpc.CallOption) (*v1.Region, error)
	List(ctx context.Context, in *RegionServiceListRequest, opts ...grpc.CallOption) (*RegionServiceListResponse, error)
	Update(ctx context.Context, in *RegionServiceUpdateRequest, opts ...grpc.CallOption) (*v1.Region, error)
	Get(ctx context.Context, in *RegionServiceGetRequest, opts ...grpc.CallOption) (*v1.Region, error)
	Delete(ctx context.Context, in *RegionServiceDeleteRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
}

type regionServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewRegionServiceClient(cc grpc.ClientConnInterface) RegionServiceClient {
	return &regionServiceClient{cc}
}

func (c *regionServiceClient) Register(ctx context.Context, in *RegionServiceRegisterRequest, opts ...grpc.CallOption) (*v1.Region, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(v1.Region)
	err := c.cc.Invoke(ctx, RegionService_Register_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *regionServiceClient) List(ctx context.Context, in *RegionServiceListRequest, opts ...grpc.CallOption) (*RegionServiceListResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(RegionServiceListResponse)
	err := c.cc.Invoke(ctx, RegionService_List_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *regionServiceClient) Update(ctx context.Context, in *RegionServiceUpdateRequest, opts ...grpc.CallOption) (*v1.Region, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(v1.Region)
	err := c.cc.Invoke(ctx, RegionService_Update_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *regionServiceClient) Get(ctx context.Context, in *RegionServiceGetRequest, opts ...grpc.CallOption) (*v1.Region, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(v1.Region)
	err := c.cc.Invoke(ctx, RegionService_Get_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *regionServiceClient) Delete(ctx context.Context, in *RegionServiceDeleteRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, RegionService_Delete_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// RegionServiceServer is the server API for RegionService service.
// All implementations should embed UnimplementedRegionServiceServer
// for forward compatibility
type RegionServiceServer interface {
	Register(context.Context, *RegionServiceRegisterRequest) (*v1.Region, error)
	List(context.Context, *RegionServiceListRequest) (*RegionServiceListResponse, error)
	Update(context.Context, *RegionServiceUpdateRequest) (*v1.Region, error)
	Get(context.Context, *RegionServiceGetRequest) (*v1.Region, error)
	Delete(context.Context, *RegionServiceDeleteRequest) (*emptypb.Empty, error)
}

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

func (UnimplementedRegionServiceServer) Register(context.Context, *RegionServiceRegisterRequest) (*v1.Region, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Register not implemented")
}
func (UnimplementedRegionServiceServer) List(context.Context, *RegionServiceListRequest) (*RegionServiceListResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method List not implemented")
}
func (UnimplementedRegionServiceServer) Update(context.Context, *RegionServiceUpdateRequest) (*v1.Region, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Update not implemented")
}
func (UnimplementedRegionServiceServer) Get(context.Context, *RegionServiceGetRequest) (*v1.Region, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Get not implemented")
}
func (UnimplementedRegionServiceServer) Delete(context.Context, *RegionServiceDeleteRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Delete not implemented")
}

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

func RegisterRegionServiceServer(s grpc.ServiceRegistrar, srv RegionServiceServer) {
	s.RegisterService(&RegionService_ServiceDesc, srv)
}

func _RegionService_Register_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RegionServiceRegisterRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RegionServiceServer).Register(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RegionService_Register_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RegionServiceServer).Register(ctx, req.(*RegionServiceRegisterRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RegionService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RegionServiceListRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RegionServiceServer).List(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RegionService_List_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RegionServiceServer).List(ctx, req.(*RegionServiceListRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RegionService_Update_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RegionServiceUpdateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RegionServiceServer).Update(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RegionService_Update_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RegionServiceServer).Update(ctx, req.(*RegionServiceUpdateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RegionService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RegionServiceGetRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RegionServiceServer).Get(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RegionService_Get_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RegionServiceServer).Get(ctx, req.(*RegionServiceGetRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RegionService_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RegionServiceDeleteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RegionServiceServer).Delete(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RegionService_Delete_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RegionServiceServer).Delete(ctx, req.(*RegionServiceDeleteRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// RegionService_ServiceDesc is the grpc.ServiceDesc for RegionService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var RegionService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "global.serverless.v1.RegionService",
	HandlerType: (*RegionServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Register",
			Handler:    _RegionService_Register_Handler,
		},
		{
			MethodName: "List",
			Handler:    _RegionService_List_Handler,
		},
		{
			MethodName: "Update",
			Handler:    _RegionService_Update_Handler,
		},
		{
			MethodName: "Get",
			Handler:    _RegionService_Get_Handler,
		},
		{
			MethodName: "Delete",
			Handler:    _RegionService_Delete_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "global/serverless/v1/services.proto",
}

const (
	ServerlessPGBackupProxyService_CreatePGBackup_FullMethodName       = "/global.serverless.v1.ServerlessPGBackupProxyService/CreatePGBackup"
	ServerlessPGBackupProxyService_ListPGBackups_FullMethodName        = "/global.serverless.v1.ServerlessPGBackupProxyService/ListPGBackups"
	ServerlessPGBackupProxyService_GetPGBackup_FullMethodName          = "/global.serverless.v1.ServerlessPGBackupProxyService/GetPGBackup"
	ServerlessPGBackupProxyService_GetPGBackupPolicy_FullMethodName    = "/global.serverless.v1.ServerlessPGBackupProxyService/GetPGBackupPolicy"
	ServerlessPGBackupProxyService_UpdatePGBackupPolicy_FullMethodName = "/global.serverless.v1.ServerlessPGBackupProxyService/UpdatePGBackupPolicy"
)

// ServerlessPGBackupProxyServiceClient is the client API for ServerlessPGBackupProxyService 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.
//
// ServerlessPGBackupProxyService proxies PostgreSQL backup calls for
// serverless-service workers. It is Sys9-backed in serverless-global-service
// and mirrors the MySQL backup-source calling style.
type ServerlessPGBackupProxyServiceClient interface {
	// Create one on-demand backup.
	CreatePGBackup(ctx context.Context, in *CreatePGBackupRequest, opts ...grpc.CallOption) (*CreatePGBackupResponse, error)
	// List backups after a cursor time with bounded count.
	ListPGBackups(ctx context.Context, in *ListPGBackupsRequest, opts ...grpc.CallOption) (*ListPGBackupsResponse, error)
	// Get one backup by backup id.
	GetPGBackup(ctx context.Context, in *GetPGBackupRequest, opts ...grpc.CallOption) (*GetPGBackupResponse, error)
	// Read backup policy from Sys9.
	GetPGBackupPolicy(ctx context.Context, in *GetPGBackupPolicyRequest, opts ...grpc.CallOption) (*GetPGBackupPolicyResponse, error)
	// Update backup policy in Sys9.
	UpdatePGBackupPolicy(ctx context.Context, in *UpdatePGBackupPolicyRequest, opts ...grpc.CallOption) (*UpdatePGBackupPolicyResponse, error)
}

type serverlessPGBackupProxyServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewServerlessPGBackupProxyServiceClient(cc grpc.ClientConnInterface) ServerlessPGBackupProxyServiceClient {
	return &serverlessPGBackupProxyServiceClient{cc}
}

func (c *serverlessPGBackupProxyServiceClient) CreatePGBackup(ctx context.Context, in *CreatePGBackupRequest, opts ...grpc.CallOption) (*CreatePGBackupResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CreatePGBackupResponse)
	err := c.cc.Invoke(ctx, ServerlessPGBackupProxyService_CreatePGBackup_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessPGBackupProxyServiceClient) ListPGBackups(ctx context.Context, in *ListPGBackupsRequest, opts ...grpc.CallOption) (*ListPGBackupsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListPGBackupsResponse)
	err := c.cc.Invoke(ctx, ServerlessPGBackupProxyService_ListPGBackups_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessPGBackupProxyServiceClient) GetPGBackup(ctx context.Context, in *GetPGBackupRequest, opts ...grpc.CallOption) (*GetPGBackupResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetPGBackupResponse)
	err := c.cc.Invoke(ctx, ServerlessPGBackupProxyService_GetPGBackup_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessPGBackupProxyServiceClient) GetPGBackupPolicy(ctx context.Context, in *GetPGBackupPolicyRequest, opts ...grpc.CallOption) (*GetPGBackupPolicyResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetPGBackupPolicyResponse)
	err := c.cc.Invoke(ctx, ServerlessPGBackupProxyService_GetPGBackupPolicy_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessPGBackupProxyServiceClient) UpdatePGBackupPolicy(ctx context.Context, in *UpdatePGBackupPolicyRequest, opts ...grpc.CallOption) (*UpdatePGBackupPolicyResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(UpdatePGBackupPolicyResponse)
	err := c.cc.Invoke(ctx, ServerlessPGBackupProxyService_UpdatePGBackupPolicy_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ServerlessPGBackupProxyServiceServer is the server API for ServerlessPGBackupProxyService service.
// All implementations should embed UnimplementedServerlessPGBackupProxyServiceServer
// for forward compatibility
//
// ServerlessPGBackupProxyService proxies PostgreSQL backup calls for
// serverless-service workers. It is Sys9-backed in serverless-global-service
// and mirrors the MySQL backup-source calling style.
type ServerlessPGBackupProxyServiceServer interface {
	// Create one on-demand backup.
	CreatePGBackup(context.Context, *CreatePGBackupRequest) (*CreatePGBackupResponse, error)
	// List backups after a cursor time with bounded count.
	ListPGBackups(context.Context, *ListPGBackupsRequest) (*ListPGBackupsResponse, error)
	// Get one backup by backup id.
	GetPGBackup(context.Context, *GetPGBackupRequest) (*GetPGBackupResponse, error)
	// Read backup policy from Sys9.
	GetPGBackupPolicy(context.Context, *GetPGBackupPolicyRequest) (*GetPGBackupPolicyResponse, error)
	// Update backup policy in Sys9.
	UpdatePGBackupPolicy(context.Context, *UpdatePGBackupPolicyRequest) (*UpdatePGBackupPolicyResponse, error)
}

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

func (UnimplementedServerlessPGBackupProxyServiceServer) CreatePGBackup(context.Context, *CreatePGBackupRequest) (*CreatePGBackupResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreatePGBackup not implemented")
}
func (UnimplementedServerlessPGBackupProxyServiceServer) ListPGBackups(context.Context, *ListPGBackupsRequest) (*ListPGBackupsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListPGBackups not implemented")
}
func (UnimplementedServerlessPGBackupProxyServiceServer) GetPGBackup(context.Context, *GetPGBackupRequest) (*GetPGBackupResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetPGBackup not implemented")
}
func (UnimplementedServerlessPGBackupProxyServiceServer) GetPGBackupPolicy(context.Context, *GetPGBackupPolicyRequest) (*GetPGBackupPolicyResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetPGBackupPolicy not implemented")
}
func (UnimplementedServerlessPGBackupProxyServiceServer) UpdatePGBackupPolicy(context.Context, *UpdatePGBackupPolicyRequest) (*UpdatePGBackupPolicyResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdatePGBackupPolicy not implemented")
}

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

func RegisterServerlessPGBackupProxyServiceServer(s grpc.ServiceRegistrar, srv ServerlessPGBackupProxyServiceServer) {
	s.RegisterService(&ServerlessPGBackupProxyService_ServiceDesc, srv)
}

func _ServerlessPGBackupProxyService_CreatePGBackup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreatePGBackupRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessPGBackupProxyServiceServer).CreatePGBackup(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPGBackupProxyService_CreatePGBackup_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPGBackupProxyServiceServer).CreatePGBackup(ctx, req.(*CreatePGBackupRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessPGBackupProxyService_ListPGBackups_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListPGBackupsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessPGBackupProxyServiceServer).ListPGBackups(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPGBackupProxyService_ListPGBackups_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPGBackupProxyServiceServer).ListPGBackups(ctx, req.(*ListPGBackupsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessPGBackupProxyService_GetPGBackup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetPGBackupRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessPGBackupProxyServiceServer).GetPGBackup(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPGBackupProxyService_GetPGBackup_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPGBackupProxyServiceServer).GetPGBackup(ctx, req.(*GetPGBackupRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessPGBackupProxyService_GetPGBackupPolicy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetPGBackupPolicyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessPGBackupProxyServiceServer).GetPGBackupPolicy(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPGBackupProxyService_GetPGBackupPolicy_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPGBackupProxyServiceServer).GetPGBackupPolicy(ctx, req.(*GetPGBackupPolicyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessPGBackupProxyService_UpdatePGBackupPolicy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdatePGBackupPolicyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessPGBackupProxyServiceServer).UpdatePGBackupPolicy(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPGBackupProxyService_UpdatePGBackupPolicy_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPGBackupProxyServiceServer).UpdatePGBackupPolicy(ctx, req.(*UpdatePGBackupPolicyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// ServerlessPGBackupProxyService_ServiceDesc is the grpc.ServiceDesc for ServerlessPGBackupProxyService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var ServerlessPGBackupProxyService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "global.serverless.v1.ServerlessPGBackupProxyService",
	HandlerType: (*ServerlessPGBackupProxyServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreatePGBackup",
			Handler:    _ServerlessPGBackupProxyService_CreatePGBackup_Handler,
		},
		{
			MethodName: "ListPGBackups",
			Handler:    _ServerlessPGBackupProxyService_ListPGBackups_Handler,
		},
		{
			MethodName: "GetPGBackup",
			Handler:    _ServerlessPGBackupProxyService_GetPGBackup_Handler,
		},
		{
			MethodName: "GetPGBackupPolicy",
			Handler:    _ServerlessPGBackupProxyService_GetPGBackupPolicy_Handler,
		},
		{
			MethodName: "UpdatePGBackupPolicy",
			Handler:    _ServerlessPGBackupProxyService_UpdatePGBackupPolicy_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "global/serverless/v1/services.proto",
}

const (
	RegionalServerProxyService_GetDataByIds_FullMethodName = "/global.serverless.v1.RegionalServerProxyService/GetDataByIds"
	RegionalServerProxyService_Delete_FullMethodName       = "/global.serverless.v1.RegionalServerProxyService/Delete"
	RegionalServerProxyService_Set_FullMethodName          = "/global.serverless.v1.RegionalServerProxyService/Set"
	RegionalServerProxyService_BatchSet_FullMethodName     = "/global.serverless.v1.RegionalServerProxyService/BatchSet"
	RegionalServerProxyService_DeleteAll_FullMethodName    = "/global.serverless.v1.RegionalServerProxyService/DeleteAll"
)

// RegionalServerProxyServiceClient is the client API for RegionalServerProxyService 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 RegionalServerProxyServiceClient interface {
	GetDataByIds(ctx context.Context, in *RegionalServerProxyServiceGetDataByIdsRequest, opts ...grpc.CallOption) (*RegionalServerProxyServiceGetDataByIdsResponse, error)
	Delete(ctx context.Context, in *RegionalServerProxyServiceDeleteRequest, opts ...grpc.CallOption) (*RegionalServerProxyServiceDeleteResponse, error)
	Set(ctx context.Context, in *RegionalServerProxyServiceSetRequest, opts ...grpc.CallOption) (*RegionalServerProxyServiceSetResponse, error)
	BatchSet(ctx context.Context, in *RegionalServerProxyServiceBatchSetRequest, opts ...grpc.CallOption) (*RegionalServerProxyServiceBatchSetResponse, error)
	DeleteAll(ctx context.Context, in *RegionalServerProxyServiceDeleteAllRequest, opts ...grpc.CallOption) (*RegionalServerProxyServiceDeleteAllResponse, error)
}

type regionalServerProxyServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewRegionalServerProxyServiceClient(cc grpc.ClientConnInterface) RegionalServerProxyServiceClient {
	return &regionalServerProxyServiceClient{cc}
}

func (c *regionalServerProxyServiceClient) GetDataByIds(ctx context.Context, in *RegionalServerProxyServiceGetDataByIdsRequest, opts ...grpc.CallOption) (*RegionalServerProxyServiceGetDataByIdsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(RegionalServerProxyServiceGetDataByIdsResponse)
	err := c.cc.Invoke(ctx, RegionalServerProxyService_GetDataByIds_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *regionalServerProxyServiceClient) Delete(ctx context.Context, in *RegionalServerProxyServiceDeleteRequest, opts ...grpc.CallOption) (*RegionalServerProxyServiceDeleteResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(RegionalServerProxyServiceDeleteResponse)
	err := c.cc.Invoke(ctx, RegionalServerProxyService_Delete_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *regionalServerProxyServiceClient) Set(ctx context.Context, in *RegionalServerProxyServiceSetRequest, opts ...grpc.CallOption) (*RegionalServerProxyServiceSetResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(RegionalServerProxyServiceSetResponse)
	err := c.cc.Invoke(ctx, RegionalServerProxyService_Set_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *regionalServerProxyServiceClient) BatchSet(ctx context.Context, in *RegionalServerProxyServiceBatchSetRequest, opts ...grpc.CallOption) (*RegionalServerProxyServiceBatchSetResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(RegionalServerProxyServiceBatchSetResponse)
	err := c.cc.Invoke(ctx, RegionalServerProxyService_BatchSet_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *regionalServerProxyServiceClient) DeleteAll(ctx context.Context, in *RegionalServerProxyServiceDeleteAllRequest, opts ...grpc.CallOption) (*RegionalServerProxyServiceDeleteAllResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(RegionalServerProxyServiceDeleteAllResponse)
	err := c.cc.Invoke(ctx, RegionalServerProxyService_DeleteAll_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// RegionalServerProxyServiceServer is the server API for RegionalServerProxyService service.
// All implementations should embed UnimplementedRegionalServerProxyServiceServer
// for forward compatibility
type RegionalServerProxyServiceServer interface {
	GetDataByIds(context.Context, *RegionalServerProxyServiceGetDataByIdsRequest) (*RegionalServerProxyServiceGetDataByIdsResponse, error)
	Delete(context.Context, *RegionalServerProxyServiceDeleteRequest) (*RegionalServerProxyServiceDeleteResponse, error)
	Set(context.Context, *RegionalServerProxyServiceSetRequest) (*RegionalServerProxyServiceSetResponse, error)
	BatchSet(context.Context, *RegionalServerProxyServiceBatchSetRequest) (*RegionalServerProxyServiceBatchSetResponse, error)
	DeleteAll(context.Context, *RegionalServerProxyServiceDeleteAllRequest) (*RegionalServerProxyServiceDeleteAllResponse, error)
}

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

func (UnimplementedRegionalServerProxyServiceServer) GetDataByIds(context.Context, *RegionalServerProxyServiceGetDataByIdsRequest) (*RegionalServerProxyServiceGetDataByIdsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetDataByIds not implemented")
}
func (UnimplementedRegionalServerProxyServiceServer) Delete(context.Context, *RegionalServerProxyServiceDeleteRequest) (*RegionalServerProxyServiceDeleteResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Delete not implemented")
}
func (UnimplementedRegionalServerProxyServiceServer) Set(context.Context, *RegionalServerProxyServiceSetRequest) (*RegionalServerProxyServiceSetResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Set not implemented")
}
func (UnimplementedRegionalServerProxyServiceServer) BatchSet(context.Context, *RegionalServerProxyServiceBatchSetRequest) (*RegionalServerProxyServiceBatchSetResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BatchSet not implemented")
}
func (UnimplementedRegionalServerProxyServiceServer) DeleteAll(context.Context, *RegionalServerProxyServiceDeleteAllRequest) (*RegionalServerProxyServiceDeleteAllResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteAll not implemented")
}

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

func RegisterRegionalServerProxyServiceServer(s grpc.ServiceRegistrar, srv RegionalServerProxyServiceServer) {
	s.RegisterService(&RegionalServerProxyService_ServiceDesc, srv)
}

func _RegionalServerProxyService_GetDataByIds_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RegionalServerProxyServiceGetDataByIdsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RegionalServerProxyServiceServer).GetDataByIds(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RegionalServerProxyService_GetDataByIds_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RegionalServerProxyServiceServer).GetDataByIds(ctx, req.(*RegionalServerProxyServiceGetDataByIdsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RegionalServerProxyService_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RegionalServerProxyServiceDeleteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RegionalServerProxyServiceServer).Delete(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RegionalServerProxyService_Delete_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RegionalServerProxyServiceServer).Delete(ctx, req.(*RegionalServerProxyServiceDeleteRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RegionalServerProxyService_Set_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RegionalServerProxyServiceSetRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RegionalServerProxyServiceServer).Set(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RegionalServerProxyService_Set_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RegionalServerProxyServiceServer).Set(ctx, req.(*RegionalServerProxyServiceSetRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RegionalServerProxyService_BatchSet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RegionalServerProxyServiceBatchSetRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RegionalServerProxyServiceServer).BatchSet(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RegionalServerProxyService_BatchSet_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RegionalServerProxyServiceServer).BatchSet(ctx, req.(*RegionalServerProxyServiceBatchSetRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RegionalServerProxyService_DeleteAll_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RegionalServerProxyServiceDeleteAllRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RegionalServerProxyServiceServer).DeleteAll(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RegionalServerProxyService_DeleteAll_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RegionalServerProxyServiceServer).DeleteAll(ctx, req.(*RegionalServerProxyServiceDeleteAllRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// RegionalServerProxyService_ServiceDesc is the grpc.ServiceDesc for RegionalServerProxyService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var RegionalServerProxyService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "global.serverless.v1.RegionalServerProxyService",
	HandlerType: (*RegionalServerProxyServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetDataByIds",
			Handler:    _RegionalServerProxyService_GetDataByIds_Handler,
		},
		{
			MethodName: "Delete",
			Handler:    _RegionalServerProxyService_Delete_Handler,
		},
		{
			MethodName: "Set",
			Handler:    _RegionalServerProxyService_Set_Handler,
		},
		{
			MethodName: "BatchSet",
			Handler:    _RegionalServerProxyService_BatchSet_Handler,
		},
		{
			MethodName: "DeleteAll",
			Handler:    _RegionalServerProxyService_DeleteAll_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "global/serverless/v1/services.proto",
}

const (
	ServerlessImportService_CheckImportPermission_FullMethodName = "/global.serverless.v1.ServerlessImportService/CheckImportPermission"
	ServerlessImportService_Precheck_FullMethodName              = "/global.serverless.v1.ServerlessImportService/Precheck"
)

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

type serverlessImportServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewServerlessImportServiceClient(cc grpc.ClientConnInterface) ServerlessImportServiceClient {
	return &serverlessImportServiceClient{cc}
}

func (c *serverlessImportServiceClient) 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, ServerlessImportService_CheckImportPermission_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessImportServiceClient) 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, ServerlessImportService_Precheck_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

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

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

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

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

func RegisterServerlessImportServiceServer(s grpc.ServiceRegistrar, srv ServerlessImportServiceServer) {
	s.RegisterService(&ServerlessImportService_ServiceDesc, srv)
}

func _ServerlessImportService_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.(ServerlessImportServiceServer).CheckImportPermission(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessImportService_CheckImportPermission_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessImportServiceServer).CheckImportPermission(ctx, req.(*CheckImportPermissionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessImportService_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.(ServerlessImportServiceServer).Precheck(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessImportService_Precheck_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessImportServiceServer).Precheck(ctx, req.(*PrecheckRequest))
	}
	return interceptor(ctx, in, info, handler)
}

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

const (
	ServerlessDMService_Precheck_FullMethodName                  = "/global.serverless.v1.ServerlessDMService/Precheck"
	ServerlessDMService_CreateVpcEndpoint_FullMethodName         = "/global.serverless.v1.ServerlessDMService/CreateVpcEndpoint"
	ServerlessDMService_DescribeVpcEndpoint_FullMethodName       = "/global.serverless.v1.ServerlessDMService/DescribeVpcEndpoint"
	ServerlessDMService_DeleteVpcEndpoint_FullMethodName         = "/global.serverless.v1.ServerlessDMService/DeleteVpcEndpoint"
	ServerlessDMService_ListVpcEndpointZones_FullMethodName      = "/global.serverless.v1.ServerlessDMService/ListVpcEndpointZones"
	ServerlessDMService_RemoveZoneFromVpcEndpoint_FullMethodName = "/global.serverless.v1.ServerlessDMService/RemoveZoneFromVpcEndpoint"
)

// ServerlessDMServiceClient is the client API for ServerlessDMService 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 ServerlessDMServiceClient interface {
	Precheck(ctx context.Context, in *ServerlessDMServicePrecheckRequest, opts ...grpc.CallOption) (*ServerlessDMServicePrecheckResponse, 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) (*emptypb.Empty, error)
	ListVpcEndpointZones(ctx context.Context, in *ListVpcEndpointZonesRequest, opts ...grpc.CallOption) (*ListVpcEndpointZonesResponse, error)
	RemoveZoneFromVpcEndpoint(ctx context.Context, in *RemoveZoneFromVpcEndpointRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
}

type serverlessDMServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewServerlessDMServiceClient(cc grpc.ClientConnInterface) ServerlessDMServiceClient {
	return &serverlessDMServiceClient{cc}
}

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

func (c *serverlessDMServiceClient) 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, ServerlessDMService_CreateVpcEndpoint_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessDMServiceClient) 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, ServerlessDMService_DescribeVpcEndpoint_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

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

func (c *serverlessDMServiceClient) 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, ServerlessDMService_ListVpcEndpointZones_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

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

// ServerlessDMServiceServer is the server API for ServerlessDMService service.
// All implementations should embed UnimplementedServerlessDMServiceServer
// for forward compatibility
type ServerlessDMServiceServer interface {
	Precheck(context.Context, *ServerlessDMServicePrecheckRequest) (*ServerlessDMServicePrecheckResponse, error)
	CreateVpcEndpoint(context.Context, *CreateVpcEndpointRequest) (*CreateVpcEndpointResponse, error)
	DescribeVpcEndpoint(context.Context, *DescribeVpcEndpointRequest) (*DescribeVpcEndpointResponse, error)
	DeleteVpcEndpoint(context.Context, *DeleteVpcEndpointRequest) (*emptypb.Empty, error)
	ListVpcEndpointZones(context.Context, *ListVpcEndpointZonesRequest) (*ListVpcEndpointZonesResponse, error)
	RemoveZoneFromVpcEndpoint(context.Context, *RemoveZoneFromVpcEndpointRequest) (*emptypb.Empty, error)
}

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

func (UnimplementedServerlessDMServiceServer) Precheck(context.Context, *ServerlessDMServicePrecheckRequest) (*ServerlessDMServicePrecheckResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Precheck not implemented")
}
func (UnimplementedServerlessDMServiceServer) CreateVpcEndpoint(context.Context, *CreateVpcEndpointRequest) (*CreateVpcEndpointResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateVpcEndpoint not implemented")
}
func (UnimplementedServerlessDMServiceServer) DescribeVpcEndpoint(context.Context, *DescribeVpcEndpointRequest) (*DescribeVpcEndpointResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DescribeVpcEndpoint not implemented")
}
func (UnimplementedServerlessDMServiceServer) DeleteVpcEndpoint(context.Context, *DeleteVpcEndpointRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteVpcEndpoint not implemented")
}
func (UnimplementedServerlessDMServiceServer) ListVpcEndpointZones(context.Context, *ListVpcEndpointZonesRequest) (*ListVpcEndpointZonesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListVpcEndpointZones not implemented")
}
func (UnimplementedServerlessDMServiceServer) RemoveZoneFromVpcEndpoint(context.Context, *RemoveZoneFromVpcEndpointRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RemoveZoneFromVpcEndpoint not implemented")
}

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

func RegisterServerlessDMServiceServer(s grpc.ServiceRegistrar, srv ServerlessDMServiceServer) {
	s.RegisterService(&ServerlessDMService_ServiceDesc, srv)
}

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

func _ServerlessDMService_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.(ServerlessDMServiceServer).CreateVpcEndpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessDMService_CreateVpcEndpoint_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessDMServiceServer).CreateVpcEndpoint(ctx, req.(*CreateVpcEndpointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessDMService_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.(ServerlessDMServiceServer).DescribeVpcEndpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessDMService_DescribeVpcEndpoint_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessDMServiceServer).DescribeVpcEndpoint(ctx, req.(*DescribeVpcEndpointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessDMService_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.(ServerlessDMServiceServer).DeleteVpcEndpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessDMService_DeleteVpcEndpoint_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessDMServiceServer).DeleteVpcEndpoint(ctx, req.(*DeleteVpcEndpointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessDMService_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.(ServerlessDMServiceServer).ListVpcEndpointZones(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessDMService_ListVpcEndpointZones_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessDMServiceServer).ListVpcEndpointZones(ctx, req.(*ListVpcEndpointZonesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessDMService_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.(ServerlessDMServiceServer).RemoveZoneFromVpcEndpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessDMService_RemoveZoneFromVpcEndpoint_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessDMServiceServer).RemoveZoneFromVpcEndpoint(ctx, req.(*RemoveZoneFromVpcEndpointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// ServerlessDMService_ServiceDesc is the grpc.ServiceDesc for ServerlessDMService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var ServerlessDMService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "global.serverless.v1.ServerlessDMService",
	HandlerType: (*ServerlessDMServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Precheck",
			Handler:    _ServerlessDMService_Precheck_Handler,
		},
		{
			MethodName: "CreateVpcEndpoint",
			Handler:    _ServerlessDMService_CreateVpcEndpoint_Handler,
		},
		{
			MethodName: "DescribeVpcEndpoint",
			Handler:    _ServerlessDMService_DescribeVpcEndpoint_Handler,
		},
		{
			MethodName: "DeleteVpcEndpoint",
			Handler:    _ServerlessDMService_DeleteVpcEndpoint_Handler,
		},
		{
			MethodName: "ListVpcEndpointZones",
			Handler:    _ServerlessDMService_ListVpcEndpointZones_Handler,
		},
		{
			MethodName: "RemoveZoneFromVpcEndpoint",
			Handler:    _ServerlessDMService_RemoveZoneFromVpcEndpoint_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "global/serverless/v1/services.proto",
}

const (
	ServerlessPrivateLinkConnectionService_CreateAWSVpcEndpoint_FullMethodName                      = "/global.serverless.v1.ServerlessPrivateLinkConnectionService/CreateAWSVpcEndpoint"
	ServerlessPrivateLinkConnectionService_DescribeAWSVpcEndpoint_FullMethodName                    = "/global.serverless.v1.ServerlessPrivateLinkConnectionService/DescribeAWSVpcEndpoint"
	ServerlessPrivateLinkConnectionService_DeleteAWSVpcEndpoint_FullMethodName                      = "/global.serverless.v1.ServerlessPrivateLinkConnectionService/DeleteAWSVpcEndpoint"
	ServerlessPrivateLinkConnectionService_CreateAliCloudVpcEndpoint_FullMethodName                 = "/global.serverless.v1.ServerlessPrivateLinkConnectionService/CreateAliCloudVpcEndpoint"
	ServerlessPrivateLinkConnectionService_DescribeAliCloudVpcEndpoint_FullMethodName               = "/global.serverless.v1.ServerlessPrivateLinkConnectionService/DescribeAliCloudVpcEndpoint"
	ServerlessPrivateLinkConnectionService_DeleteAliCloudVpcEndpoint_FullMethodName                 = "/global.serverless.v1.ServerlessPrivateLinkConnectionService/DeleteAliCloudVpcEndpoint"
	ServerlessPrivateLinkConnectionService_GetZoneIds_FullMethodName                                = "/global.serverless.v1.ServerlessPrivateLinkConnectionService/GetZoneIds"
	ServerlessPrivateLinkConnectionService_ListAliCloudVpcEndpointZones_FullMethodName              = "/global.serverless.v1.ServerlessPrivateLinkConnectionService/ListAliCloudVpcEndpointZones"
	ServerlessPrivateLinkConnectionService_RemoveAliCloudZoneFromVpcEndpoint_FullMethodName         = "/global.serverless.v1.ServerlessPrivateLinkConnectionService/RemoveAliCloudZoneFromVpcEndpoint"
	ServerlessPrivateLinkConnectionService_CreateAliCloudDNSRecord_FullMethodName                   = "/global.serverless.v1.ServerlessPrivateLinkConnectionService/CreateAliCloudDNSRecord"
	ServerlessPrivateLinkConnectionService_DeleteAliCloudDNSRecord_FullMethodName                   = "/global.serverless.v1.ServerlessPrivateLinkConnectionService/DeleteAliCloudDNSRecord"
	ServerlessPrivateLinkConnectionService_CreateAWSRoute53Records_FullMethodName                   = "/global.serverless.v1.ServerlessPrivateLinkConnectionService/CreateAWSRoute53Records"
	ServerlessPrivateLinkConnectionService_DeleteAWSRoute53Records_FullMethodName                   = "/global.serverless.v1.ServerlessPrivateLinkConnectionService/DeleteAWSRoute53Records"
	ServerlessPrivateLinkConnectionService_GetAWSRoute53Change_FullMethodName                       = "/global.serverless.v1.ServerlessPrivateLinkConnectionService/GetAWSRoute53Change"
	ServerlessPrivateLinkConnectionService_CreateAWSRoute53PrivateHostedZone_FullMethodName         = "/global.serverless.v1.ServerlessPrivateLinkConnectionService/CreateAWSRoute53PrivateHostedZone"
	ServerlessPrivateLinkConnectionService_DeleteAWSRoute53PrivateHostedZone_FullMethodName         = "/global.serverless.v1.ServerlessPrivateLinkConnectionService/DeleteAWSRoute53PrivateHostedZone"
	ServerlessPrivateLinkConnectionService_CreateAliCloudDNSPrivateHostedZone_FullMethodName        = "/global.serverless.v1.ServerlessPrivateLinkConnectionService/CreateAliCloudDNSPrivateHostedZone"
	ServerlessPrivateLinkConnectionService_DeleteAliCloudDNSPrivateHostedZone_FullMethodName        = "/global.serverless.v1.ServerlessPrivateLinkConnectionService/DeleteAliCloudDNSPrivateHostedZone"
	ServerlessPrivateLinkConnectionService_AttachVpcToAliCloudDNSPrivateHostedZone_FullMethodName   = "/global.serverless.v1.ServerlessPrivateLinkConnectionService/AttachVpcToAliCloudDNSPrivateHostedZone"
	ServerlessPrivateLinkConnectionService_DetachVpcFromAliCloudDNSPrivateHostedZone_FullMethodName = "/global.serverless.v1.ServerlessPrivateLinkConnectionService/DetachVpcFromAliCloudDNSPrivateHostedZone"
	ServerlessPrivateLinkConnectionService_CreateMSKVPCConnection_FullMethodName                    = "/global.serverless.v1.ServerlessPrivateLinkConnectionService/CreateMSKVPCConnection"
	ServerlessPrivateLinkConnectionService_DeleteMSKVPCConnection_FullMethodName                    = "/global.serverless.v1.ServerlessPrivateLinkConnectionService/DeleteMSKVPCConnection"
	ServerlessPrivateLinkConnectionService_GetMSKVPCConnection_FullMethodName                       = "/global.serverless.v1.ServerlessPrivateLinkConnectionService/GetMSKVPCConnection"
)

// ServerlessPrivateLinkConnectionServiceClient is the client API for ServerlessPrivateLinkConnectionService 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 ServerlessPrivateLinkConnectionServiceClient 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) (*emptypb.Empty, 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) (*emptypb.Empty, error)
	GetZoneIds(ctx context.Context, in *GetZoneIdsRequest, opts ...grpc.CallOption) (*GetZoneIdsResponse, error)
	ListAliCloudVpcEndpointZones(ctx context.Context, in *ListAliCloudVpcEndpointZonesRequest, opts ...grpc.CallOption) (*ListAliCloudVpcEndpointZonesResponse, error)
	RemoveAliCloudZoneFromVpcEndpoint(ctx context.Context, in *RemoveAliCloudZoneFromVpcEndpointRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	CreateAliCloudDNSRecord(ctx context.Context, in *CreateAliCloudDNSRecordRequest, opts ...grpc.CallOption) (*CreateAliCloudDNSRecordResponse, error)
	DeleteAliCloudDNSRecord(ctx context.Context, in *DeleteAliCloudDNSRecordRequest, opts ...grpc.CallOption) (*emptypb.Empty, 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 serverlessPrivateLinkConnectionServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewServerlessPrivateLinkConnectionServiceClient(cc grpc.ClientConnInterface) ServerlessPrivateLinkConnectionServiceClient {
	return &serverlessPrivateLinkConnectionServiceClient{cc}
}

func (c *serverlessPrivateLinkConnectionServiceClient) 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, ServerlessPrivateLinkConnectionService_CreateAWSVpcEndpoint_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessPrivateLinkConnectionServiceClient) 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, ServerlessPrivateLinkConnectionService_DescribeAWSVpcEndpoint_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

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

func (c *serverlessPrivateLinkConnectionServiceClient) 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, ServerlessPrivateLinkConnectionService_CreateAliCloudVpcEndpoint_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessPrivateLinkConnectionServiceClient) 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, ServerlessPrivateLinkConnectionService_DescribeAliCloudVpcEndpoint_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

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

func (c *serverlessPrivateLinkConnectionServiceClient) 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, ServerlessPrivateLinkConnectionService_GetZoneIds_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessPrivateLinkConnectionServiceClient) 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, ServerlessPrivateLinkConnectionService_ListAliCloudVpcEndpointZones_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

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

func (c *serverlessPrivateLinkConnectionServiceClient) 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, ServerlessPrivateLinkConnectionService_CreateAliCloudDNSRecord_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

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

func (c *serverlessPrivateLinkConnectionServiceClient) 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, ServerlessPrivateLinkConnectionService_CreateAWSRoute53Records_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessPrivateLinkConnectionServiceClient) 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, ServerlessPrivateLinkConnectionService_DeleteAWSRoute53Records_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessPrivateLinkConnectionServiceClient) 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, ServerlessPrivateLinkConnectionService_GetAWSRoute53Change_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessPrivateLinkConnectionServiceClient) 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, ServerlessPrivateLinkConnectionService_CreateAWSRoute53PrivateHostedZone_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessPrivateLinkConnectionServiceClient) 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, ServerlessPrivateLinkConnectionService_DeleteAWSRoute53PrivateHostedZone_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessPrivateLinkConnectionServiceClient) 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, ServerlessPrivateLinkConnectionService_CreateAliCloudDNSPrivateHostedZone_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessPrivateLinkConnectionServiceClient) 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, ServerlessPrivateLinkConnectionService_DeleteAliCloudDNSPrivateHostedZone_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessPrivateLinkConnectionServiceClient) 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, ServerlessPrivateLinkConnectionService_AttachVpcToAliCloudDNSPrivateHostedZone_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessPrivateLinkConnectionServiceClient) 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, ServerlessPrivateLinkConnectionService_DetachVpcFromAliCloudDNSPrivateHostedZone_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessPrivateLinkConnectionServiceClient) 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, ServerlessPrivateLinkConnectionService_CreateMSKVPCConnection_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessPrivateLinkConnectionServiceClient) 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, ServerlessPrivateLinkConnectionService_DeleteMSKVPCConnection_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessPrivateLinkConnectionServiceClient) 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, ServerlessPrivateLinkConnectionService_GetMSKVPCConnection_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ServerlessPrivateLinkConnectionServiceServer is the server API for ServerlessPrivateLinkConnectionService service.
// All implementations should embed UnimplementedServerlessPrivateLinkConnectionServiceServer
// for forward compatibility
type ServerlessPrivateLinkConnectionServiceServer interface {
	CreateAWSVpcEndpoint(context.Context, *CreateAWSVpcEndpointRequest) (*CreateAWSVpcEndpointResponse, error)
	DescribeAWSVpcEndpoint(context.Context, *DescribeAWSVpcEndpointRequest) (*DescribeAWSVpcEndpointResponse, error)
	DeleteAWSVpcEndpoint(context.Context, *DeleteAWSVpcEndpointRequest) (*emptypb.Empty, error)
	CreateAliCloudVpcEndpoint(context.Context, *CreateAliCloudVpcEndpointRequest) (*CreateAliCloudVpcEndpointResponse, error)
	DescribeAliCloudVpcEndpoint(context.Context, *DescribeAliCloudVpcEndpointRequest) (*DescribeAliCloudVpcEndpointResponse, error)
	DeleteAliCloudVpcEndpoint(context.Context, *DeleteAliCloudVpcEndpointRequest) (*emptypb.Empty, error)
	GetZoneIds(context.Context, *GetZoneIdsRequest) (*GetZoneIdsResponse, error)
	ListAliCloudVpcEndpointZones(context.Context, *ListAliCloudVpcEndpointZonesRequest) (*ListAliCloudVpcEndpointZonesResponse, error)
	RemoveAliCloudZoneFromVpcEndpoint(context.Context, *RemoveAliCloudZoneFromVpcEndpointRequest) (*emptypb.Empty, error)
	CreateAliCloudDNSRecord(context.Context, *CreateAliCloudDNSRecordRequest) (*CreateAliCloudDNSRecordResponse, error)
	DeleteAliCloudDNSRecord(context.Context, *DeleteAliCloudDNSRecordRequest) (*emptypb.Empty, 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)
}

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

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

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

func RegisterServerlessPrivateLinkConnectionServiceServer(s grpc.ServiceRegistrar, srv ServerlessPrivateLinkConnectionServiceServer) {
	s.RegisterService(&ServerlessPrivateLinkConnectionService_ServiceDesc, srv)
}

func _ServerlessPrivateLinkConnectionService_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.(ServerlessPrivateLinkConnectionServiceServer).CreateAWSVpcEndpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPrivateLinkConnectionService_CreateAWSVpcEndpoint_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPrivateLinkConnectionServiceServer).CreateAWSVpcEndpoint(ctx, req.(*CreateAWSVpcEndpointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessPrivateLinkConnectionService_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.(ServerlessPrivateLinkConnectionServiceServer).DescribeAWSVpcEndpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPrivateLinkConnectionService_DescribeAWSVpcEndpoint_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPrivateLinkConnectionServiceServer).DescribeAWSVpcEndpoint(ctx, req.(*DescribeAWSVpcEndpointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessPrivateLinkConnectionService_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.(ServerlessPrivateLinkConnectionServiceServer).DeleteAWSVpcEndpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPrivateLinkConnectionService_DeleteAWSVpcEndpoint_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPrivateLinkConnectionServiceServer).DeleteAWSVpcEndpoint(ctx, req.(*DeleteAWSVpcEndpointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessPrivateLinkConnectionService_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.(ServerlessPrivateLinkConnectionServiceServer).CreateAliCloudVpcEndpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPrivateLinkConnectionService_CreateAliCloudVpcEndpoint_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPrivateLinkConnectionServiceServer).CreateAliCloudVpcEndpoint(ctx, req.(*CreateAliCloudVpcEndpointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessPrivateLinkConnectionService_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.(ServerlessPrivateLinkConnectionServiceServer).DescribeAliCloudVpcEndpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPrivateLinkConnectionService_DescribeAliCloudVpcEndpoint_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPrivateLinkConnectionServiceServer).DescribeAliCloudVpcEndpoint(ctx, req.(*DescribeAliCloudVpcEndpointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessPrivateLinkConnectionService_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.(ServerlessPrivateLinkConnectionServiceServer).DeleteAliCloudVpcEndpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPrivateLinkConnectionService_DeleteAliCloudVpcEndpoint_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPrivateLinkConnectionServiceServer).DeleteAliCloudVpcEndpoint(ctx, req.(*DeleteAliCloudVpcEndpointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessPrivateLinkConnectionService_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.(ServerlessPrivateLinkConnectionServiceServer).GetZoneIds(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPrivateLinkConnectionService_GetZoneIds_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPrivateLinkConnectionServiceServer).GetZoneIds(ctx, req.(*GetZoneIdsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessPrivateLinkConnectionService_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.(ServerlessPrivateLinkConnectionServiceServer).ListAliCloudVpcEndpointZones(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPrivateLinkConnectionService_ListAliCloudVpcEndpointZones_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPrivateLinkConnectionServiceServer).ListAliCloudVpcEndpointZones(ctx, req.(*ListAliCloudVpcEndpointZonesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessPrivateLinkConnectionService_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.(ServerlessPrivateLinkConnectionServiceServer).RemoveAliCloudZoneFromVpcEndpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPrivateLinkConnectionService_RemoveAliCloudZoneFromVpcEndpoint_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPrivateLinkConnectionServiceServer).RemoveAliCloudZoneFromVpcEndpoint(ctx, req.(*RemoveAliCloudZoneFromVpcEndpointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessPrivateLinkConnectionService_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.(ServerlessPrivateLinkConnectionServiceServer).CreateAliCloudDNSRecord(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPrivateLinkConnectionService_CreateAliCloudDNSRecord_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPrivateLinkConnectionServiceServer).CreateAliCloudDNSRecord(ctx, req.(*CreateAliCloudDNSRecordRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessPrivateLinkConnectionService_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.(ServerlessPrivateLinkConnectionServiceServer).DeleteAliCloudDNSRecord(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPrivateLinkConnectionService_DeleteAliCloudDNSRecord_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPrivateLinkConnectionServiceServer).DeleteAliCloudDNSRecord(ctx, req.(*DeleteAliCloudDNSRecordRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessPrivateLinkConnectionService_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.(ServerlessPrivateLinkConnectionServiceServer).CreateAWSRoute53Records(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPrivateLinkConnectionService_CreateAWSRoute53Records_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPrivateLinkConnectionServiceServer).CreateAWSRoute53Records(ctx, req.(*CreateAWSRoute53RecordsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessPrivateLinkConnectionService_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.(ServerlessPrivateLinkConnectionServiceServer).DeleteAWSRoute53Records(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPrivateLinkConnectionService_DeleteAWSRoute53Records_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPrivateLinkConnectionServiceServer).DeleteAWSRoute53Records(ctx, req.(*DeleteAWSRoute53RecordsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessPrivateLinkConnectionService_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.(ServerlessPrivateLinkConnectionServiceServer).GetAWSRoute53Change(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPrivateLinkConnectionService_GetAWSRoute53Change_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPrivateLinkConnectionServiceServer).GetAWSRoute53Change(ctx, req.(*GetAWSRoute53ChangeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessPrivateLinkConnectionService_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.(ServerlessPrivateLinkConnectionServiceServer).CreateAWSRoute53PrivateHostedZone(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPrivateLinkConnectionService_CreateAWSRoute53PrivateHostedZone_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPrivateLinkConnectionServiceServer).CreateAWSRoute53PrivateHostedZone(ctx, req.(*CreateAWSRoute53PrivateHostedZoneRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessPrivateLinkConnectionService_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.(ServerlessPrivateLinkConnectionServiceServer).DeleteAWSRoute53PrivateHostedZone(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPrivateLinkConnectionService_DeleteAWSRoute53PrivateHostedZone_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPrivateLinkConnectionServiceServer).DeleteAWSRoute53PrivateHostedZone(ctx, req.(*DeleteAWSRoute53PrivateHostedZoneRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessPrivateLinkConnectionService_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.(ServerlessPrivateLinkConnectionServiceServer).CreateAliCloudDNSPrivateHostedZone(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPrivateLinkConnectionService_CreateAliCloudDNSPrivateHostedZone_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPrivateLinkConnectionServiceServer).CreateAliCloudDNSPrivateHostedZone(ctx, req.(*CreateAliCloudDNSPrivateHostedZoneRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessPrivateLinkConnectionService_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.(ServerlessPrivateLinkConnectionServiceServer).DeleteAliCloudDNSPrivateHostedZone(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPrivateLinkConnectionService_DeleteAliCloudDNSPrivateHostedZone_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPrivateLinkConnectionServiceServer).DeleteAliCloudDNSPrivateHostedZone(ctx, req.(*DeleteAliCloudDNSPrivateHostedZoneRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessPrivateLinkConnectionService_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.(ServerlessPrivateLinkConnectionServiceServer).AttachVpcToAliCloudDNSPrivateHostedZone(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPrivateLinkConnectionService_AttachVpcToAliCloudDNSPrivateHostedZone_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPrivateLinkConnectionServiceServer).AttachVpcToAliCloudDNSPrivateHostedZone(ctx, req.(*AttachVpcToAliCloudDNSPrivateHostedZoneRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessPrivateLinkConnectionService_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.(ServerlessPrivateLinkConnectionServiceServer).DetachVpcFromAliCloudDNSPrivateHostedZone(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPrivateLinkConnectionService_DetachVpcFromAliCloudDNSPrivateHostedZone_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPrivateLinkConnectionServiceServer).DetachVpcFromAliCloudDNSPrivateHostedZone(ctx, req.(*DetachVpcFromAliCloudDNSPrivateHostedZoneRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessPrivateLinkConnectionService_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.(ServerlessPrivateLinkConnectionServiceServer).CreateMSKVPCConnection(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPrivateLinkConnectionService_CreateMSKVPCConnection_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPrivateLinkConnectionServiceServer).CreateMSKVPCConnection(ctx, req.(*CreateMSKVPCConnectionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessPrivateLinkConnectionService_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.(ServerlessPrivateLinkConnectionServiceServer).DeleteMSKVPCConnection(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPrivateLinkConnectionService_DeleteMSKVPCConnection_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPrivateLinkConnectionServiceServer).DeleteMSKVPCConnection(ctx, req.(*DeleteMSKVPCConnectionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessPrivateLinkConnectionService_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.(ServerlessPrivateLinkConnectionServiceServer).GetMSKVPCConnection(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessPrivateLinkConnectionService_GetMSKVPCConnection_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessPrivateLinkConnectionServiceServer).GetMSKVPCConnection(ctx, req.(*GetMSKVPCConnectionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// ServerlessPrivateLinkConnectionService_ServiceDesc is the grpc.ServiceDesc for ServerlessPrivateLinkConnectionService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var ServerlessPrivateLinkConnectionService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "global.serverless.v1.ServerlessPrivateLinkConnectionService",
	HandlerType: (*ServerlessPrivateLinkConnectionServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateAWSVpcEndpoint",
			Handler:    _ServerlessPrivateLinkConnectionService_CreateAWSVpcEndpoint_Handler,
		},
		{
			MethodName: "DescribeAWSVpcEndpoint",
			Handler:    _ServerlessPrivateLinkConnectionService_DescribeAWSVpcEndpoint_Handler,
		},
		{
			MethodName: "DeleteAWSVpcEndpoint",
			Handler:    _ServerlessPrivateLinkConnectionService_DeleteAWSVpcEndpoint_Handler,
		},
		{
			MethodName: "CreateAliCloudVpcEndpoint",
			Handler:    _ServerlessPrivateLinkConnectionService_CreateAliCloudVpcEndpoint_Handler,
		},
		{
			MethodName: "DescribeAliCloudVpcEndpoint",
			Handler:    _ServerlessPrivateLinkConnectionService_DescribeAliCloudVpcEndpoint_Handler,
		},
		{
			MethodName: "DeleteAliCloudVpcEndpoint",
			Handler:    _ServerlessPrivateLinkConnectionService_DeleteAliCloudVpcEndpoint_Handler,
		},
		{
			MethodName: "GetZoneIds",
			Handler:    _ServerlessPrivateLinkConnectionService_GetZoneIds_Handler,
		},
		{
			MethodName: "ListAliCloudVpcEndpointZones",
			Handler:    _ServerlessPrivateLinkConnectionService_ListAliCloudVpcEndpointZones_Handler,
		},
		{
			MethodName: "RemoveAliCloudZoneFromVpcEndpoint",
			Handler:    _ServerlessPrivateLinkConnectionService_RemoveAliCloudZoneFromVpcEndpoint_Handler,
		},
		{
			MethodName: "CreateAliCloudDNSRecord",
			Handler:    _ServerlessPrivateLinkConnectionService_CreateAliCloudDNSRecord_Handler,
		},
		{
			MethodName: "DeleteAliCloudDNSRecord",
			Handler:    _ServerlessPrivateLinkConnectionService_DeleteAliCloudDNSRecord_Handler,
		},
		{
			MethodName: "CreateAWSRoute53Records",
			Handler:    _ServerlessPrivateLinkConnectionService_CreateAWSRoute53Records_Handler,
		},
		{
			MethodName: "DeleteAWSRoute53Records",
			Handler:    _ServerlessPrivateLinkConnectionService_DeleteAWSRoute53Records_Handler,
		},
		{
			MethodName: "GetAWSRoute53Change",
			Handler:    _ServerlessPrivateLinkConnectionService_GetAWSRoute53Change_Handler,
		},
		{
			MethodName: "CreateAWSRoute53PrivateHostedZone",
			Handler:    _ServerlessPrivateLinkConnectionService_CreateAWSRoute53PrivateHostedZone_Handler,
		},
		{
			MethodName: "DeleteAWSRoute53PrivateHostedZone",
			Handler:    _ServerlessPrivateLinkConnectionService_DeleteAWSRoute53PrivateHostedZone_Handler,
		},
		{
			MethodName: "CreateAliCloudDNSPrivateHostedZone",
			Handler:    _ServerlessPrivateLinkConnectionService_CreateAliCloudDNSPrivateHostedZone_Handler,
		},
		{
			MethodName: "DeleteAliCloudDNSPrivateHostedZone",
			Handler:    _ServerlessPrivateLinkConnectionService_DeleteAliCloudDNSPrivateHostedZone_Handler,
		},
		{
			MethodName: "AttachVpcToAliCloudDNSPrivateHostedZone",
			Handler:    _ServerlessPrivateLinkConnectionService_AttachVpcToAliCloudDNSPrivateHostedZone_Handler,
		},
		{
			MethodName: "DetachVpcFromAliCloudDNSPrivateHostedZone",
			Handler:    _ServerlessPrivateLinkConnectionService_DetachVpcFromAliCloudDNSPrivateHostedZone_Handler,
		},
		{
			MethodName: "CreateMSKVPCConnection",
			Handler:    _ServerlessPrivateLinkConnectionService_CreateMSKVPCConnection_Handler,
		},
		{
			MethodName: "DeleteMSKVPCConnection",
			Handler:    _ServerlessPrivateLinkConnectionService_DeleteMSKVPCConnection_Handler,
		},
		{
			MethodName: "GetMSKVPCConnection",
			Handler:    _ServerlessPrivateLinkConnectionService_GetMSKVPCConnection_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "global/serverless/v1/services.proto",
}