// Code generated by protoc-gen-grpc-gateway. DO NOT EDIT.
// source: regional/serverless/v1/services.proto

/*
Package serverlessv1 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.
*/
package serverlessv1

import (
	"context"
	"errors"
	"io"
	"net/http"

	"github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
	"github.com/grpc-ecosystem/grpc-gateway/v2/utilities"
	"google.golang.org/grpc"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/grpclog"
	"google.golang.org/grpc/metadata"
	"google.golang.org/grpc/status"
	"google.golang.org/protobuf/proto"
)

// Suppress "imported and not used" errors
var (
	_ codes.Code
	_ io.Reader
	_ status.Status
	_ = errors.New
	_ = runtime.String
	_ = utilities.NewDoubleArray
	_ = metadata.Join
)

func request_ServerlessRegionalService_DescRegion_0(ctx context.Context, marshaler runtime.Marshaler, client ServerlessRegionalServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq ServerlessRegionalServiceDescRegionRequest
		metadata runtime.ServerMetadata
	)
	if req.Body != nil {
		_, _ = io.Copy(io.Discard, req.Body)
	}
	msg, err := client.DescRegion(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
	return msg, metadata, err
}

func local_request_ServerlessRegionalService_DescRegion_0(ctx context.Context, marshaler runtime.Marshaler, server ServerlessRegionalServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq ServerlessRegionalServiceDescRegionRequest
		metadata runtime.ServerMetadata
	)
	msg, err := server.DescRegion(ctx, &protoReq)
	return msg, metadata, err
}

func request_ServerlessRegionalService_CreateCluster_0(ctx context.Context, marshaler runtime.Marshaler, client ServerlessRegionalServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq ServerlessRegionalServiceCreateClusterRequest
		metadata runtime.ServerMetadata
		err      error
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	if req.Body != nil {
		_, _ = io.Copy(io.Discard, req.Body)
	}
	val, ok := pathParams["cluster_id"]
	if !ok {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "cluster_id")
	}
	protoReq.ClusterId, err = runtime.String(val)
	if err != nil {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "cluster_id", err)
	}
	msg, err := client.CreateCluster(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
	return msg, metadata, err
}

func local_request_ServerlessRegionalService_CreateCluster_0(ctx context.Context, marshaler runtime.Marshaler, server ServerlessRegionalServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq ServerlessRegionalServiceCreateClusterRequest
		metadata runtime.ServerMetadata
		err      error
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	val, ok := pathParams["cluster_id"]
	if !ok {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "cluster_id")
	}
	protoReq.ClusterId, err = runtime.String(val)
	if err != nil {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "cluster_id", err)
	}
	msg, err := server.CreateCluster(ctx, &protoReq)
	return msg, metadata, err
}

var filter_ServerlessRegionalService_GetCluster_0 = &utilities.DoubleArray{Encoding: map[string]int{"cluster_id": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}

func request_ServerlessRegionalService_GetCluster_0(ctx context.Context, marshaler runtime.Marshaler, client ServerlessRegionalServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq ServerlessRegionalServiceGetClusterRequest
		metadata runtime.ServerMetadata
		err      error
	)
	if req.Body != nil {
		_, _ = io.Copy(io.Discard, req.Body)
	}
	val, ok := pathParams["cluster_id"]
	if !ok {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "cluster_id")
	}
	protoReq.ClusterId, err = runtime.String(val)
	if err != nil {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "cluster_id", err)
	}
	if err := req.ParseForm(); err != nil {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ServerlessRegionalService_GetCluster_0); err != nil {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	msg, err := client.GetCluster(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
	return msg, metadata, err
}

func local_request_ServerlessRegionalService_GetCluster_0(ctx context.Context, marshaler runtime.Marshaler, server ServerlessRegionalServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq ServerlessRegionalServiceGetClusterRequest
		metadata runtime.ServerMetadata
		err      error
	)
	val, ok := pathParams["cluster_id"]
	if !ok {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "cluster_id")
	}
	protoReq.ClusterId, err = runtime.String(val)
	if err != nil {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "cluster_id", err)
	}
	if err := req.ParseForm(); err != nil {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ServerlessRegionalService_GetCluster_0); err != nil {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	msg, err := server.GetCluster(ctx, &protoReq)
	return msg, metadata, err
}

var filter_ServerlessRegionalService_ListClusters_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}

func request_ServerlessRegionalService_ListClusters_0(ctx context.Context, marshaler runtime.Marshaler, client ServerlessRegionalServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq ServerlessRegionalServiceListClustersRequest
		metadata runtime.ServerMetadata
	)
	if req.Body != nil {
		_, _ = io.Copy(io.Discard, req.Body)
	}
	if err := req.ParseForm(); err != nil {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ServerlessRegionalService_ListClusters_0); err != nil {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	msg, err := client.ListClusters(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
	return msg, metadata, err
}

func local_request_ServerlessRegionalService_ListClusters_0(ctx context.Context, marshaler runtime.Marshaler, server ServerlessRegionalServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq ServerlessRegionalServiceListClustersRequest
		metadata runtime.ServerMetadata
	)
	if err := req.ParseForm(); err != nil {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ServerlessRegionalService_ListClusters_0); err != nil {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	msg, err := server.ListClusters(ctx, &protoReq)
	return msg, metadata, err
}

func request_ServerlessRegionalService_UpdateCluster_0(ctx context.Context, marshaler runtime.Marshaler, client ServerlessRegionalServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq ServerlessRegionalServiceUpdateClusterRequest
		metadata runtime.ServerMetadata
		err      error
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	if req.Body != nil {
		_, _ = io.Copy(io.Discard, req.Body)
	}
	val, ok := pathParams["cluster_id"]
	if !ok {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "cluster_id")
	}
	protoReq.ClusterId, err = runtime.String(val)
	if err != nil {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "cluster_id", err)
	}
	msg, err := client.UpdateCluster(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
	return msg, metadata, err
}

func local_request_ServerlessRegionalService_UpdateCluster_0(ctx context.Context, marshaler runtime.Marshaler, server ServerlessRegionalServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq ServerlessRegionalServiceUpdateClusterRequest
		metadata runtime.ServerMetadata
		err      error
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	val, ok := pathParams["cluster_id"]
	if !ok {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "cluster_id")
	}
	protoReq.ClusterId, err = runtime.String(val)
	if err != nil {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "cluster_id", err)
	}
	msg, err := server.UpdateCluster(ctx, &protoReq)
	return msg, metadata, err
}

var filter_ServerlessRegionalService_DeleteCluster_0 = &utilities.DoubleArray{Encoding: map[string]int{"cluster_id": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}

func request_ServerlessRegionalService_DeleteCluster_0(ctx context.Context, marshaler runtime.Marshaler, client ServerlessRegionalServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq ServerlessRegionalServiceDeleteClusterRequest
		metadata runtime.ServerMetadata
		err      error
	)
	if req.Body != nil {
		_, _ = io.Copy(io.Discard, req.Body)
	}
	val, ok := pathParams["cluster_id"]
	if !ok {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "cluster_id")
	}
	protoReq.ClusterId, err = runtime.String(val)
	if err != nil {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "cluster_id", err)
	}
	if err := req.ParseForm(); err != nil {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ServerlessRegionalService_DeleteCluster_0); err != nil {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	msg, err := client.DeleteCluster(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
	return msg, metadata, err
}

func local_request_ServerlessRegionalService_DeleteCluster_0(ctx context.Context, marshaler runtime.Marshaler, server ServerlessRegionalServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq ServerlessRegionalServiceDeleteClusterRequest
		metadata runtime.ServerMetadata
		err      error
	)
	val, ok := pathParams["cluster_id"]
	if !ok {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "cluster_id")
	}
	protoReq.ClusterId, err = runtime.String(val)
	if err != nil {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "cluster_id", err)
	}
	if err := req.ParseForm(); err != nil {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ServerlessRegionalService_DeleteCluster_0); err != nil {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	msg, err := server.DeleteCluster(ctx, &protoReq)
	return msg, metadata, err
}

func request_ServerlessRegionalService_CheckCloudStoragePermission_0(ctx context.Context, marshaler runtime.Marshaler, client ServerlessRegionalServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq CheckCloudStoragePermissionRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	if req.Body != nil {
		_, _ = io.Copy(io.Discard, req.Body)
	}
	msg, err := client.CheckCloudStoragePermission(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
	return msg, metadata, err
}

func local_request_ServerlessRegionalService_CheckCloudStoragePermission_0(ctx context.Context, marshaler runtime.Marshaler, server ServerlessRegionalServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq CheckCloudStoragePermissionRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	msg, err := server.CheckCloudStoragePermission(ctx, &protoReq)
	return msg, metadata, err
}

func request_ServerlessImportRegionalService_CheckImportPermission_0(ctx context.Context, marshaler runtime.Marshaler, client ServerlessImportRegionalServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq CheckImportPermissionRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	if req.Body != nil {
		_, _ = io.Copy(io.Discard, req.Body)
	}
	msg, err := client.CheckImportPermission(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
	return msg, metadata, err
}

func local_request_ServerlessImportRegionalService_CheckImportPermission_0(ctx context.Context, marshaler runtime.Marshaler, server ServerlessImportRegionalServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq CheckImportPermissionRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	msg, err := server.CheckImportPermission(ctx, &protoReq)
	return msg, metadata, err
}

func request_ServerlessImportRegionalService_Precheck_0(ctx context.Context, marshaler runtime.Marshaler, client ServerlessImportRegionalServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq PrecheckRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	if req.Body != nil {
		_, _ = io.Copy(io.Discard, req.Body)
	}
	msg, err := client.Precheck(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
	return msg, metadata, err
}

func local_request_ServerlessImportRegionalService_Precheck_0(ctx context.Context, marshaler runtime.Marshaler, server ServerlessImportRegionalServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq PrecheckRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	msg, err := server.Precheck(ctx, &protoReq)
	return msg, metadata, err
}

func request_ServerlessDMRegionalService_Precheck_0(ctx context.Context, marshaler runtime.Marshaler, client ServerlessDMRegionalServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq ServerlessDMRegionalServicePrecheckRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	if req.Body != nil {
		_, _ = io.Copy(io.Discard, req.Body)
	}
	msg, err := client.Precheck(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
	return msg, metadata, err
}

func local_request_ServerlessDMRegionalService_Precheck_0(ctx context.Context, marshaler runtime.Marshaler, server ServerlessDMRegionalServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq ServerlessDMRegionalServicePrecheckRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	msg, err := server.Precheck(ctx, &protoReq)
	return msg, metadata, err
}

func request_ServerlessDMRegionalService_CreateVpcEndpoint_0(ctx context.Context, marshaler runtime.Marshaler, client ServerlessDMRegionalServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq CreateVpcEndpointRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	if req.Body != nil {
		_, _ = io.Copy(io.Discard, req.Body)
	}
	msg, err := client.CreateVpcEndpoint(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
	return msg, metadata, err
}

func local_request_ServerlessDMRegionalService_CreateVpcEndpoint_0(ctx context.Context, marshaler runtime.Marshaler, server ServerlessDMRegionalServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq CreateVpcEndpointRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	msg, err := server.CreateVpcEndpoint(ctx, &protoReq)
	return msg, metadata, err
}

func request_ServerlessDMRegionalService_DescribeVpcEndpoint_0(ctx context.Context, marshaler runtime.Marshaler, client ServerlessDMRegionalServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq DescribeVpcEndpointRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	if req.Body != nil {
		_, _ = io.Copy(io.Discard, req.Body)
	}
	msg, err := client.DescribeVpcEndpoint(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
	return msg, metadata, err
}

func local_request_ServerlessDMRegionalService_DescribeVpcEndpoint_0(ctx context.Context, marshaler runtime.Marshaler, server ServerlessDMRegionalServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq DescribeVpcEndpointRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	msg, err := server.DescribeVpcEndpoint(ctx, &protoReq)
	return msg, metadata, err
}

func request_ServerlessDMRegionalService_DeleteVpcEndpoint_0(ctx context.Context, marshaler runtime.Marshaler, client ServerlessDMRegionalServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq DeleteVpcEndpointRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	if req.Body != nil {
		_, _ = io.Copy(io.Discard, req.Body)
	}
	msg, err := client.DeleteVpcEndpoint(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
	return msg, metadata, err
}

func local_request_ServerlessDMRegionalService_DeleteVpcEndpoint_0(ctx context.Context, marshaler runtime.Marshaler, server ServerlessDMRegionalServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq DeleteVpcEndpointRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	msg, err := server.DeleteVpcEndpoint(ctx, &protoReq)
	return msg, metadata, err
}

func request_ServerlessDMRegionalService_ListVpcEndpointZones_0(ctx context.Context, marshaler runtime.Marshaler, client ServerlessDMRegionalServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq ListVpcEndpointZonesRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	if req.Body != nil {
		_, _ = io.Copy(io.Discard, req.Body)
	}
	msg, err := client.ListVpcEndpointZones(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
	return msg, metadata, err
}

func local_request_ServerlessDMRegionalService_ListVpcEndpointZones_0(ctx context.Context, marshaler runtime.Marshaler, server ServerlessDMRegionalServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq ListVpcEndpointZonesRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	msg, err := server.ListVpcEndpointZones(ctx, &protoReq)
	return msg, metadata, err
}

func request_ServerlessDMRegionalService_RemoveZoneFromVpcEndpoint_0(ctx context.Context, marshaler runtime.Marshaler, client ServerlessDMRegionalServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq RemoveZoneFromVpcEndpointRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	if req.Body != nil {
		_, _ = io.Copy(io.Discard, req.Body)
	}
	msg, err := client.RemoveZoneFromVpcEndpoint(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
	return msg, metadata, err
}

func local_request_ServerlessDMRegionalService_RemoveZoneFromVpcEndpoint_0(ctx context.Context, marshaler runtime.Marshaler, server ServerlessDMRegionalServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq RemoveZoneFromVpcEndpointRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	msg, err := server.RemoveZoneFromVpcEndpoint(ctx, &protoReq)
	return msg, metadata, err
}

func request_ServerlessPrivateLinkConnectionRegionalService_CreateAWSVpcEndpoint_0(ctx context.Context, marshaler runtime.Marshaler, client ServerlessPrivateLinkConnectionRegionalServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq CreateAWSVpcEndpointRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	if req.Body != nil {
		_, _ = io.Copy(io.Discard, req.Body)
	}
	msg, err := client.CreateAWSVpcEndpoint(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
	return msg, metadata, err
}

func local_request_ServerlessPrivateLinkConnectionRegionalService_CreateAWSVpcEndpoint_0(ctx context.Context, marshaler runtime.Marshaler, server ServerlessPrivateLinkConnectionRegionalServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq CreateAWSVpcEndpointRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	msg, err := server.CreateAWSVpcEndpoint(ctx, &protoReq)
	return msg, metadata, err
}

func request_ServerlessPrivateLinkConnectionRegionalService_DescribeAWSVpcEndpoint_0(ctx context.Context, marshaler runtime.Marshaler, client ServerlessPrivateLinkConnectionRegionalServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq DescribeAWSVpcEndpointRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	if req.Body != nil {
		_, _ = io.Copy(io.Discard, req.Body)
	}
	msg, err := client.DescribeAWSVpcEndpoint(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
	return msg, metadata, err
}

func local_request_ServerlessPrivateLinkConnectionRegionalService_DescribeAWSVpcEndpoint_0(ctx context.Context, marshaler runtime.Marshaler, server ServerlessPrivateLinkConnectionRegionalServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq DescribeAWSVpcEndpointRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	msg, err := server.DescribeAWSVpcEndpoint(ctx, &protoReq)
	return msg, metadata, err
}

func request_ServerlessPrivateLinkConnectionRegionalService_DeleteAWSVpcEndpoint_0(ctx context.Context, marshaler runtime.Marshaler, client ServerlessPrivateLinkConnectionRegionalServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq DeleteAWSVpcEndpointRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	if req.Body != nil {
		_, _ = io.Copy(io.Discard, req.Body)
	}
	msg, err := client.DeleteAWSVpcEndpoint(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
	return msg, metadata, err
}

func local_request_ServerlessPrivateLinkConnectionRegionalService_DeleteAWSVpcEndpoint_0(ctx context.Context, marshaler runtime.Marshaler, server ServerlessPrivateLinkConnectionRegionalServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq DeleteAWSVpcEndpointRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	msg, err := server.DeleteAWSVpcEndpoint(ctx, &protoReq)
	return msg, metadata, err
}

func request_ServerlessPrivateLinkConnectionRegionalService_CreateAliCloudVpcEndpoint_0(ctx context.Context, marshaler runtime.Marshaler, client ServerlessPrivateLinkConnectionRegionalServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq CreateAliCloudVpcEndpointRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	if req.Body != nil {
		_, _ = io.Copy(io.Discard, req.Body)
	}
	msg, err := client.CreateAliCloudVpcEndpoint(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
	return msg, metadata, err
}

func local_request_ServerlessPrivateLinkConnectionRegionalService_CreateAliCloudVpcEndpoint_0(ctx context.Context, marshaler runtime.Marshaler, server ServerlessPrivateLinkConnectionRegionalServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq CreateAliCloudVpcEndpointRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	msg, err := server.CreateAliCloudVpcEndpoint(ctx, &protoReq)
	return msg, metadata, err
}

func request_ServerlessPrivateLinkConnectionRegionalService_DescribeAliCloudVpcEndpoint_0(ctx context.Context, marshaler runtime.Marshaler, client ServerlessPrivateLinkConnectionRegionalServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq DescribeAliCloudVpcEndpointRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	if req.Body != nil {
		_, _ = io.Copy(io.Discard, req.Body)
	}
	msg, err := client.DescribeAliCloudVpcEndpoint(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
	return msg, metadata, err
}

func local_request_ServerlessPrivateLinkConnectionRegionalService_DescribeAliCloudVpcEndpoint_0(ctx context.Context, marshaler runtime.Marshaler, server ServerlessPrivateLinkConnectionRegionalServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq DescribeAliCloudVpcEndpointRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	msg, err := server.DescribeAliCloudVpcEndpoint(ctx, &protoReq)
	return msg, metadata, err
}

func request_ServerlessPrivateLinkConnectionRegionalService_DeleteAliCloudVpcEndpoint_0(ctx context.Context, marshaler runtime.Marshaler, client ServerlessPrivateLinkConnectionRegionalServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq DeleteAliCloudVpcEndpointRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	if req.Body != nil {
		_, _ = io.Copy(io.Discard, req.Body)
	}
	msg, err := client.DeleteAliCloudVpcEndpoint(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
	return msg, metadata, err
}

func local_request_ServerlessPrivateLinkConnectionRegionalService_DeleteAliCloudVpcEndpoint_0(ctx context.Context, marshaler runtime.Marshaler, server ServerlessPrivateLinkConnectionRegionalServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq DeleteAliCloudVpcEndpointRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	msg, err := server.DeleteAliCloudVpcEndpoint(ctx, &protoReq)
	return msg, metadata, err
}

func request_ServerlessPrivateLinkConnectionRegionalService_GetZoneIds_0(ctx context.Context, marshaler runtime.Marshaler, client ServerlessPrivateLinkConnectionRegionalServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq GetZoneIdsRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	if req.Body != nil {
		_, _ = io.Copy(io.Discard, req.Body)
	}
	msg, err := client.GetZoneIds(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
	return msg, metadata, err
}

func local_request_ServerlessPrivateLinkConnectionRegionalService_GetZoneIds_0(ctx context.Context, marshaler runtime.Marshaler, server ServerlessPrivateLinkConnectionRegionalServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq GetZoneIdsRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	msg, err := server.GetZoneIds(ctx, &protoReq)
	return msg, metadata, err
}

func request_ServerlessPrivateLinkConnectionRegionalService_ListAliCloudVpcEndpointZones_0(ctx context.Context, marshaler runtime.Marshaler, client ServerlessPrivateLinkConnectionRegionalServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq ListAliCloudVpcEndpointZonesRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	if req.Body != nil {
		_, _ = io.Copy(io.Discard, req.Body)
	}
	msg, err := client.ListAliCloudVpcEndpointZones(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
	return msg, metadata, err
}

func local_request_ServerlessPrivateLinkConnectionRegionalService_ListAliCloudVpcEndpointZones_0(ctx context.Context, marshaler runtime.Marshaler, server ServerlessPrivateLinkConnectionRegionalServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq ListAliCloudVpcEndpointZonesRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	msg, err := server.ListAliCloudVpcEndpointZones(ctx, &protoReq)
	return msg, metadata, err
}

func request_ServerlessPrivateLinkConnectionRegionalService_RemoveAliCloudZoneFromVpcEndpoint_0(ctx context.Context, marshaler runtime.Marshaler, client ServerlessPrivateLinkConnectionRegionalServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq RemoveAliCloudZoneFromVpcEndpointRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	if req.Body != nil {
		_, _ = io.Copy(io.Discard, req.Body)
	}
	msg, err := client.RemoveAliCloudZoneFromVpcEndpoint(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
	return msg, metadata, err
}

func local_request_ServerlessPrivateLinkConnectionRegionalService_RemoveAliCloudZoneFromVpcEndpoint_0(ctx context.Context, marshaler runtime.Marshaler, server ServerlessPrivateLinkConnectionRegionalServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq RemoveAliCloudZoneFromVpcEndpointRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	msg, err := server.RemoveAliCloudZoneFromVpcEndpoint(ctx, &protoReq)
	return msg, metadata, err
}

func request_ServerlessPrivateLinkConnectionRegionalService_CreateAliCloudDNSRecord_0(ctx context.Context, marshaler runtime.Marshaler, client ServerlessPrivateLinkConnectionRegionalServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq CreateAliCloudDNSRecordRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	if req.Body != nil {
		_, _ = io.Copy(io.Discard, req.Body)
	}
	msg, err := client.CreateAliCloudDNSRecord(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
	return msg, metadata, err
}

func local_request_ServerlessPrivateLinkConnectionRegionalService_CreateAliCloudDNSRecord_0(ctx context.Context, marshaler runtime.Marshaler, server ServerlessPrivateLinkConnectionRegionalServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq CreateAliCloudDNSRecordRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	msg, err := server.CreateAliCloudDNSRecord(ctx, &protoReq)
	return msg, metadata, err
}

func request_ServerlessPrivateLinkConnectionRegionalService_DeleteAliCloudDNSRecord_0(ctx context.Context, marshaler runtime.Marshaler, client ServerlessPrivateLinkConnectionRegionalServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq DeleteAliCloudDNSRecordRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	if req.Body != nil {
		_, _ = io.Copy(io.Discard, req.Body)
	}
	msg, err := client.DeleteAliCloudDNSRecord(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
	return msg, metadata, err
}

func local_request_ServerlessPrivateLinkConnectionRegionalService_DeleteAliCloudDNSRecord_0(ctx context.Context, marshaler runtime.Marshaler, server ServerlessPrivateLinkConnectionRegionalServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq DeleteAliCloudDNSRecordRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	msg, err := server.DeleteAliCloudDNSRecord(ctx, &protoReq)
	return msg, metadata, err
}

func request_ServerlessPrivateLinkConnectionRegionalService_CreateAWSRoute53Records_0(ctx context.Context, marshaler runtime.Marshaler, client ServerlessPrivateLinkConnectionRegionalServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq CreateAWSRoute53RecordsRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	if req.Body != nil {
		_, _ = io.Copy(io.Discard, req.Body)
	}
	msg, err := client.CreateAWSRoute53Records(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
	return msg, metadata, err
}

func local_request_ServerlessPrivateLinkConnectionRegionalService_CreateAWSRoute53Records_0(ctx context.Context, marshaler runtime.Marshaler, server ServerlessPrivateLinkConnectionRegionalServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq CreateAWSRoute53RecordsRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	msg, err := server.CreateAWSRoute53Records(ctx, &protoReq)
	return msg, metadata, err
}

func request_ServerlessPrivateLinkConnectionRegionalService_DeleteAWSRoute53Records_0(ctx context.Context, marshaler runtime.Marshaler, client ServerlessPrivateLinkConnectionRegionalServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq DeleteAWSRoute53RecordsRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	if req.Body != nil {
		_, _ = io.Copy(io.Discard, req.Body)
	}
	msg, err := client.DeleteAWSRoute53Records(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
	return msg, metadata, err
}

func local_request_ServerlessPrivateLinkConnectionRegionalService_DeleteAWSRoute53Records_0(ctx context.Context, marshaler runtime.Marshaler, server ServerlessPrivateLinkConnectionRegionalServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq DeleteAWSRoute53RecordsRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	msg, err := server.DeleteAWSRoute53Records(ctx, &protoReq)
	return msg, metadata, err
}

func request_ServerlessPrivateLinkConnectionRegionalService_GetAWSRoute53Change_0(ctx context.Context, marshaler runtime.Marshaler, client ServerlessPrivateLinkConnectionRegionalServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq GetAWSRoute53ChangeRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	if req.Body != nil {
		_, _ = io.Copy(io.Discard, req.Body)
	}
	msg, err := client.GetAWSRoute53Change(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
	return msg, metadata, err
}

func local_request_ServerlessPrivateLinkConnectionRegionalService_GetAWSRoute53Change_0(ctx context.Context, marshaler runtime.Marshaler, server ServerlessPrivateLinkConnectionRegionalServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq GetAWSRoute53ChangeRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	msg, err := server.GetAWSRoute53Change(ctx, &protoReq)
	return msg, metadata, err
}

func request_ServerlessPrivateLinkConnectionRegionalService_CreateAWSRoute53PrivateHostedZone_0(ctx context.Context, marshaler runtime.Marshaler, client ServerlessPrivateLinkConnectionRegionalServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq CreateAWSRoute53PrivateHostedZoneRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	if req.Body != nil {
		_, _ = io.Copy(io.Discard, req.Body)
	}
	msg, err := client.CreateAWSRoute53PrivateHostedZone(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
	return msg, metadata, err
}

func local_request_ServerlessPrivateLinkConnectionRegionalService_CreateAWSRoute53PrivateHostedZone_0(ctx context.Context, marshaler runtime.Marshaler, server ServerlessPrivateLinkConnectionRegionalServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq CreateAWSRoute53PrivateHostedZoneRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	msg, err := server.CreateAWSRoute53PrivateHostedZone(ctx, &protoReq)
	return msg, metadata, err
}

func request_ServerlessPrivateLinkConnectionRegionalService_DeleteAWSRoute53PrivateHostedZone_0(ctx context.Context, marshaler runtime.Marshaler, client ServerlessPrivateLinkConnectionRegionalServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq DeleteAWSRoute53PrivateHostedZoneRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	if req.Body != nil {
		_, _ = io.Copy(io.Discard, req.Body)
	}
	msg, err := client.DeleteAWSRoute53PrivateHostedZone(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
	return msg, metadata, err
}

func local_request_ServerlessPrivateLinkConnectionRegionalService_DeleteAWSRoute53PrivateHostedZone_0(ctx context.Context, marshaler runtime.Marshaler, server ServerlessPrivateLinkConnectionRegionalServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq DeleteAWSRoute53PrivateHostedZoneRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	msg, err := server.DeleteAWSRoute53PrivateHostedZone(ctx, &protoReq)
	return msg, metadata, err
}

func request_ServerlessPrivateLinkConnectionRegionalService_CreateAliCloudDNSPrivateHostedZone_0(ctx context.Context, marshaler runtime.Marshaler, client ServerlessPrivateLinkConnectionRegionalServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq CreateAliCloudDNSPrivateHostedZoneRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	if req.Body != nil {
		_, _ = io.Copy(io.Discard, req.Body)
	}
	msg, err := client.CreateAliCloudDNSPrivateHostedZone(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
	return msg, metadata, err
}

func local_request_ServerlessPrivateLinkConnectionRegionalService_CreateAliCloudDNSPrivateHostedZone_0(ctx context.Context, marshaler runtime.Marshaler, server ServerlessPrivateLinkConnectionRegionalServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq CreateAliCloudDNSPrivateHostedZoneRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	msg, err := server.CreateAliCloudDNSPrivateHostedZone(ctx, &protoReq)
	return msg, metadata, err
}

func request_ServerlessPrivateLinkConnectionRegionalService_DeleteAliCloudDNSPrivateHostedZone_0(ctx context.Context, marshaler runtime.Marshaler, client ServerlessPrivateLinkConnectionRegionalServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq DeleteAliCloudDNSPrivateHostedZoneRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	if req.Body != nil {
		_, _ = io.Copy(io.Discard, req.Body)
	}
	msg, err := client.DeleteAliCloudDNSPrivateHostedZone(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
	return msg, metadata, err
}

func local_request_ServerlessPrivateLinkConnectionRegionalService_DeleteAliCloudDNSPrivateHostedZone_0(ctx context.Context, marshaler runtime.Marshaler, server ServerlessPrivateLinkConnectionRegionalServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq DeleteAliCloudDNSPrivateHostedZoneRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	msg, err := server.DeleteAliCloudDNSPrivateHostedZone(ctx, &protoReq)
	return msg, metadata, err
}

func request_ServerlessPrivateLinkConnectionRegionalService_AttachVpcToAliCloudDNSPrivateHostedZone_0(ctx context.Context, marshaler runtime.Marshaler, client ServerlessPrivateLinkConnectionRegionalServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq AttachVpcToAliCloudDNSPrivateHostedZoneRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	if req.Body != nil {
		_, _ = io.Copy(io.Discard, req.Body)
	}
	msg, err := client.AttachVpcToAliCloudDNSPrivateHostedZone(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
	return msg, metadata, err
}

func local_request_ServerlessPrivateLinkConnectionRegionalService_AttachVpcToAliCloudDNSPrivateHostedZone_0(ctx context.Context, marshaler runtime.Marshaler, server ServerlessPrivateLinkConnectionRegionalServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq AttachVpcToAliCloudDNSPrivateHostedZoneRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	msg, err := server.AttachVpcToAliCloudDNSPrivateHostedZone(ctx, &protoReq)
	return msg, metadata, err
}

func request_ServerlessPrivateLinkConnectionRegionalService_DetachVpcFromAliCloudDNSPrivateHostedZone_0(ctx context.Context, marshaler runtime.Marshaler, client ServerlessPrivateLinkConnectionRegionalServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq DetachVpcFromAliCloudDNSPrivateHostedZoneRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	if req.Body != nil {
		_, _ = io.Copy(io.Discard, req.Body)
	}
	msg, err := client.DetachVpcFromAliCloudDNSPrivateHostedZone(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
	return msg, metadata, err
}

func local_request_ServerlessPrivateLinkConnectionRegionalService_DetachVpcFromAliCloudDNSPrivateHostedZone_0(ctx context.Context, marshaler runtime.Marshaler, server ServerlessPrivateLinkConnectionRegionalServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq DetachVpcFromAliCloudDNSPrivateHostedZoneRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	msg, err := server.DetachVpcFromAliCloudDNSPrivateHostedZone(ctx, &protoReq)
	return msg, metadata, err
}

func request_ServerlessPrivateLinkConnectionRegionalService_CreateMSKVPCConnection_0(ctx context.Context, marshaler runtime.Marshaler, client ServerlessPrivateLinkConnectionRegionalServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq CreateMSKVPCConnectionRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	if req.Body != nil {
		_, _ = io.Copy(io.Discard, req.Body)
	}
	msg, err := client.CreateMSKVPCConnection(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
	return msg, metadata, err
}

func local_request_ServerlessPrivateLinkConnectionRegionalService_CreateMSKVPCConnection_0(ctx context.Context, marshaler runtime.Marshaler, server ServerlessPrivateLinkConnectionRegionalServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq CreateMSKVPCConnectionRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	msg, err := server.CreateMSKVPCConnection(ctx, &protoReq)
	return msg, metadata, err
}

func request_ServerlessPrivateLinkConnectionRegionalService_DeleteMSKVPCConnection_0(ctx context.Context, marshaler runtime.Marshaler, client ServerlessPrivateLinkConnectionRegionalServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq DeleteMSKVPCConnectionRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	if req.Body != nil {
		_, _ = io.Copy(io.Discard, req.Body)
	}
	msg, err := client.DeleteMSKVPCConnection(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
	return msg, metadata, err
}

func local_request_ServerlessPrivateLinkConnectionRegionalService_DeleteMSKVPCConnection_0(ctx context.Context, marshaler runtime.Marshaler, server ServerlessPrivateLinkConnectionRegionalServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq DeleteMSKVPCConnectionRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	msg, err := server.DeleteMSKVPCConnection(ctx, &protoReq)
	return msg, metadata, err
}

func request_ServerlessPrivateLinkConnectionRegionalService_GetMSKVPCConnection_0(ctx context.Context, marshaler runtime.Marshaler, client ServerlessPrivateLinkConnectionRegionalServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq GetMSKVPCConnectionRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	if req.Body != nil {
		_, _ = io.Copy(io.Discard, req.Body)
	}
	msg, err := client.GetMSKVPCConnection(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
	return msg, metadata, err
}

func local_request_ServerlessPrivateLinkConnectionRegionalService_GetMSKVPCConnection_0(ctx context.Context, marshaler runtime.Marshaler, server ServerlessPrivateLinkConnectionRegionalServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var (
		protoReq GetMSKVPCConnectionRequest
		metadata runtime.ServerMetadata
	)
	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	msg, err := server.GetMSKVPCConnection(ctx, &protoReq)
	return msg, metadata, err
}

// RegisterServerlessRegionalServiceHandlerServer registers the http handlers for service ServerlessRegionalService to "mux".
// UnaryRPC     :call ServerlessRegionalServiceServer directly.
// StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
// Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterServerlessRegionalServiceHandlerFromEndpoint instead.
// GRPC interceptors will not work for this type of registration. To use interceptors, you must use the "runtime.WithMiddlewares" option in the "runtime.NewServeMux" call.
func RegisterServerlessRegionalServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server ServerlessRegionalServiceServer) error {
	mux.Handle(http.MethodGet, pattern_ServerlessRegionalService_DescRegion_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		var stream runtime.ServerTransportStream
		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/regional.serverless.v1.ServerlessRegionalService/DescRegion", runtime.WithHTTPPathPattern("/serverless/regional/v1/desc"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := local_request_ServerlessRegionalService_DescRegion_0(annotatedContext, inboundMarshaler, server, req, pathParams)
		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessRegionalService_DescRegion_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessRegionalService_CreateCluster_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		var stream runtime.ServerTransportStream
		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/regional.serverless.v1.ServerlessRegionalService/CreateCluster", runtime.WithHTTPPathPattern("/serverless/regional/v1/clusters/{cluster_id}"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := local_request_ServerlessRegionalService_CreateCluster_0(annotatedContext, inboundMarshaler, server, req, pathParams)
		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessRegionalService_CreateCluster_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodGet, pattern_ServerlessRegionalService_GetCluster_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		var stream runtime.ServerTransportStream
		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/regional.serverless.v1.ServerlessRegionalService/GetCluster", runtime.WithHTTPPathPattern("/serverless/regional/v1/clusters/{cluster_id}"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := local_request_ServerlessRegionalService_GetCluster_0(annotatedContext, inboundMarshaler, server, req, pathParams)
		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessRegionalService_GetCluster_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodGet, pattern_ServerlessRegionalService_ListClusters_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		var stream runtime.ServerTransportStream
		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/regional.serverless.v1.ServerlessRegionalService/ListClusters", runtime.WithHTTPPathPattern("/serverless/regional/v1/clusters"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := local_request_ServerlessRegionalService_ListClusters_0(annotatedContext, inboundMarshaler, server, req, pathParams)
		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessRegionalService_ListClusters_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPatch, pattern_ServerlessRegionalService_UpdateCluster_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		var stream runtime.ServerTransportStream
		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/regional.serverless.v1.ServerlessRegionalService/UpdateCluster", runtime.WithHTTPPathPattern("/serverless/regional/v1/clusters/{cluster_id}"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := local_request_ServerlessRegionalService_UpdateCluster_0(annotatedContext, inboundMarshaler, server, req, pathParams)
		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessRegionalService_UpdateCluster_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodDelete, pattern_ServerlessRegionalService_DeleteCluster_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		var stream runtime.ServerTransportStream
		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/regional.serverless.v1.ServerlessRegionalService/DeleteCluster", runtime.WithHTTPPathPattern("/serverless/regional/v1/clusters/{cluster_id}"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := local_request_ServerlessRegionalService_DeleteCluster_0(annotatedContext, inboundMarshaler, server, req, pathParams)
		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessRegionalService_DeleteCluster_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessRegionalService_CheckCloudStoragePermission_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		var stream runtime.ServerTransportStream
		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/regional.serverless.v1.ServerlessRegionalService/CheckCloudStoragePermission", runtime.WithHTTPPathPattern("/serverless/regional/v1/clusters:checkCloudStoragePermission"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := local_request_ServerlessRegionalService_CheckCloudStoragePermission_0(annotatedContext, inboundMarshaler, server, req, pathParams)
		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessRegionalService_CheckCloudStoragePermission_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})

	return nil
}

// RegisterServerlessImportRegionalServiceHandlerServer registers the http handlers for service ServerlessImportRegionalService to "mux".
// UnaryRPC     :call ServerlessImportRegionalServiceServer directly.
// StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
// Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterServerlessImportRegionalServiceHandlerFromEndpoint instead.
// GRPC interceptors will not work for this type of registration. To use interceptors, you must use the "runtime.WithMiddlewares" option in the "runtime.NewServeMux" call.
func RegisterServerlessImportRegionalServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server ServerlessImportRegionalServiceServer) error {
	mux.Handle(http.MethodPost, pattern_ServerlessImportRegionalService_CheckImportPermission_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		var stream runtime.ServerTransportStream
		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/regional.serverless.v1.ServerlessImportRegionalService/CheckImportPermission", runtime.WithHTTPPathPattern("/serverless/regional/v1/import:checkPermission"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := local_request_ServerlessImportRegionalService_CheckImportPermission_0(annotatedContext, inboundMarshaler, server, req, pathParams)
		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessImportRegionalService_CheckImportPermission_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessImportRegionalService_Precheck_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		var stream runtime.ServerTransportStream
		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/regional.serverless.v1.ServerlessImportRegionalService/Precheck", runtime.WithHTTPPathPattern("/serverless/regional/v1/import:precheck"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := local_request_ServerlessImportRegionalService_Precheck_0(annotatedContext, inboundMarshaler, server, req, pathParams)
		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessImportRegionalService_Precheck_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})

	return nil
}

// RegisterServerlessDMRegionalServiceHandlerServer registers the http handlers for service ServerlessDMRegionalService to "mux".
// UnaryRPC     :call ServerlessDMRegionalServiceServer directly.
// StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
// Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterServerlessDMRegionalServiceHandlerFromEndpoint instead.
// GRPC interceptors will not work for this type of registration. To use interceptors, you must use the "runtime.WithMiddlewares" option in the "runtime.NewServeMux" call.
func RegisterServerlessDMRegionalServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server ServerlessDMRegionalServiceServer) error {
	mux.Handle(http.MethodPost, pattern_ServerlessDMRegionalService_Precheck_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		var stream runtime.ServerTransportStream
		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/regional.serverless.v1.ServerlessDMRegionalService/Precheck", runtime.WithHTTPPathPattern("/serverless/regional/v1/dm:precheck"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := local_request_ServerlessDMRegionalService_Precheck_0(annotatedContext, inboundMarshaler, server, req, pathParams)
		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessDMRegionalService_Precheck_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessDMRegionalService_CreateVpcEndpoint_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		var stream runtime.ServerTransportStream
		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/regional.serverless.v1.ServerlessDMRegionalService/CreateVpcEndpoint", runtime.WithHTTPPathPattern("/serverless/regional/v1/dm:createVpcEndpoint"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := local_request_ServerlessDMRegionalService_CreateVpcEndpoint_0(annotatedContext, inboundMarshaler, server, req, pathParams)
		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessDMRegionalService_CreateVpcEndpoint_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessDMRegionalService_DescribeVpcEndpoint_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		var stream runtime.ServerTransportStream
		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/regional.serverless.v1.ServerlessDMRegionalService/DescribeVpcEndpoint", runtime.WithHTTPPathPattern("/serverless/regional/v1/dm:describeVpcEndpoint"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := local_request_ServerlessDMRegionalService_DescribeVpcEndpoint_0(annotatedContext, inboundMarshaler, server, req, pathParams)
		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessDMRegionalService_DescribeVpcEndpoint_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessDMRegionalService_DeleteVpcEndpoint_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		var stream runtime.ServerTransportStream
		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/regional.serverless.v1.ServerlessDMRegionalService/DeleteVpcEndpoint", runtime.WithHTTPPathPattern("/serverless/regional/v1/dm:deleteVpcEndpoint"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := local_request_ServerlessDMRegionalService_DeleteVpcEndpoint_0(annotatedContext, inboundMarshaler, server, req, pathParams)
		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessDMRegionalService_DeleteVpcEndpoint_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessDMRegionalService_ListVpcEndpointZones_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		var stream runtime.ServerTransportStream
		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/regional.serverless.v1.ServerlessDMRegionalService/ListVpcEndpointZones", runtime.WithHTTPPathPattern("/serverless/regional/v1/dm:listVpcEndpointZones"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := local_request_ServerlessDMRegionalService_ListVpcEndpointZones_0(annotatedContext, inboundMarshaler, server, req, pathParams)
		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessDMRegionalService_ListVpcEndpointZones_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessDMRegionalService_RemoveZoneFromVpcEndpoint_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		var stream runtime.ServerTransportStream
		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/regional.serverless.v1.ServerlessDMRegionalService/RemoveZoneFromVpcEndpoint", runtime.WithHTTPPathPattern("/serverless/regional/v1/dm:removeZoneFromVpcEndpoint"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := local_request_ServerlessDMRegionalService_RemoveZoneFromVpcEndpoint_0(annotatedContext, inboundMarshaler, server, req, pathParams)
		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessDMRegionalService_RemoveZoneFromVpcEndpoint_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})

	return nil
}

// RegisterServerlessPrivateLinkConnectionRegionalServiceHandlerServer registers the http handlers for service ServerlessPrivateLinkConnectionRegionalService to "mux".
// UnaryRPC     :call ServerlessPrivateLinkConnectionRegionalServiceServer directly.
// StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
// Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterServerlessPrivateLinkConnectionRegionalServiceHandlerFromEndpoint instead.
// GRPC interceptors will not work for this type of registration. To use interceptors, you must use the "runtime.WithMiddlewares" option in the "runtime.NewServeMux" call.
func RegisterServerlessPrivateLinkConnectionRegionalServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server ServerlessPrivateLinkConnectionRegionalServiceServer) error {
	mux.Handle(http.MethodPost, pattern_ServerlessPrivateLinkConnectionRegionalService_CreateAWSVpcEndpoint_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		var stream runtime.ServerTransportStream
		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/CreateAWSVpcEndpoint", runtime.WithHTTPPathPattern("/serverless/regional/v1/privateLinkConnection:createAWSVpcEndpoint"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := local_request_ServerlessPrivateLinkConnectionRegionalService_CreateAWSVpcEndpoint_0(annotatedContext, inboundMarshaler, server, req, pathParams)
		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessPrivateLinkConnectionRegionalService_CreateAWSVpcEndpoint_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessPrivateLinkConnectionRegionalService_DescribeAWSVpcEndpoint_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		var stream runtime.ServerTransportStream
		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/DescribeAWSVpcEndpoint", runtime.WithHTTPPathPattern("/serverless/regional/v1/privateLinkConnection:describeAWSVpcEndpoint"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := local_request_ServerlessPrivateLinkConnectionRegionalService_DescribeAWSVpcEndpoint_0(annotatedContext, inboundMarshaler, server, req, pathParams)
		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessPrivateLinkConnectionRegionalService_DescribeAWSVpcEndpoint_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessPrivateLinkConnectionRegionalService_DeleteAWSVpcEndpoint_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		var stream runtime.ServerTransportStream
		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/DeleteAWSVpcEndpoint", runtime.WithHTTPPathPattern("/serverless/regional/v1/privateLinkConnection:deleteAWSVpcEndpoint"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := local_request_ServerlessPrivateLinkConnectionRegionalService_DeleteAWSVpcEndpoint_0(annotatedContext, inboundMarshaler, server, req, pathParams)
		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessPrivateLinkConnectionRegionalService_DeleteAWSVpcEndpoint_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessPrivateLinkConnectionRegionalService_CreateAliCloudVpcEndpoint_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		var stream runtime.ServerTransportStream
		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/CreateAliCloudVpcEndpoint", runtime.WithHTTPPathPattern("/serverless/regional/v1/privateLinkConnection:createAliCloudVpcEndpoint"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := local_request_ServerlessPrivateLinkConnectionRegionalService_CreateAliCloudVpcEndpoint_0(annotatedContext, inboundMarshaler, server, req, pathParams)
		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessPrivateLinkConnectionRegionalService_CreateAliCloudVpcEndpoint_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessPrivateLinkConnectionRegionalService_DescribeAliCloudVpcEndpoint_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		var stream runtime.ServerTransportStream
		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/DescribeAliCloudVpcEndpoint", runtime.WithHTTPPathPattern("/serverless/regional/v1/privateLinkConnection:describeAliCloudVpcEndpoint"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := local_request_ServerlessPrivateLinkConnectionRegionalService_DescribeAliCloudVpcEndpoint_0(annotatedContext, inboundMarshaler, server, req, pathParams)
		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessPrivateLinkConnectionRegionalService_DescribeAliCloudVpcEndpoint_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessPrivateLinkConnectionRegionalService_DeleteAliCloudVpcEndpoint_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		var stream runtime.ServerTransportStream
		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/DeleteAliCloudVpcEndpoint", runtime.WithHTTPPathPattern("/serverless/regional/v1/privateLinkConnection:deleteAliCloudVpcEndpoint"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := local_request_ServerlessPrivateLinkConnectionRegionalService_DeleteAliCloudVpcEndpoint_0(annotatedContext, inboundMarshaler, server, req, pathParams)
		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessPrivateLinkConnectionRegionalService_DeleteAliCloudVpcEndpoint_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessPrivateLinkConnectionRegionalService_GetZoneIds_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		var stream runtime.ServerTransportStream
		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/GetZoneIds", runtime.WithHTTPPathPattern("/serverless/regional/v1/privateLinkConnection:getZoneIds"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := local_request_ServerlessPrivateLinkConnectionRegionalService_GetZoneIds_0(annotatedContext, inboundMarshaler, server, req, pathParams)
		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessPrivateLinkConnectionRegionalService_GetZoneIds_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessPrivateLinkConnectionRegionalService_ListAliCloudVpcEndpointZones_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		var stream runtime.ServerTransportStream
		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/ListAliCloudVpcEndpointZones", runtime.WithHTTPPathPattern("/serverless/regional/v1/privateLinkConnection:listAliCloudVpcEndpointZones"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := local_request_ServerlessPrivateLinkConnectionRegionalService_ListAliCloudVpcEndpointZones_0(annotatedContext, inboundMarshaler, server, req, pathParams)
		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessPrivateLinkConnectionRegionalService_ListAliCloudVpcEndpointZones_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessPrivateLinkConnectionRegionalService_RemoveAliCloudZoneFromVpcEndpoint_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		var stream runtime.ServerTransportStream
		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/RemoveAliCloudZoneFromVpcEndpoint", runtime.WithHTTPPathPattern("/serverless/regional/v1/privateLinkConnection:removeZoneFromAliCloudVpcEndpoint"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := local_request_ServerlessPrivateLinkConnectionRegionalService_RemoveAliCloudZoneFromVpcEndpoint_0(annotatedContext, inboundMarshaler, server, req, pathParams)
		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessPrivateLinkConnectionRegionalService_RemoveAliCloudZoneFromVpcEndpoint_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessPrivateLinkConnectionRegionalService_CreateAliCloudDNSRecord_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		var stream runtime.ServerTransportStream
		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/CreateAliCloudDNSRecord", runtime.WithHTTPPathPattern("/serverless/regional/v1/privateLinkConnection:createAliCloudDNSRecord"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := local_request_ServerlessPrivateLinkConnectionRegionalService_CreateAliCloudDNSRecord_0(annotatedContext, inboundMarshaler, server, req, pathParams)
		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessPrivateLinkConnectionRegionalService_CreateAliCloudDNSRecord_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessPrivateLinkConnectionRegionalService_DeleteAliCloudDNSRecord_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		var stream runtime.ServerTransportStream
		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/DeleteAliCloudDNSRecord", runtime.WithHTTPPathPattern("/serverless/regional/v1/privateLinkConnection:deleteAliCloudDNSRecord"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := local_request_ServerlessPrivateLinkConnectionRegionalService_DeleteAliCloudDNSRecord_0(annotatedContext, inboundMarshaler, server, req, pathParams)
		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessPrivateLinkConnectionRegionalService_DeleteAliCloudDNSRecord_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessPrivateLinkConnectionRegionalService_CreateAWSRoute53Records_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		var stream runtime.ServerTransportStream
		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/CreateAWSRoute53Records", runtime.WithHTTPPathPattern("/serverless/regional/v1/privateLinkConnection:createAWSRoute53Records"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := local_request_ServerlessPrivateLinkConnectionRegionalService_CreateAWSRoute53Records_0(annotatedContext, inboundMarshaler, server, req, pathParams)
		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessPrivateLinkConnectionRegionalService_CreateAWSRoute53Records_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessPrivateLinkConnectionRegionalService_DeleteAWSRoute53Records_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		var stream runtime.ServerTransportStream
		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/DeleteAWSRoute53Records", runtime.WithHTTPPathPattern("/serverless/regional/v1/privateLinkConnection:deleteAWSRoute53Records"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := local_request_ServerlessPrivateLinkConnectionRegionalService_DeleteAWSRoute53Records_0(annotatedContext, inboundMarshaler, server, req, pathParams)
		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessPrivateLinkConnectionRegionalService_DeleteAWSRoute53Records_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessPrivateLinkConnectionRegionalService_GetAWSRoute53Change_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		var stream runtime.ServerTransportStream
		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/GetAWSRoute53Change", runtime.WithHTTPPathPattern("/serverless/regional/v1/privateLinkConnection:getAWSRoute53Change"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := local_request_ServerlessPrivateLinkConnectionRegionalService_GetAWSRoute53Change_0(annotatedContext, inboundMarshaler, server, req, pathParams)
		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessPrivateLinkConnectionRegionalService_GetAWSRoute53Change_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessPrivateLinkConnectionRegionalService_CreateAWSRoute53PrivateHostedZone_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		var stream runtime.ServerTransportStream
		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/CreateAWSRoute53PrivateHostedZone", runtime.WithHTTPPathPattern("/serverless/regional/v1/privateLinkConnection:createAWSRoute53PrivateHostedZone"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := local_request_ServerlessPrivateLinkConnectionRegionalService_CreateAWSRoute53PrivateHostedZone_0(annotatedContext, inboundMarshaler, server, req, pathParams)
		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessPrivateLinkConnectionRegionalService_CreateAWSRoute53PrivateHostedZone_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessPrivateLinkConnectionRegionalService_DeleteAWSRoute53PrivateHostedZone_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		var stream runtime.ServerTransportStream
		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/DeleteAWSRoute53PrivateHostedZone", runtime.WithHTTPPathPattern("/serverless/regional/v1/privateLinkConnection:deleteAWSRoute53PrivateHostedZone"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := local_request_ServerlessPrivateLinkConnectionRegionalService_DeleteAWSRoute53PrivateHostedZone_0(annotatedContext, inboundMarshaler, server, req, pathParams)
		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessPrivateLinkConnectionRegionalService_DeleteAWSRoute53PrivateHostedZone_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessPrivateLinkConnectionRegionalService_CreateAliCloudDNSPrivateHostedZone_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		var stream runtime.ServerTransportStream
		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/CreateAliCloudDNSPrivateHostedZone", runtime.WithHTTPPathPattern("/serverless/regional/v1/privateLinkConnection:createAliCloudDNSPrivateHostedZone"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := local_request_ServerlessPrivateLinkConnectionRegionalService_CreateAliCloudDNSPrivateHostedZone_0(annotatedContext, inboundMarshaler, server, req, pathParams)
		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessPrivateLinkConnectionRegionalService_CreateAliCloudDNSPrivateHostedZone_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessPrivateLinkConnectionRegionalService_DeleteAliCloudDNSPrivateHostedZone_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		var stream runtime.ServerTransportStream
		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/DeleteAliCloudDNSPrivateHostedZone", runtime.WithHTTPPathPattern("/serverless/regional/v1/privateLinkConnection:deleteAliCloudDNSPrivateHostedZone"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := local_request_ServerlessPrivateLinkConnectionRegionalService_DeleteAliCloudDNSPrivateHostedZone_0(annotatedContext, inboundMarshaler, server, req, pathParams)
		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessPrivateLinkConnectionRegionalService_DeleteAliCloudDNSPrivateHostedZone_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessPrivateLinkConnectionRegionalService_AttachVpcToAliCloudDNSPrivateHostedZone_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		var stream runtime.ServerTransportStream
		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/AttachVpcToAliCloudDNSPrivateHostedZone", runtime.WithHTTPPathPattern("/serverless/regional/v1/privateLinkConnection:attachVpcToAliCloudDNSPrivateHostedZone"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := local_request_ServerlessPrivateLinkConnectionRegionalService_AttachVpcToAliCloudDNSPrivateHostedZone_0(annotatedContext, inboundMarshaler, server, req, pathParams)
		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessPrivateLinkConnectionRegionalService_AttachVpcToAliCloudDNSPrivateHostedZone_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessPrivateLinkConnectionRegionalService_DetachVpcFromAliCloudDNSPrivateHostedZone_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		var stream runtime.ServerTransportStream
		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/DetachVpcFromAliCloudDNSPrivateHostedZone", runtime.WithHTTPPathPattern("/serverless/regional/v1/privateLinkConnection:detachVpcFromAliCloudDNSPrivateHostedZone"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := local_request_ServerlessPrivateLinkConnectionRegionalService_DetachVpcFromAliCloudDNSPrivateHostedZone_0(annotatedContext, inboundMarshaler, server, req, pathParams)
		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessPrivateLinkConnectionRegionalService_DetachVpcFromAliCloudDNSPrivateHostedZone_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessPrivateLinkConnectionRegionalService_CreateMSKVPCConnection_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		var stream runtime.ServerTransportStream
		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/CreateMSKVPCConnection", runtime.WithHTTPPathPattern("/serverless/regional/v1/privateLinkConnection:createMSKVPCConnection"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := local_request_ServerlessPrivateLinkConnectionRegionalService_CreateMSKVPCConnection_0(annotatedContext, inboundMarshaler, server, req, pathParams)
		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessPrivateLinkConnectionRegionalService_CreateMSKVPCConnection_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessPrivateLinkConnectionRegionalService_DeleteMSKVPCConnection_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		var stream runtime.ServerTransportStream
		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/DeleteMSKVPCConnection", runtime.WithHTTPPathPattern("/serverless/regional/v1/privateLinkConnection:deleteMSKVPCConnection"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := local_request_ServerlessPrivateLinkConnectionRegionalService_DeleteMSKVPCConnection_0(annotatedContext, inboundMarshaler, server, req, pathParams)
		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessPrivateLinkConnectionRegionalService_DeleteMSKVPCConnection_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessPrivateLinkConnectionRegionalService_GetMSKVPCConnection_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		var stream runtime.ServerTransportStream
		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/GetMSKVPCConnection", runtime.WithHTTPPathPattern("/serverless/regional/v1/privateLinkConnection:getMSKVPCConnection"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := local_request_ServerlessPrivateLinkConnectionRegionalService_GetMSKVPCConnection_0(annotatedContext, inboundMarshaler, server, req, pathParams)
		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessPrivateLinkConnectionRegionalService_GetMSKVPCConnection_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})

	return nil
}

// RegisterServerlessRegionalServiceHandlerFromEndpoint is same as RegisterServerlessRegionalServiceHandler but
// automatically dials to "endpoint" and closes the connection when "ctx" gets done.
func RegisterServerlessRegionalServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
	conn, err := grpc.NewClient(endpoint, opts...)
	if err != nil {
		return err
	}
	defer func() {
		if err != nil {
			if cerr := conn.Close(); cerr != nil {
				grpclog.Errorf("Failed to close conn to %s: %v", endpoint, cerr)
			}
			return
		}
		go func() {
			<-ctx.Done()
			if cerr := conn.Close(); cerr != nil {
				grpclog.Errorf("Failed to close conn to %s: %v", endpoint, cerr)
			}
		}()
	}()
	return RegisterServerlessRegionalServiceHandler(ctx, mux, conn)
}

// RegisterServerlessRegionalServiceHandler registers the http handlers for service ServerlessRegionalService to "mux".
// The handlers forward requests to the grpc endpoint over "conn".
func RegisterServerlessRegionalServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
	return RegisterServerlessRegionalServiceHandlerClient(ctx, mux, NewServerlessRegionalServiceClient(conn))
}

// RegisterServerlessRegionalServiceHandlerClient registers the http handlers for service ServerlessRegionalService
// to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "ServerlessRegionalServiceClient".
// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "ServerlessRegionalServiceClient"
// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in
// "ServerlessRegionalServiceClient" to call the correct interceptors. This client ignores the HTTP middlewares.
func RegisterServerlessRegionalServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client ServerlessRegionalServiceClient) error {
	mux.Handle(http.MethodGet, pattern_ServerlessRegionalService_DescRegion_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/regional.serverless.v1.ServerlessRegionalService/DescRegion", runtime.WithHTTPPathPattern("/serverless/regional/v1/desc"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := request_ServerlessRegionalService_DescRegion_0(annotatedContext, inboundMarshaler, client, req, pathParams)
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessRegionalService_DescRegion_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessRegionalService_CreateCluster_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/regional.serverless.v1.ServerlessRegionalService/CreateCluster", runtime.WithHTTPPathPattern("/serverless/regional/v1/clusters/{cluster_id}"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := request_ServerlessRegionalService_CreateCluster_0(annotatedContext, inboundMarshaler, client, req, pathParams)
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessRegionalService_CreateCluster_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodGet, pattern_ServerlessRegionalService_GetCluster_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/regional.serverless.v1.ServerlessRegionalService/GetCluster", runtime.WithHTTPPathPattern("/serverless/regional/v1/clusters/{cluster_id}"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := request_ServerlessRegionalService_GetCluster_0(annotatedContext, inboundMarshaler, client, req, pathParams)
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessRegionalService_GetCluster_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodGet, pattern_ServerlessRegionalService_ListClusters_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/regional.serverless.v1.ServerlessRegionalService/ListClusters", runtime.WithHTTPPathPattern("/serverless/regional/v1/clusters"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := request_ServerlessRegionalService_ListClusters_0(annotatedContext, inboundMarshaler, client, req, pathParams)
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessRegionalService_ListClusters_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPatch, pattern_ServerlessRegionalService_UpdateCluster_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/regional.serverless.v1.ServerlessRegionalService/UpdateCluster", runtime.WithHTTPPathPattern("/serverless/regional/v1/clusters/{cluster_id}"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := request_ServerlessRegionalService_UpdateCluster_0(annotatedContext, inboundMarshaler, client, req, pathParams)
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessRegionalService_UpdateCluster_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodDelete, pattern_ServerlessRegionalService_DeleteCluster_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/regional.serverless.v1.ServerlessRegionalService/DeleteCluster", runtime.WithHTTPPathPattern("/serverless/regional/v1/clusters/{cluster_id}"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := request_ServerlessRegionalService_DeleteCluster_0(annotatedContext, inboundMarshaler, client, req, pathParams)
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessRegionalService_DeleteCluster_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessRegionalService_CheckCloudStoragePermission_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/regional.serverless.v1.ServerlessRegionalService/CheckCloudStoragePermission", runtime.WithHTTPPathPattern("/serverless/regional/v1/clusters:checkCloudStoragePermission"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := request_ServerlessRegionalService_CheckCloudStoragePermission_0(annotatedContext, inboundMarshaler, client, req, pathParams)
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessRegionalService_CheckCloudStoragePermission_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	return nil
}

var (
	pattern_ServerlessRegionalService_DescRegion_0                  = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"serverless", "regional", "v1", "desc"}, ""))
	pattern_ServerlessRegionalService_CreateCluster_0               = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"serverless", "regional", "v1", "clusters", "cluster_id"}, ""))
	pattern_ServerlessRegionalService_GetCluster_0                  = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"serverless", "regional", "v1", "clusters", "cluster_id"}, ""))
	pattern_ServerlessRegionalService_ListClusters_0                = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"serverless", "regional", "v1", "clusters"}, ""))
	pattern_ServerlessRegionalService_UpdateCluster_0               = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"serverless", "regional", "v1", "clusters", "cluster_id"}, ""))
	pattern_ServerlessRegionalService_DeleteCluster_0               = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"serverless", "regional", "v1", "clusters", "cluster_id"}, ""))
	pattern_ServerlessRegionalService_CheckCloudStoragePermission_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"serverless", "regional", "v1", "clusters"}, "checkCloudStoragePermission"))
)

var (
	forward_ServerlessRegionalService_DescRegion_0                  = runtime.ForwardResponseMessage
	forward_ServerlessRegionalService_CreateCluster_0               = runtime.ForwardResponseMessage
	forward_ServerlessRegionalService_GetCluster_0                  = runtime.ForwardResponseMessage
	forward_ServerlessRegionalService_ListClusters_0                = runtime.ForwardResponseMessage
	forward_ServerlessRegionalService_UpdateCluster_0               = runtime.ForwardResponseMessage
	forward_ServerlessRegionalService_DeleteCluster_0               = runtime.ForwardResponseMessage
	forward_ServerlessRegionalService_CheckCloudStoragePermission_0 = runtime.ForwardResponseMessage
)

// RegisterServerlessImportRegionalServiceHandlerFromEndpoint is same as RegisterServerlessImportRegionalServiceHandler but
// automatically dials to "endpoint" and closes the connection when "ctx" gets done.
func RegisterServerlessImportRegionalServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
	conn, err := grpc.NewClient(endpoint, opts...)
	if err != nil {
		return err
	}
	defer func() {
		if err != nil {
			if cerr := conn.Close(); cerr != nil {
				grpclog.Errorf("Failed to close conn to %s: %v", endpoint, cerr)
			}
			return
		}
		go func() {
			<-ctx.Done()
			if cerr := conn.Close(); cerr != nil {
				grpclog.Errorf("Failed to close conn to %s: %v", endpoint, cerr)
			}
		}()
	}()
	return RegisterServerlessImportRegionalServiceHandler(ctx, mux, conn)
}

// RegisterServerlessImportRegionalServiceHandler registers the http handlers for service ServerlessImportRegionalService to "mux".
// The handlers forward requests to the grpc endpoint over "conn".
func RegisterServerlessImportRegionalServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
	return RegisterServerlessImportRegionalServiceHandlerClient(ctx, mux, NewServerlessImportRegionalServiceClient(conn))
}

// RegisterServerlessImportRegionalServiceHandlerClient registers the http handlers for service ServerlessImportRegionalService
// to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "ServerlessImportRegionalServiceClient".
// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "ServerlessImportRegionalServiceClient"
// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in
// "ServerlessImportRegionalServiceClient" to call the correct interceptors. This client ignores the HTTP middlewares.
func RegisterServerlessImportRegionalServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client ServerlessImportRegionalServiceClient) error {
	mux.Handle(http.MethodPost, pattern_ServerlessImportRegionalService_CheckImportPermission_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/regional.serverless.v1.ServerlessImportRegionalService/CheckImportPermission", runtime.WithHTTPPathPattern("/serverless/regional/v1/import:checkPermission"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := request_ServerlessImportRegionalService_CheckImportPermission_0(annotatedContext, inboundMarshaler, client, req, pathParams)
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessImportRegionalService_CheckImportPermission_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessImportRegionalService_Precheck_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/regional.serverless.v1.ServerlessImportRegionalService/Precheck", runtime.WithHTTPPathPattern("/serverless/regional/v1/import:precheck"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := request_ServerlessImportRegionalService_Precheck_0(annotatedContext, inboundMarshaler, client, req, pathParams)
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessImportRegionalService_Precheck_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	return nil
}

var (
	pattern_ServerlessImportRegionalService_CheckImportPermission_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"serverless", "regional", "v1", "import"}, "checkPermission"))
	pattern_ServerlessImportRegionalService_Precheck_0              = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"serverless", "regional", "v1", "import"}, "precheck"))
)

var (
	forward_ServerlessImportRegionalService_CheckImportPermission_0 = runtime.ForwardResponseMessage
	forward_ServerlessImportRegionalService_Precheck_0              = runtime.ForwardResponseMessage
)

// RegisterServerlessDMRegionalServiceHandlerFromEndpoint is same as RegisterServerlessDMRegionalServiceHandler but
// automatically dials to "endpoint" and closes the connection when "ctx" gets done.
func RegisterServerlessDMRegionalServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
	conn, err := grpc.NewClient(endpoint, opts...)
	if err != nil {
		return err
	}
	defer func() {
		if err != nil {
			if cerr := conn.Close(); cerr != nil {
				grpclog.Errorf("Failed to close conn to %s: %v", endpoint, cerr)
			}
			return
		}
		go func() {
			<-ctx.Done()
			if cerr := conn.Close(); cerr != nil {
				grpclog.Errorf("Failed to close conn to %s: %v", endpoint, cerr)
			}
		}()
	}()
	return RegisterServerlessDMRegionalServiceHandler(ctx, mux, conn)
}

// RegisterServerlessDMRegionalServiceHandler registers the http handlers for service ServerlessDMRegionalService to "mux".
// The handlers forward requests to the grpc endpoint over "conn".
func RegisterServerlessDMRegionalServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
	return RegisterServerlessDMRegionalServiceHandlerClient(ctx, mux, NewServerlessDMRegionalServiceClient(conn))
}

// RegisterServerlessDMRegionalServiceHandlerClient registers the http handlers for service ServerlessDMRegionalService
// to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "ServerlessDMRegionalServiceClient".
// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "ServerlessDMRegionalServiceClient"
// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in
// "ServerlessDMRegionalServiceClient" to call the correct interceptors. This client ignores the HTTP middlewares.
func RegisterServerlessDMRegionalServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client ServerlessDMRegionalServiceClient) error {
	mux.Handle(http.MethodPost, pattern_ServerlessDMRegionalService_Precheck_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/regional.serverless.v1.ServerlessDMRegionalService/Precheck", runtime.WithHTTPPathPattern("/serverless/regional/v1/dm:precheck"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := request_ServerlessDMRegionalService_Precheck_0(annotatedContext, inboundMarshaler, client, req, pathParams)
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessDMRegionalService_Precheck_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessDMRegionalService_CreateVpcEndpoint_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/regional.serverless.v1.ServerlessDMRegionalService/CreateVpcEndpoint", runtime.WithHTTPPathPattern("/serverless/regional/v1/dm:createVpcEndpoint"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := request_ServerlessDMRegionalService_CreateVpcEndpoint_0(annotatedContext, inboundMarshaler, client, req, pathParams)
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessDMRegionalService_CreateVpcEndpoint_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessDMRegionalService_DescribeVpcEndpoint_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/regional.serverless.v1.ServerlessDMRegionalService/DescribeVpcEndpoint", runtime.WithHTTPPathPattern("/serverless/regional/v1/dm:describeVpcEndpoint"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := request_ServerlessDMRegionalService_DescribeVpcEndpoint_0(annotatedContext, inboundMarshaler, client, req, pathParams)
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessDMRegionalService_DescribeVpcEndpoint_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessDMRegionalService_DeleteVpcEndpoint_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/regional.serverless.v1.ServerlessDMRegionalService/DeleteVpcEndpoint", runtime.WithHTTPPathPattern("/serverless/regional/v1/dm:deleteVpcEndpoint"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := request_ServerlessDMRegionalService_DeleteVpcEndpoint_0(annotatedContext, inboundMarshaler, client, req, pathParams)
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessDMRegionalService_DeleteVpcEndpoint_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessDMRegionalService_ListVpcEndpointZones_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/regional.serverless.v1.ServerlessDMRegionalService/ListVpcEndpointZones", runtime.WithHTTPPathPattern("/serverless/regional/v1/dm:listVpcEndpointZones"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := request_ServerlessDMRegionalService_ListVpcEndpointZones_0(annotatedContext, inboundMarshaler, client, req, pathParams)
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessDMRegionalService_ListVpcEndpointZones_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessDMRegionalService_RemoveZoneFromVpcEndpoint_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/regional.serverless.v1.ServerlessDMRegionalService/RemoveZoneFromVpcEndpoint", runtime.WithHTTPPathPattern("/serverless/regional/v1/dm:removeZoneFromVpcEndpoint"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := request_ServerlessDMRegionalService_RemoveZoneFromVpcEndpoint_0(annotatedContext, inboundMarshaler, client, req, pathParams)
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessDMRegionalService_RemoveZoneFromVpcEndpoint_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	return nil
}

var (
	pattern_ServerlessDMRegionalService_Precheck_0                  = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"serverless", "regional", "v1", "dm"}, "precheck"))
	pattern_ServerlessDMRegionalService_CreateVpcEndpoint_0         = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"serverless", "regional", "v1", "dm"}, "createVpcEndpoint"))
	pattern_ServerlessDMRegionalService_DescribeVpcEndpoint_0       = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"serverless", "regional", "v1", "dm"}, "describeVpcEndpoint"))
	pattern_ServerlessDMRegionalService_DeleteVpcEndpoint_0         = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"serverless", "regional", "v1", "dm"}, "deleteVpcEndpoint"))
	pattern_ServerlessDMRegionalService_ListVpcEndpointZones_0      = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"serverless", "regional", "v1", "dm"}, "listVpcEndpointZones"))
	pattern_ServerlessDMRegionalService_RemoveZoneFromVpcEndpoint_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"serverless", "regional", "v1", "dm"}, "removeZoneFromVpcEndpoint"))
)

var (
	forward_ServerlessDMRegionalService_Precheck_0                  = runtime.ForwardResponseMessage
	forward_ServerlessDMRegionalService_CreateVpcEndpoint_0         = runtime.ForwardResponseMessage
	forward_ServerlessDMRegionalService_DescribeVpcEndpoint_0       = runtime.ForwardResponseMessage
	forward_ServerlessDMRegionalService_DeleteVpcEndpoint_0         = runtime.ForwardResponseMessage
	forward_ServerlessDMRegionalService_ListVpcEndpointZones_0      = runtime.ForwardResponseMessage
	forward_ServerlessDMRegionalService_RemoveZoneFromVpcEndpoint_0 = runtime.ForwardResponseMessage
)

// RegisterServerlessPrivateLinkConnectionRegionalServiceHandlerFromEndpoint is same as RegisterServerlessPrivateLinkConnectionRegionalServiceHandler but
// automatically dials to "endpoint" and closes the connection when "ctx" gets done.
func RegisterServerlessPrivateLinkConnectionRegionalServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
	conn, err := grpc.NewClient(endpoint, opts...)
	if err != nil {
		return err
	}
	defer func() {
		if err != nil {
			if cerr := conn.Close(); cerr != nil {
				grpclog.Errorf("Failed to close conn to %s: %v", endpoint, cerr)
			}
			return
		}
		go func() {
			<-ctx.Done()
			if cerr := conn.Close(); cerr != nil {
				grpclog.Errorf("Failed to close conn to %s: %v", endpoint, cerr)
			}
		}()
	}()
	return RegisterServerlessPrivateLinkConnectionRegionalServiceHandler(ctx, mux, conn)
}

// RegisterServerlessPrivateLinkConnectionRegionalServiceHandler registers the http handlers for service ServerlessPrivateLinkConnectionRegionalService to "mux".
// The handlers forward requests to the grpc endpoint over "conn".
func RegisterServerlessPrivateLinkConnectionRegionalServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
	return RegisterServerlessPrivateLinkConnectionRegionalServiceHandlerClient(ctx, mux, NewServerlessPrivateLinkConnectionRegionalServiceClient(conn))
}

// RegisterServerlessPrivateLinkConnectionRegionalServiceHandlerClient registers the http handlers for service ServerlessPrivateLinkConnectionRegionalService
// to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "ServerlessPrivateLinkConnectionRegionalServiceClient".
// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "ServerlessPrivateLinkConnectionRegionalServiceClient"
// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in
// "ServerlessPrivateLinkConnectionRegionalServiceClient" to call the correct interceptors. This client ignores the HTTP middlewares.
func RegisterServerlessPrivateLinkConnectionRegionalServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client ServerlessPrivateLinkConnectionRegionalServiceClient) error {
	mux.Handle(http.MethodPost, pattern_ServerlessPrivateLinkConnectionRegionalService_CreateAWSVpcEndpoint_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/CreateAWSVpcEndpoint", runtime.WithHTTPPathPattern("/serverless/regional/v1/privateLinkConnection:createAWSVpcEndpoint"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := request_ServerlessPrivateLinkConnectionRegionalService_CreateAWSVpcEndpoint_0(annotatedContext, inboundMarshaler, client, req, pathParams)
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessPrivateLinkConnectionRegionalService_CreateAWSVpcEndpoint_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessPrivateLinkConnectionRegionalService_DescribeAWSVpcEndpoint_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/DescribeAWSVpcEndpoint", runtime.WithHTTPPathPattern("/serverless/regional/v1/privateLinkConnection:describeAWSVpcEndpoint"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := request_ServerlessPrivateLinkConnectionRegionalService_DescribeAWSVpcEndpoint_0(annotatedContext, inboundMarshaler, client, req, pathParams)
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessPrivateLinkConnectionRegionalService_DescribeAWSVpcEndpoint_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessPrivateLinkConnectionRegionalService_DeleteAWSVpcEndpoint_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/DeleteAWSVpcEndpoint", runtime.WithHTTPPathPattern("/serverless/regional/v1/privateLinkConnection:deleteAWSVpcEndpoint"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := request_ServerlessPrivateLinkConnectionRegionalService_DeleteAWSVpcEndpoint_0(annotatedContext, inboundMarshaler, client, req, pathParams)
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessPrivateLinkConnectionRegionalService_DeleteAWSVpcEndpoint_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessPrivateLinkConnectionRegionalService_CreateAliCloudVpcEndpoint_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/CreateAliCloudVpcEndpoint", runtime.WithHTTPPathPattern("/serverless/regional/v1/privateLinkConnection:createAliCloudVpcEndpoint"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := request_ServerlessPrivateLinkConnectionRegionalService_CreateAliCloudVpcEndpoint_0(annotatedContext, inboundMarshaler, client, req, pathParams)
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessPrivateLinkConnectionRegionalService_CreateAliCloudVpcEndpoint_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessPrivateLinkConnectionRegionalService_DescribeAliCloudVpcEndpoint_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/DescribeAliCloudVpcEndpoint", runtime.WithHTTPPathPattern("/serverless/regional/v1/privateLinkConnection:describeAliCloudVpcEndpoint"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := request_ServerlessPrivateLinkConnectionRegionalService_DescribeAliCloudVpcEndpoint_0(annotatedContext, inboundMarshaler, client, req, pathParams)
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessPrivateLinkConnectionRegionalService_DescribeAliCloudVpcEndpoint_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessPrivateLinkConnectionRegionalService_DeleteAliCloudVpcEndpoint_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/DeleteAliCloudVpcEndpoint", runtime.WithHTTPPathPattern("/serverless/regional/v1/privateLinkConnection:deleteAliCloudVpcEndpoint"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := request_ServerlessPrivateLinkConnectionRegionalService_DeleteAliCloudVpcEndpoint_0(annotatedContext, inboundMarshaler, client, req, pathParams)
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessPrivateLinkConnectionRegionalService_DeleteAliCloudVpcEndpoint_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessPrivateLinkConnectionRegionalService_GetZoneIds_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/GetZoneIds", runtime.WithHTTPPathPattern("/serverless/regional/v1/privateLinkConnection:getZoneIds"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := request_ServerlessPrivateLinkConnectionRegionalService_GetZoneIds_0(annotatedContext, inboundMarshaler, client, req, pathParams)
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessPrivateLinkConnectionRegionalService_GetZoneIds_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessPrivateLinkConnectionRegionalService_ListAliCloudVpcEndpointZones_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/ListAliCloudVpcEndpointZones", runtime.WithHTTPPathPattern("/serverless/regional/v1/privateLinkConnection:listAliCloudVpcEndpointZones"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := request_ServerlessPrivateLinkConnectionRegionalService_ListAliCloudVpcEndpointZones_0(annotatedContext, inboundMarshaler, client, req, pathParams)
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessPrivateLinkConnectionRegionalService_ListAliCloudVpcEndpointZones_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessPrivateLinkConnectionRegionalService_RemoveAliCloudZoneFromVpcEndpoint_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/RemoveAliCloudZoneFromVpcEndpoint", runtime.WithHTTPPathPattern("/serverless/regional/v1/privateLinkConnection:removeZoneFromAliCloudVpcEndpoint"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := request_ServerlessPrivateLinkConnectionRegionalService_RemoveAliCloudZoneFromVpcEndpoint_0(annotatedContext, inboundMarshaler, client, req, pathParams)
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessPrivateLinkConnectionRegionalService_RemoveAliCloudZoneFromVpcEndpoint_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessPrivateLinkConnectionRegionalService_CreateAliCloudDNSRecord_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/CreateAliCloudDNSRecord", runtime.WithHTTPPathPattern("/serverless/regional/v1/privateLinkConnection:createAliCloudDNSRecord"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := request_ServerlessPrivateLinkConnectionRegionalService_CreateAliCloudDNSRecord_0(annotatedContext, inboundMarshaler, client, req, pathParams)
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessPrivateLinkConnectionRegionalService_CreateAliCloudDNSRecord_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessPrivateLinkConnectionRegionalService_DeleteAliCloudDNSRecord_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/DeleteAliCloudDNSRecord", runtime.WithHTTPPathPattern("/serverless/regional/v1/privateLinkConnection:deleteAliCloudDNSRecord"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := request_ServerlessPrivateLinkConnectionRegionalService_DeleteAliCloudDNSRecord_0(annotatedContext, inboundMarshaler, client, req, pathParams)
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessPrivateLinkConnectionRegionalService_DeleteAliCloudDNSRecord_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessPrivateLinkConnectionRegionalService_CreateAWSRoute53Records_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/CreateAWSRoute53Records", runtime.WithHTTPPathPattern("/serverless/regional/v1/privateLinkConnection:createAWSRoute53Records"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := request_ServerlessPrivateLinkConnectionRegionalService_CreateAWSRoute53Records_0(annotatedContext, inboundMarshaler, client, req, pathParams)
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessPrivateLinkConnectionRegionalService_CreateAWSRoute53Records_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessPrivateLinkConnectionRegionalService_DeleteAWSRoute53Records_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/DeleteAWSRoute53Records", runtime.WithHTTPPathPattern("/serverless/regional/v1/privateLinkConnection:deleteAWSRoute53Records"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := request_ServerlessPrivateLinkConnectionRegionalService_DeleteAWSRoute53Records_0(annotatedContext, inboundMarshaler, client, req, pathParams)
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessPrivateLinkConnectionRegionalService_DeleteAWSRoute53Records_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessPrivateLinkConnectionRegionalService_GetAWSRoute53Change_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/GetAWSRoute53Change", runtime.WithHTTPPathPattern("/serverless/regional/v1/privateLinkConnection:getAWSRoute53Change"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := request_ServerlessPrivateLinkConnectionRegionalService_GetAWSRoute53Change_0(annotatedContext, inboundMarshaler, client, req, pathParams)
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessPrivateLinkConnectionRegionalService_GetAWSRoute53Change_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessPrivateLinkConnectionRegionalService_CreateAWSRoute53PrivateHostedZone_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/CreateAWSRoute53PrivateHostedZone", runtime.WithHTTPPathPattern("/serverless/regional/v1/privateLinkConnection:createAWSRoute53PrivateHostedZone"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := request_ServerlessPrivateLinkConnectionRegionalService_CreateAWSRoute53PrivateHostedZone_0(annotatedContext, inboundMarshaler, client, req, pathParams)
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessPrivateLinkConnectionRegionalService_CreateAWSRoute53PrivateHostedZone_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessPrivateLinkConnectionRegionalService_DeleteAWSRoute53PrivateHostedZone_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/DeleteAWSRoute53PrivateHostedZone", runtime.WithHTTPPathPattern("/serverless/regional/v1/privateLinkConnection:deleteAWSRoute53PrivateHostedZone"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := request_ServerlessPrivateLinkConnectionRegionalService_DeleteAWSRoute53PrivateHostedZone_0(annotatedContext, inboundMarshaler, client, req, pathParams)
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessPrivateLinkConnectionRegionalService_DeleteAWSRoute53PrivateHostedZone_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessPrivateLinkConnectionRegionalService_CreateAliCloudDNSPrivateHostedZone_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/CreateAliCloudDNSPrivateHostedZone", runtime.WithHTTPPathPattern("/serverless/regional/v1/privateLinkConnection:createAliCloudDNSPrivateHostedZone"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := request_ServerlessPrivateLinkConnectionRegionalService_CreateAliCloudDNSPrivateHostedZone_0(annotatedContext, inboundMarshaler, client, req, pathParams)
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessPrivateLinkConnectionRegionalService_CreateAliCloudDNSPrivateHostedZone_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessPrivateLinkConnectionRegionalService_DeleteAliCloudDNSPrivateHostedZone_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/DeleteAliCloudDNSPrivateHostedZone", runtime.WithHTTPPathPattern("/serverless/regional/v1/privateLinkConnection:deleteAliCloudDNSPrivateHostedZone"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := request_ServerlessPrivateLinkConnectionRegionalService_DeleteAliCloudDNSPrivateHostedZone_0(annotatedContext, inboundMarshaler, client, req, pathParams)
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessPrivateLinkConnectionRegionalService_DeleteAliCloudDNSPrivateHostedZone_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessPrivateLinkConnectionRegionalService_AttachVpcToAliCloudDNSPrivateHostedZone_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/AttachVpcToAliCloudDNSPrivateHostedZone", runtime.WithHTTPPathPattern("/serverless/regional/v1/privateLinkConnection:attachVpcToAliCloudDNSPrivateHostedZone"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := request_ServerlessPrivateLinkConnectionRegionalService_AttachVpcToAliCloudDNSPrivateHostedZone_0(annotatedContext, inboundMarshaler, client, req, pathParams)
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessPrivateLinkConnectionRegionalService_AttachVpcToAliCloudDNSPrivateHostedZone_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessPrivateLinkConnectionRegionalService_DetachVpcFromAliCloudDNSPrivateHostedZone_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/DetachVpcFromAliCloudDNSPrivateHostedZone", runtime.WithHTTPPathPattern("/serverless/regional/v1/privateLinkConnection:detachVpcFromAliCloudDNSPrivateHostedZone"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := request_ServerlessPrivateLinkConnectionRegionalService_DetachVpcFromAliCloudDNSPrivateHostedZone_0(annotatedContext, inboundMarshaler, client, req, pathParams)
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessPrivateLinkConnectionRegionalService_DetachVpcFromAliCloudDNSPrivateHostedZone_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessPrivateLinkConnectionRegionalService_CreateMSKVPCConnection_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/CreateMSKVPCConnection", runtime.WithHTTPPathPattern("/serverless/regional/v1/privateLinkConnection:createMSKVPCConnection"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := request_ServerlessPrivateLinkConnectionRegionalService_CreateMSKVPCConnection_0(annotatedContext, inboundMarshaler, client, req, pathParams)
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessPrivateLinkConnectionRegionalService_CreateMSKVPCConnection_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessPrivateLinkConnectionRegionalService_DeleteMSKVPCConnection_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/DeleteMSKVPCConnection", runtime.WithHTTPPathPattern("/serverless/regional/v1/privateLinkConnection:deleteMSKVPCConnection"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := request_ServerlessPrivateLinkConnectionRegionalService_DeleteMSKVPCConnection_0(annotatedContext, inboundMarshaler, client, req, pathParams)
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessPrivateLinkConnectionRegionalService_DeleteMSKVPCConnection_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	mux.Handle(http.MethodPost, pattern_ServerlessPrivateLinkConnectionRegionalService_GetMSKVPCConnection_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/regional.serverless.v1.ServerlessPrivateLinkConnectionRegionalService/GetMSKVPCConnection", runtime.WithHTTPPathPattern("/serverless/regional/v1/privateLinkConnection:getMSKVPCConnection"))
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := request_ServerlessPrivateLinkConnectionRegionalService_GetMSKVPCConnection_0(annotatedContext, inboundMarshaler, client, req, pathParams)
		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
		if err != nil {
			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
			return
		}
		forward_ServerlessPrivateLinkConnectionRegionalService_GetMSKVPCConnection_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
	})
	return nil
}

var (
	pattern_ServerlessPrivateLinkConnectionRegionalService_CreateAWSVpcEndpoint_0                      = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"serverless", "regional", "v1", "privateLinkConnection"}, "createAWSVpcEndpoint"))
	pattern_ServerlessPrivateLinkConnectionRegionalService_DescribeAWSVpcEndpoint_0                    = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"serverless", "regional", "v1", "privateLinkConnection"}, "describeAWSVpcEndpoint"))
	pattern_ServerlessPrivateLinkConnectionRegionalService_DeleteAWSVpcEndpoint_0                      = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"serverless", "regional", "v1", "privateLinkConnection"}, "deleteAWSVpcEndpoint"))
	pattern_ServerlessPrivateLinkConnectionRegionalService_CreateAliCloudVpcEndpoint_0                 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"serverless", "regional", "v1", "privateLinkConnection"}, "createAliCloudVpcEndpoint"))
	pattern_ServerlessPrivateLinkConnectionRegionalService_DescribeAliCloudVpcEndpoint_0               = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"serverless", "regional", "v1", "privateLinkConnection"}, "describeAliCloudVpcEndpoint"))
	pattern_ServerlessPrivateLinkConnectionRegionalService_DeleteAliCloudVpcEndpoint_0                 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"serverless", "regional", "v1", "privateLinkConnection"}, "deleteAliCloudVpcEndpoint"))
	pattern_ServerlessPrivateLinkConnectionRegionalService_GetZoneIds_0                                = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"serverless", "regional", "v1", "privateLinkConnection"}, "getZoneIds"))
	pattern_ServerlessPrivateLinkConnectionRegionalService_ListAliCloudVpcEndpointZones_0              = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"serverless", "regional", "v1", "privateLinkConnection"}, "listAliCloudVpcEndpointZones"))
	pattern_ServerlessPrivateLinkConnectionRegionalService_RemoveAliCloudZoneFromVpcEndpoint_0         = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"serverless", "regional", "v1", "privateLinkConnection"}, "removeZoneFromAliCloudVpcEndpoint"))
	pattern_ServerlessPrivateLinkConnectionRegionalService_CreateAliCloudDNSRecord_0                   = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"serverless", "regional", "v1", "privateLinkConnection"}, "createAliCloudDNSRecord"))
	pattern_ServerlessPrivateLinkConnectionRegionalService_DeleteAliCloudDNSRecord_0                   = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"serverless", "regional", "v1", "privateLinkConnection"}, "deleteAliCloudDNSRecord"))
	pattern_ServerlessPrivateLinkConnectionRegionalService_CreateAWSRoute53Records_0                   = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"serverless", "regional", "v1", "privateLinkConnection"}, "createAWSRoute53Records"))
	pattern_ServerlessPrivateLinkConnectionRegionalService_DeleteAWSRoute53Records_0                   = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"serverless", "regional", "v1", "privateLinkConnection"}, "deleteAWSRoute53Records"))
	pattern_ServerlessPrivateLinkConnectionRegionalService_GetAWSRoute53Change_0                       = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"serverless", "regional", "v1", "privateLinkConnection"}, "getAWSRoute53Change"))
	pattern_ServerlessPrivateLinkConnectionRegionalService_CreateAWSRoute53PrivateHostedZone_0         = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"serverless", "regional", "v1", "privateLinkConnection"}, "createAWSRoute53PrivateHostedZone"))
	pattern_ServerlessPrivateLinkConnectionRegionalService_DeleteAWSRoute53PrivateHostedZone_0         = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"serverless", "regional", "v1", "privateLinkConnection"}, "deleteAWSRoute53PrivateHostedZone"))
	pattern_ServerlessPrivateLinkConnectionRegionalService_CreateAliCloudDNSPrivateHostedZone_0        = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"serverless", "regional", "v1", "privateLinkConnection"}, "createAliCloudDNSPrivateHostedZone"))
	pattern_ServerlessPrivateLinkConnectionRegionalService_DeleteAliCloudDNSPrivateHostedZone_0        = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"serverless", "regional", "v1", "privateLinkConnection"}, "deleteAliCloudDNSPrivateHostedZone"))
	pattern_ServerlessPrivateLinkConnectionRegionalService_AttachVpcToAliCloudDNSPrivateHostedZone_0   = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"serverless", "regional", "v1", "privateLinkConnection"}, "attachVpcToAliCloudDNSPrivateHostedZone"))
	pattern_ServerlessPrivateLinkConnectionRegionalService_DetachVpcFromAliCloudDNSPrivateHostedZone_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"serverless", "regional", "v1", "privateLinkConnection"}, "detachVpcFromAliCloudDNSPrivateHostedZone"))
	pattern_ServerlessPrivateLinkConnectionRegionalService_CreateMSKVPCConnection_0                    = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"serverless", "regional", "v1", "privateLinkConnection"}, "createMSKVPCConnection"))
	pattern_ServerlessPrivateLinkConnectionRegionalService_DeleteMSKVPCConnection_0                    = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"serverless", "regional", "v1", "privateLinkConnection"}, "deleteMSKVPCConnection"))
	pattern_ServerlessPrivateLinkConnectionRegionalService_GetMSKVPCConnection_0                       = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"serverless", "regional", "v1", "privateLinkConnection"}, "getMSKVPCConnection"))
)

var (
	forward_ServerlessPrivateLinkConnectionRegionalService_CreateAWSVpcEndpoint_0                      = runtime.ForwardResponseMessage
	forward_ServerlessPrivateLinkConnectionRegionalService_DescribeAWSVpcEndpoint_0                    = runtime.ForwardResponseMessage
	forward_ServerlessPrivateLinkConnectionRegionalService_DeleteAWSVpcEndpoint_0                      = runtime.ForwardResponseMessage
	forward_ServerlessPrivateLinkConnectionRegionalService_CreateAliCloudVpcEndpoint_0                 = runtime.ForwardResponseMessage
	forward_ServerlessPrivateLinkConnectionRegionalService_DescribeAliCloudVpcEndpoint_0               = runtime.ForwardResponseMessage
	forward_ServerlessPrivateLinkConnectionRegionalService_DeleteAliCloudVpcEndpoint_0                 = runtime.ForwardResponseMessage
	forward_ServerlessPrivateLinkConnectionRegionalService_GetZoneIds_0                                = runtime.ForwardResponseMessage
	forward_ServerlessPrivateLinkConnectionRegionalService_ListAliCloudVpcEndpointZones_0              = runtime.ForwardResponseMessage
	forward_ServerlessPrivateLinkConnectionRegionalService_RemoveAliCloudZoneFromVpcEndpoint_0         = runtime.ForwardResponseMessage
	forward_ServerlessPrivateLinkConnectionRegionalService_CreateAliCloudDNSRecord_0                   = runtime.ForwardResponseMessage
	forward_ServerlessPrivateLinkConnectionRegionalService_DeleteAliCloudDNSRecord_0                   = runtime.ForwardResponseMessage
	forward_ServerlessPrivateLinkConnectionRegionalService_CreateAWSRoute53Records_0                   = runtime.ForwardResponseMessage
	forward_ServerlessPrivateLinkConnectionRegionalService_DeleteAWSRoute53Records_0                   = runtime.ForwardResponseMessage
	forward_ServerlessPrivateLinkConnectionRegionalService_GetAWSRoute53Change_0                       = runtime.ForwardResponseMessage
	forward_ServerlessPrivateLinkConnectionRegionalService_CreateAWSRoute53PrivateHostedZone_0         = runtime.ForwardResponseMessage
	forward_ServerlessPrivateLinkConnectionRegionalService_DeleteAWSRoute53PrivateHostedZone_0         = runtime.ForwardResponseMessage
	forward_ServerlessPrivateLinkConnectionRegionalService_CreateAliCloudDNSPrivateHostedZone_0        = runtime.ForwardResponseMessage
	forward_ServerlessPrivateLinkConnectionRegionalService_DeleteAliCloudDNSPrivateHostedZone_0        = runtime.ForwardResponseMessage
	forward_ServerlessPrivateLinkConnectionRegionalService_AttachVpcToAliCloudDNSPrivateHostedZone_0   = runtime.ForwardResponseMessage
	forward_ServerlessPrivateLinkConnectionRegionalService_DetachVpcFromAliCloudDNSPrivateHostedZone_0 = runtime.ForwardResponseMessage
	forward_ServerlessPrivateLinkConnectionRegionalService_CreateMSKVPCConnection_0                    = runtime.ForwardResponseMessage
	forward_ServerlessPrivateLinkConnectionRegionalService_DeleteMSKVPCConnection_0                    = runtime.ForwardResponseMessage
	forward_ServerlessPrivateLinkConnectionRegionalService_GetMSKVPCConnection_0                       = runtime.ForwardResponseMessage
)