diff --git a/balancer/grpclb/grpc_lb_v1/load_balancer.pb.go b/balancer/grpclb/grpc_lb_v1/load_balancer.pb.go
index b59191a..7381dfc 100644
--- a/balancer/grpclb/grpc_lb_v1/load_balancer.pb.go
+++ b/balancer/grpclb/grpc_lb_v1/load_balancer.pb.go
@@ -4,14 +4,10 @@
 package grpc_lb_v1
 
 import (
-	context "context"
 	fmt "fmt"
 	proto "github.com/golang/protobuf/proto"
 	duration "github.com/golang/protobuf/ptypes/duration"
 	timestamp "github.com/golang/protobuf/ptypes/timestamp"
-	grpc "google.golang.org/grpc"
-	codes "google.golang.org/grpc/codes"
-	status "google.golang.org/grpc/status"
 	math "math"
 )
 
@@ -642,117 +638,3 @@
 	0x6d, 0xe1, 0xbe, 0xfb, 0x2f, 0x00, 0x00, 0xff, 0xff, 0x3f, 0x47, 0x55, 0xac, 0xab, 0x06, 0x00,
 	0x00,
 }
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ context.Context
-var _ grpc.ClientConnInterface
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the grpc package it is being compiled against.
-const _ = grpc.SupportPackageIsVersion6
-
-// LoadBalancerClient is the client API for LoadBalancer service.
-//
-// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
-type LoadBalancerClient interface {
-	// Bidirectional rpc to get a list of servers.
-	BalanceLoad(ctx context.Context, opts ...grpc.CallOption) (LoadBalancer_BalanceLoadClient, error)
-}
-
-type loadBalancerClient struct {
-	cc grpc.ClientConnInterface
-}
-
-func NewLoadBalancerClient(cc grpc.ClientConnInterface) LoadBalancerClient {
-	return &loadBalancerClient{cc}
-}
-
-func (c *loadBalancerClient) BalanceLoad(ctx context.Context, opts ...grpc.CallOption) (LoadBalancer_BalanceLoadClient, error) {
-	stream, err := c.cc.NewStream(ctx, &_LoadBalancer_serviceDesc.Streams[0], "/grpc.lb.v1.LoadBalancer/BalanceLoad", opts...)
-	if err != nil {
-		return nil, err
-	}
-	x := &loadBalancerBalanceLoadClient{stream}
-	return x, nil
-}
-
-type LoadBalancer_BalanceLoadClient interface {
-	Send(*LoadBalanceRequest) error
-	Recv() (*LoadBalanceResponse, error)
-	grpc.ClientStream
-}
-
-type loadBalancerBalanceLoadClient struct {
-	grpc.ClientStream
-}
-
-func (x *loadBalancerBalanceLoadClient) Send(m *LoadBalanceRequest) error {
-	return x.ClientStream.SendMsg(m)
-}
-
-func (x *loadBalancerBalanceLoadClient) Recv() (*LoadBalanceResponse, error) {
-	m := new(LoadBalanceResponse)
-	if err := x.ClientStream.RecvMsg(m); err != nil {
-		return nil, err
-	}
-	return m, nil
-}
-
-// LoadBalancerServer is the server API for LoadBalancer service.
-type LoadBalancerServer interface {
-	// Bidirectional rpc to get a list of servers.
-	BalanceLoad(LoadBalancer_BalanceLoadServer) error
-}
-
-// UnimplementedLoadBalancerServer can be embedded to have forward compatible implementations.
-type UnimplementedLoadBalancerServer struct {
-}
-
-func (*UnimplementedLoadBalancerServer) BalanceLoad(srv LoadBalancer_BalanceLoadServer) error {
-	return status.Errorf(codes.Unimplemented, "method BalanceLoad not implemented")
-}
-
-func RegisterLoadBalancerServer(s *grpc.Server, srv LoadBalancerServer) {
-	s.RegisterService(&_LoadBalancer_serviceDesc, srv)
-}
-
-func _LoadBalancer_BalanceLoad_Handler(srv interface{}, stream grpc.ServerStream) error {
-	return srv.(LoadBalancerServer).BalanceLoad(&loadBalancerBalanceLoadServer{stream})
-}
-
-type LoadBalancer_BalanceLoadServer interface {
-	Send(*LoadBalanceResponse) error
-	Recv() (*LoadBalanceRequest, error)
-	grpc.ServerStream
-}
-
-type loadBalancerBalanceLoadServer struct {
-	grpc.ServerStream
-}
-
-func (x *loadBalancerBalanceLoadServer) Send(m *LoadBalanceResponse) error {
-	return x.ServerStream.SendMsg(m)
-}
-
-func (x *loadBalancerBalanceLoadServer) Recv() (*LoadBalanceRequest, error) {
-	m := new(LoadBalanceRequest)
-	if err := x.ServerStream.RecvMsg(m); err != nil {
-		return nil, err
-	}
-	return m, nil
-}
-
-var _LoadBalancer_serviceDesc = grpc.ServiceDesc{
-	ServiceName: "grpc.lb.v1.LoadBalancer",
-	HandlerType: (*LoadBalancerServer)(nil),
-	Methods:     []grpc.MethodDesc{},
-	Streams: []grpc.StreamDesc{
-		{
-			StreamName:    "BalanceLoad",
-			Handler:       _LoadBalancer_BalanceLoad_Handler,
-			ServerStreams: true,
-			ClientStreams: true,
-		},
-	},
-	Metadata: "grpc/lb/v1/load_balancer.proto",
-}
diff --git a/balancer/grpclb/grpc_lb_v1/load_balancer_grpc.pb.go b/balancer/grpclb/grpc_lb_v1/load_balancer_grpc.pb.go
index e59bf30..62bd5be 100644
--- a/balancer/grpclb/grpc_lb_v1/load_balancer_grpc.pb.go
+++ b/balancer/grpclb/grpc_lb_v1/load_balancer_grpc.pb.go
@@ -3,6 +3,7 @@
 package grpc_lb_v1
 
 import (
+	context "context"
 	grpc "google.golang.org/grpc"
 	codes "google.golang.org/grpc/codes"
 	status "google.golang.org/grpc/status"
@@ -12,6 +13,59 @@
 // is compatible with the grpc package it is being compiled against.
 const _ = grpc.SupportPackageIsVersion7
 
+// LoadBalancerClient is the client API for LoadBalancer service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
+type LoadBalancerClient interface {
+	// Bidirectional rpc to get a list of servers.
+	BalanceLoad(ctx context.Context, opts ...grpc.CallOption) (LoadBalancer_BalanceLoadClient, error)
+}
+
+type loadBalancerClient struct {
+	cc grpc.ClientConnInterface
+}
+
+func NewLoadBalancerClient(cc grpc.ClientConnInterface) LoadBalancerClient {
+	return &loadBalancerClient{cc}
+}
+
+var loadBalancerBalanceLoadStreamDesc = &grpc.StreamDesc{
+	StreamName:    "BalanceLoad",
+	ServerStreams: true,
+	ClientStreams: true,
+}
+
+func (c *loadBalancerClient) BalanceLoad(ctx context.Context, opts ...grpc.CallOption) (LoadBalancer_BalanceLoadClient, error) {
+	stream, err := c.cc.NewStream(ctx, loadBalancerBalanceLoadStreamDesc, "/grpc.lb.v1.LoadBalancer/BalanceLoad", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &loadBalancerBalanceLoadClient{stream}
+	return x, nil
+}
+
+type LoadBalancer_BalanceLoadClient interface {
+	Send(*LoadBalanceRequest) error
+	Recv() (*LoadBalanceResponse, error)
+	grpc.ClientStream
+}
+
+type loadBalancerBalanceLoadClient struct {
+	grpc.ClientStream
+}
+
+func (x *loadBalancerBalanceLoadClient) Send(m *LoadBalanceRequest) error {
+	return x.ClientStream.SendMsg(m)
+}
+
+func (x *loadBalancerBalanceLoadClient) Recv() (*LoadBalanceResponse, error) {
+	m := new(LoadBalanceResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
 // LoadBalancerService is the service API for LoadBalancer service.
 // Fields should be assigned to their respective handler implementations only before
 // RegisterLoadBalancerService is called.  Any unassigned fields will result in the
@@ -25,6 +79,28 @@
 	return s.BalanceLoad(&loadBalancerBalanceLoadServer{stream})
 }
 
+type LoadBalancer_BalanceLoadServer interface {
+	Send(*LoadBalanceResponse) error
+	Recv() (*LoadBalanceRequest, error)
+	grpc.ServerStream
+}
+
+type loadBalancerBalanceLoadServer struct {
+	grpc.ServerStream
+}
+
+func (x *loadBalancerBalanceLoadServer) Send(m *LoadBalanceResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+func (x *loadBalancerBalanceLoadServer) Recv() (*LoadBalanceRequest, error) {
+	m := new(LoadBalanceRequest)
+	if err := x.ServerStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
 // RegisterLoadBalancerService registers a service implementation with a gRPC server.
 func RegisterLoadBalancerService(s grpc.ServiceRegistrar, srv *LoadBalancerService) {
 	srvCopy := *srv
@@ -50,27 +126,28 @@
 	s.RegisterService(&sd, nil)
 }
 
-// NewLoadBalancerService creates a new LoadBalancerService containing the
-// implemented methods of the LoadBalancer service in s.  Any unimplemented
-// methods will result in the gRPC server returning an UNIMPLEMENTED status to the client.
-// This includes situations where the method handler is misspelled or has the wrong
-// signature.  For this reason, this function should be used with great care and
-// is not recommended to be used by most users.
-func NewLoadBalancerService(s interface{}) *LoadBalancerService {
-	ns := &LoadBalancerService{}
-	if h, ok := s.(interface {
-		BalanceLoad(LoadBalancer_BalanceLoadServer) error
-	}); ok {
-		ns.BalanceLoad = h.BalanceLoad
-	}
-	return ns
-}
-
-// UnstableLoadBalancerService is the service API for LoadBalancer service.
+// LoadBalancerServer is the service API for LoadBalancer service.
 // New methods may be added to this interface if they are added to the service
 // definition, which is not a backward-compatible change.  For this reason,
-// use of this type is not recommended.
-type UnstableLoadBalancerService interface {
+// use of this type is not recommended unless you own the service definition.
+type LoadBalancerServer interface {
 	// Bidirectional rpc to get a list of servers.
 	BalanceLoad(LoadBalancer_BalanceLoadServer) error
 }
+
+// UnimplementedLoadBalancerServer can be embedded to have forward compatible implementations of
+// LoadBalancerServer
+type UnimplementedLoadBalancerServer struct {
+}
+
+func (*UnimplementedLoadBalancerServer) BalanceLoad(LoadBalancer_BalanceLoadServer) error {
+	return status.Errorf(codes.Unimplemented, "method BalanceLoad not implemented")
+}
+
+// RegisterLoadBalancerServer registers a service implementation with a gRPC server.
+func RegisterLoadBalancerServer(s grpc.ServiceRegistrar, srv LoadBalancerServer) {
+	str := &LoadBalancerService{
+		BalanceLoad: srv.BalanceLoad,
+	}
+	RegisterLoadBalancerService(s, str)
+}
diff --git a/balancer/rls/internal/proto/grpc_lookup_v1/rls.pb.go b/balancer/rls/internal/proto/grpc_lookup_v1/rls.pb.go
index a3a3f81..7ec1427 100644
--- a/balancer/rls/internal/proto/grpc_lookup_v1/rls.pb.go
+++ b/balancer/rls/internal/proto/grpc_lookup_v1/rls.pb.go
@@ -4,12 +4,8 @@
 package grpc_lookup_v1
 
 import (
-	context "context"
 	fmt "fmt"
 	proto "github.com/golang/protobuf/proto"
-	grpc "google.golang.org/grpc"
-	codes "google.golang.org/grpc/codes"
-	status "google.golang.org/grpc/status"
 	math "math"
 )
 
@@ -180,85 +176,3 @@
 	0x29, 0xa7, 0xcf, 0x5e, 0xb3, 0x1d, 0x27, 0xef, 0x01, 0x00, 0x00, 0xff, 0xff, 0xca, 0x8d, 0x5c,
 	0xc7, 0x39, 0x02, 0x00, 0x00,
 }
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ context.Context
-var _ grpc.ClientConnInterface
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the grpc package it is being compiled against.
-const _ = grpc.SupportPackageIsVersion6
-
-// RouteLookupServiceClient is the client API for RouteLookupService service.
-//
-// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
-type RouteLookupServiceClient interface {
-	// Lookup returns a target for a single key.
-	RouteLookup(ctx context.Context, in *RouteLookupRequest, opts ...grpc.CallOption) (*RouteLookupResponse, error)
-}
-
-type routeLookupServiceClient struct {
-	cc grpc.ClientConnInterface
-}
-
-func NewRouteLookupServiceClient(cc grpc.ClientConnInterface) RouteLookupServiceClient {
-	return &routeLookupServiceClient{cc}
-}
-
-func (c *routeLookupServiceClient) RouteLookup(ctx context.Context, in *RouteLookupRequest, opts ...grpc.CallOption) (*RouteLookupResponse, error) {
-	out := new(RouteLookupResponse)
-	err := c.cc.Invoke(ctx, "/grpc.lookup.v1.RouteLookupService/RouteLookup", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-// RouteLookupServiceServer is the server API for RouteLookupService service.
-type RouteLookupServiceServer interface {
-	// Lookup returns a target for a single key.
-	RouteLookup(context.Context, *RouteLookupRequest) (*RouteLookupResponse, error)
-}
-
-// UnimplementedRouteLookupServiceServer can be embedded to have forward compatible implementations.
-type UnimplementedRouteLookupServiceServer struct {
-}
-
-func (*UnimplementedRouteLookupServiceServer) RouteLookup(ctx context.Context, req *RouteLookupRequest) (*RouteLookupResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method RouteLookup not implemented")
-}
-
-func RegisterRouteLookupServiceServer(s *grpc.Server, srv RouteLookupServiceServer) {
-	s.RegisterService(&_RouteLookupService_serviceDesc, srv)
-}
-
-func _RouteLookupService_RouteLookup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(RouteLookupRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(RouteLookupServiceServer).RouteLookup(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/grpc.lookup.v1.RouteLookupService/RouteLookup",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(RouteLookupServiceServer).RouteLookup(ctx, req.(*RouteLookupRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-var _RouteLookupService_serviceDesc = grpc.ServiceDesc{
-	ServiceName: "grpc.lookup.v1.RouteLookupService",
-	HandlerType: (*RouteLookupServiceServer)(nil),
-	Methods: []grpc.MethodDesc{
-		{
-			MethodName: "RouteLookup",
-			Handler:    _RouteLookupService_RouteLookup_Handler,
-		},
-	},
-	Streams:  []grpc.StreamDesc{},
-	Metadata: "grpc/lookup/v1/rls.proto",
-}
diff --git a/balancer/rls/internal/proto/grpc_lookup_v1/rls_grpc.pb.go b/balancer/rls/internal/proto/grpc_lookup_v1/rls_grpc.pb.go
index 4a9f270..6952ce6 100644
--- a/balancer/rls/internal/proto/grpc_lookup_v1/rls_grpc.pb.go
+++ b/balancer/rls/internal/proto/grpc_lookup_v1/rls_grpc.pb.go
@@ -13,6 +13,35 @@
 // is compatible with the grpc package it is being compiled against.
 const _ = grpc.SupportPackageIsVersion7
 
+// RouteLookupServiceClient is the client API for RouteLookupService service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
+type RouteLookupServiceClient interface {
+	// Lookup returns a target for a single key.
+	RouteLookup(ctx context.Context, in *RouteLookupRequest, opts ...grpc.CallOption) (*RouteLookupResponse, error)
+}
+
+type routeLookupServiceClient struct {
+	cc grpc.ClientConnInterface
+}
+
+func NewRouteLookupServiceClient(cc grpc.ClientConnInterface) RouteLookupServiceClient {
+	return &routeLookupServiceClient{cc}
+}
+
+var routeLookupServiceRouteLookupStreamDesc = &grpc.StreamDesc{
+	StreamName: "RouteLookup",
+}
+
+func (c *routeLookupServiceClient) RouteLookup(ctx context.Context, in *RouteLookupRequest, opts ...grpc.CallOption) (*RouteLookupResponse, error) {
+	out := new(RouteLookupResponse)
+	err := c.cc.Invoke(ctx, "/grpc.lookup.v1.RouteLookupService/RouteLookup", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // RouteLookupServiceService is the service API for RouteLookupService service.
 // Fields should be assigned to their respective handler implementations only before
 // RegisterRouteLookupServiceService is called.  Any unassigned fields will result in the
@@ -63,27 +92,28 @@
 	s.RegisterService(&sd, nil)
 }
 
-// NewRouteLookupServiceService creates a new RouteLookupServiceService containing the
-// implemented methods of the RouteLookupService service in s.  Any unimplemented
-// methods will result in the gRPC server returning an UNIMPLEMENTED status to the client.
-// This includes situations where the method handler is misspelled or has the wrong
-// signature.  For this reason, this function should be used with great care and
-// is not recommended to be used by most users.
-func NewRouteLookupServiceService(s interface{}) *RouteLookupServiceService {
-	ns := &RouteLookupServiceService{}
-	if h, ok := s.(interface {
-		RouteLookup(context.Context, *RouteLookupRequest) (*RouteLookupResponse, error)
-	}); ok {
-		ns.RouteLookup = h.RouteLookup
-	}
-	return ns
-}
-
-// UnstableRouteLookupServiceService is the service API for RouteLookupService service.
+// RouteLookupServiceServer is the service API for RouteLookupService service.
 // New methods may be added to this interface if they are added to the service
 // definition, which is not a backward-compatible change.  For this reason,
-// use of this type is not recommended.
-type UnstableRouteLookupServiceService interface {
+// use of this type is not recommended unless you own the service definition.
+type RouteLookupServiceServer interface {
 	// Lookup returns a target for a single key.
 	RouteLookup(context.Context, *RouteLookupRequest) (*RouteLookupResponse, error)
 }
+
+// UnimplementedRouteLookupServiceServer can be embedded to have forward compatible implementations of
+// RouteLookupServiceServer
+type UnimplementedRouteLookupServiceServer struct {
+}
+
+func (*UnimplementedRouteLookupServiceServer) RouteLookup(context.Context, *RouteLookupRequest) (*RouteLookupResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method RouteLookup not implemented")
+}
+
+// RegisterRouteLookupServiceServer registers a service implementation with a gRPC server.
+func RegisterRouteLookupServiceServer(s grpc.ServiceRegistrar, srv RouteLookupServiceServer) {
+	str := &RouteLookupServiceService{
+		RouteLookup: srv.RouteLookup,
+	}
+	RegisterRouteLookupServiceService(s, str)
+}
diff --git a/benchmark/benchmark.go b/benchmark/benchmark.go
index d2783a8..5794aeb 100644
--- a/benchmark/benchmark.go
+++ b/benchmark/benchmark.go
@@ -63,7 +63,13 @@
 
 type testServer struct{}
 
-var _ testpb.UnstableBenchmarkServiceService = (*testServer)(nil)
+func (s *testServer) Svc() *testpb.BenchmarkServiceService {
+	return &testpb.BenchmarkServiceService{
+		UnaryCall:                  s.UnaryCall,
+		StreamingCall:              s.StreamingCall,
+		UnconstrainedStreamingCall: s.UnconstrainedStreamingCall,
+	}
+}
 
 func (s *testServer) UnaryCall(ctx context.Context, in *testpb.SimpleRequest) (*testpb.SimpleResponse, error) {
 	return &testpb.SimpleResponse{
@@ -147,7 +153,13 @@
 	respSize int32
 }
 
-var _ testpb.UnstableBenchmarkServiceService = (*byteBufServer)(nil)
+func (s *byteBufServer) Svc() *testpb.BenchmarkServiceService {
+	return &testpb.BenchmarkServiceService{
+		UnaryCall:                  s.UnaryCall,
+		StreamingCall:              s.StreamingCall,
+		UnconstrainedStreamingCall: s.UnconstrainedStreamingCall,
+	}
+}
 
 // UnaryCall is an empty function and is not used for benchmark.
 // If bytebuf UnaryCall benchmark is needed later, the function body needs to be updated.
@@ -212,13 +224,13 @@
 	s := grpc.NewServer(opts...)
 	switch info.Type {
 	case "protobuf":
-		testpb.RegisterBenchmarkServiceService(s, testpb.NewBenchmarkServiceService(&testServer{}))
+		testpb.RegisterBenchmarkServiceService(s, (&testServer{}).Svc())
 	case "bytebuf":
 		respSize, ok := info.Metadata.(int32)
 		if !ok {
 			logger.Fatalf("failed to StartServer, invalid metadata: %v, for Type: %v", info.Metadata, info.Type)
 		}
-		testpb.RegisterBenchmarkServiceService(s, testpb.NewBenchmarkServiceService(&byteBufServer{respSize: respSize}))
+		testpb.RegisterBenchmarkServiceService(s, (&byteBufServer{respSize: respSize}).Svc())
 	default:
 		logger.Fatalf("failed to StartServer, unknown Type: %v", info.Type)
 	}
diff --git a/benchmark/grpc_testing/services_grpc.pb.go b/benchmark/grpc_testing/services_grpc.pb.go
index 37d637d..81e9ed6 100644
--- a/benchmark/grpc_testing/services_grpc.pb.go
+++ b/benchmark/grpc_testing/services_grpc.pb.go
@@ -253,48 +253,6 @@
 	s.RegisterService(&sd, nil)
 }
 
-// NewBenchmarkServiceService creates a new BenchmarkServiceService containing the
-// implemented methods of the BenchmarkService service in s.  Any unimplemented
-// methods will result in the gRPC server returning an UNIMPLEMENTED status to the client.
-// This includes situations where the method handler is misspelled or has the wrong
-// signature.  For this reason, this function should be used with great care and
-// is not recommended to be used by most users.
-func NewBenchmarkServiceService(s interface{}) *BenchmarkServiceService {
-	ns := &BenchmarkServiceService{}
-	if h, ok := s.(interface {
-		UnaryCall(context.Context, *SimpleRequest) (*SimpleResponse, error)
-	}); ok {
-		ns.UnaryCall = h.UnaryCall
-	}
-	if h, ok := s.(interface {
-		StreamingCall(BenchmarkService_StreamingCallServer) error
-	}); ok {
-		ns.StreamingCall = h.StreamingCall
-	}
-	if h, ok := s.(interface {
-		UnconstrainedStreamingCall(BenchmarkService_UnconstrainedStreamingCallServer) error
-	}); ok {
-		ns.UnconstrainedStreamingCall = h.UnconstrainedStreamingCall
-	}
-	return ns
-}
-
-// UnstableBenchmarkServiceService is the service API for BenchmarkService service.
-// New methods may be added to this interface if they are added to the service
-// definition, which is not a backward-compatible change.  For this reason,
-// use of this type is not recommended.
-type UnstableBenchmarkServiceService interface {
-	// One request followed by one response.
-	// The server returns the client payload as-is.
-	UnaryCall(context.Context, *SimpleRequest) (*SimpleResponse, error)
-	// One request followed by one response.
-	// The server returns the client payload as-is.
-	StreamingCall(BenchmarkService_StreamingCallServer) error
-	// Unconstrainted streaming.
-	// Both server and client keep sending & receiving simultaneously.
-	UnconstrainedStreamingCall(BenchmarkService_UnconstrainedStreamingCallServer) error
-}
-
 // WorkerServiceClient is the client API for WorkerService service.
 //
 // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
@@ -591,59 +549,3 @@
 
 	s.RegisterService(&sd, nil)
 }
-
-// NewWorkerServiceService creates a new WorkerServiceService containing the
-// implemented methods of the WorkerService service in s.  Any unimplemented
-// methods will result in the gRPC server returning an UNIMPLEMENTED status to the client.
-// This includes situations where the method handler is misspelled or has the wrong
-// signature.  For this reason, this function should be used with great care and
-// is not recommended to be used by most users.
-func NewWorkerServiceService(s interface{}) *WorkerServiceService {
-	ns := &WorkerServiceService{}
-	if h, ok := s.(interface {
-		RunServer(WorkerService_RunServerServer) error
-	}); ok {
-		ns.RunServer = h.RunServer
-	}
-	if h, ok := s.(interface {
-		RunClient(WorkerService_RunClientServer) error
-	}); ok {
-		ns.RunClient = h.RunClient
-	}
-	if h, ok := s.(interface {
-		CoreCount(context.Context, *CoreRequest) (*CoreResponse, error)
-	}); ok {
-		ns.CoreCount = h.CoreCount
-	}
-	if h, ok := s.(interface {
-		QuitWorker(context.Context, *Void) (*Void, error)
-	}); ok {
-		ns.QuitWorker = h.QuitWorker
-	}
-	return ns
-}
-
-// UnstableWorkerServiceService is the service API for WorkerService service.
-// New methods may be added to this interface if they are added to the service
-// definition, which is not a backward-compatible change.  For this reason,
-// use of this type is not recommended.
-type UnstableWorkerServiceService interface {
-	// Start server with specified workload.
-	// First request sent specifies the ServerConfig followed by ServerStatus
-	// response. After that, a "Mark" can be sent anytime to request the latest
-	// stats. Closing the stream will initiate shutdown of the test server
-	// and once the shutdown has finished, the OK status is sent to terminate
-	// this RPC.
-	RunServer(WorkerService_RunServerServer) error
-	// Start client with specified workload.
-	// First request sent specifies the ClientConfig followed by ClientStatus
-	// response. After that, a "Mark" can be sent anytime to request the latest
-	// stats. Closing the stream will initiate shutdown of the test client
-	// and once the shutdown has finished, the OK status is sent to terminate
-	// this RPC.
-	RunClient(WorkerService_RunClientServer) error
-	// Just return the core count - unary call
-	CoreCount(context.Context, *CoreRequest) (*CoreResponse, error)
-	// Quit this worker
-	QuitWorker(context.Context, *Void) (*Void, error)
-}
diff --git a/benchmark/worker/main.go b/benchmark/worker/main.go
index 891cd01..71a1fb6 100644
--- a/benchmark/worker/main.go
+++ b/benchmark/worker/main.go
@@ -79,7 +79,14 @@
 	serverPort int
 }
 
-var _ testpb.UnstableWorkerServiceService = (*workerServer)(nil)
+func (s *workerServer) Svc() *testpb.WorkerServiceService {
+	return &testpb.WorkerServiceService{
+		RunServer:  s.RunServer,
+		RunClient:  s.RunClient,
+		CoreCount:  s.CoreCount,
+		QuitWorker: s.QuitWorker,
+	}
+}
 
 func (s *workerServer) RunServer(stream testpb.WorkerService_RunServerServer) error {
 	var bs *benchmarkServer
@@ -210,10 +217,10 @@
 
 	s := grpc.NewServer()
 	stop := make(chan bool)
-	testpb.RegisterWorkerServiceService(s, testpb.NewWorkerServiceService(&workerServer{
+	testpb.RegisterWorkerServiceService(s, (&workerServer{
 		stop:       stop,
 		serverPort: *serverPort,
-	}))
+	}).Svc())
 
 	go func() {
 		<-stop
diff --git a/channelz/grpc_channelz_v1/channelz.pb.go b/channelz/grpc_channelz_v1/channelz.pb.go
index 34bfa5a..9c364e1 100644
--- a/channelz/grpc_channelz_v1/channelz.pb.go
+++ b/channelz/grpc_channelz_v1/channelz.pb.go
@@ -4,16 +4,12 @@
 package grpc_channelz_v1
 
 import (
-	context "context"
 	fmt "fmt"
 	proto "github.com/golang/protobuf/proto"
 	any "github.com/golang/protobuf/ptypes/any"
 	duration "github.com/golang/protobuf/ptypes/duration"
 	timestamp "github.com/golang/protobuf/ptypes/timestamp"
 	wrappers "github.com/golang/protobuf/ptypes/wrappers"
-	grpc "google.golang.org/grpc"
-	codes "google.golang.org/grpc/codes"
-	status "google.golang.org/grpc/status"
 	math "math"
 )
 
@@ -2925,315 +2921,3 @@
 	0xd3, 0x77, 0xc6, 0x68, 0xe7, 0x3c, 0xcf, 0x4f, 0xf3, 0x5f, 0xfd, 0x37, 0x00, 0x00, 0xff, 0xff,
 	0x54, 0xae, 0x0b, 0x93, 0xdf, 0x1f, 0x00, 0x00,
 }
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ context.Context
-var _ grpc.ClientConnInterface
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the grpc package it is being compiled against.
-const _ = grpc.SupportPackageIsVersion6
-
-// ChannelzClient is the client API for Channelz service.
-//
-// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
-type ChannelzClient interface {
-	// Gets all root channels (i.e. channels the application has directly
-	// created). This does not include subchannels nor non-top level channels.
-	GetTopChannels(ctx context.Context, in *GetTopChannelsRequest, opts ...grpc.CallOption) (*GetTopChannelsResponse, error)
-	// Gets all servers that exist in the process.
-	GetServers(ctx context.Context, in *GetServersRequest, opts ...grpc.CallOption) (*GetServersResponse, error)
-	// Returns a single Server, or else a NOT_FOUND code.
-	GetServer(ctx context.Context, in *GetServerRequest, opts ...grpc.CallOption) (*GetServerResponse, error)
-	// Gets all server sockets that exist in the process.
-	GetServerSockets(ctx context.Context, in *GetServerSocketsRequest, opts ...grpc.CallOption) (*GetServerSocketsResponse, error)
-	// Returns a single Channel, or else a NOT_FOUND code.
-	GetChannel(ctx context.Context, in *GetChannelRequest, opts ...grpc.CallOption) (*GetChannelResponse, error)
-	// Returns a single Subchannel, or else a NOT_FOUND code.
-	GetSubchannel(ctx context.Context, in *GetSubchannelRequest, opts ...grpc.CallOption) (*GetSubchannelResponse, error)
-	// Returns a single Socket or else a NOT_FOUND code.
-	GetSocket(ctx context.Context, in *GetSocketRequest, opts ...grpc.CallOption) (*GetSocketResponse, error)
-}
-
-type channelzClient struct {
-	cc grpc.ClientConnInterface
-}
-
-func NewChannelzClient(cc grpc.ClientConnInterface) ChannelzClient {
-	return &channelzClient{cc}
-}
-
-func (c *channelzClient) GetTopChannels(ctx context.Context, in *GetTopChannelsRequest, opts ...grpc.CallOption) (*GetTopChannelsResponse, error) {
-	out := new(GetTopChannelsResponse)
-	err := c.cc.Invoke(ctx, "/grpc.channelz.v1.Channelz/GetTopChannels", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *channelzClient) GetServers(ctx context.Context, in *GetServersRequest, opts ...grpc.CallOption) (*GetServersResponse, error) {
-	out := new(GetServersResponse)
-	err := c.cc.Invoke(ctx, "/grpc.channelz.v1.Channelz/GetServers", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *channelzClient) GetServer(ctx context.Context, in *GetServerRequest, opts ...grpc.CallOption) (*GetServerResponse, error) {
-	out := new(GetServerResponse)
-	err := c.cc.Invoke(ctx, "/grpc.channelz.v1.Channelz/GetServer", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *channelzClient) GetServerSockets(ctx context.Context, in *GetServerSocketsRequest, opts ...grpc.CallOption) (*GetServerSocketsResponse, error) {
-	out := new(GetServerSocketsResponse)
-	err := c.cc.Invoke(ctx, "/grpc.channelz.v1.Channelz/GetServerSockets", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *channelzClient) GetChannel(ctx context.Context, in *GetChannelRequest, opts ...grpc.CallOption) (*GetChannelResponse, error) {
-	out := new(GetChannelResponse)
-	err := c.cc.Invoke(ctx, "/grpc.channelz.v1.Channelz/GetChannel", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *channelzClient) GetSubchannel(ctx context.Context, in *GetSubchannelRequest, opts ...grpc.CallOption) (*GetSubchannelResponse, error) {
-	out := new(GetSubchannelResponse)
-	err := c.cc.Invoke(ctx, "/grpc.channelz.v1.Channelz/GetSubchannel", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *channelzClient) GetSocket(ctx context.Context, in *GetSocketRequest, opts ...grpc.CallOption) (*GetSocketResponse, error) {
-	out := new(GetSocketResponse)
-	err := c.cc.Invoke(ctx, "/grpc.channelz.v1.Channelz/GetSocket", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-// ChannelzServer is the server API for Channelz service.
-type ChannelzServer interface {
-	// Gets all root channels (i.e. channels the application has directly
-	// created). This does not include subchannels nor non-top level channels.
-	GetTopChannels(context.Context, *GetTopChannelsRequest) (*GetTopChannelsResponse, error)
-	// Gets all servers that exist in the process.
-	GetServers(context.Context, *GetServersRequest) (*GetServersResponse, error)
-	// Returns a single Server, or else a NOT_FOUND code.
-	GetServer(context.Context, *GetServerRequest) (*GetServerResponse, error)
-	// Gets all server sockets that exist in the process.
-	GetServerSockets(context.Context, *GetServerSocketsRequest) (*GetServerSocketsResponse, error)
-	// Returns a single Channel, or else a NOT_FOUND code.
-	GetChannel(context.Context, *GetChannelRequest) (*GetChannelResponse, error)
-	// Returns a single Subchannel, or else a NOT_FOUND code.
-	GetSubchannel(context.Context, *GetSubchannelRequest) (*GetSubchannelResponse, error)
-	// Returns a single Socket or else a NOT_FOUND code.
-	GetSocket(context.Context, *GetSocketRequest) (*GetSocketResponse, error)
-}
-
-// UnimplementedChannelzServer can be embedded to have forward compatible implementations.
-type UnimplementedChannelzServer struct {
-}
-
-func (*UnimplementedChannelzServer) GetTopChannels(ctx context.Context, req *GetTopChannelsRequest) (*GetTopChannelsResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method GetTopChannels not implemented")
-}
-func (*UnimplementedChannelzServer) GetServers(ctx context.Context, req *GetServersRequest) (*GetServersResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method GetServers not implemented")
-}
-func (*UnimplementedChannelzServer) GetServer(ctx context.Context, req *GetServerRequest) (*GetServerResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method GetServer not implemented")
-}
-func (*UnimplementedChannelzServer) GetServerSockets(ctx context.Context, req *GetServerSocketsRequest) (*GetServerSocketsResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method GetServerSockets not implemented")
-}
-func (*UnimplementedChannelzServer) GetChannel(ctx context.Context, req *GetChannelRequest) (*GetChannelResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method GetChannel not implemented")
-}
-func (*UnimplementedChannelzServer) GetSubchannel(ctx context.Context, req *GetSubchannelRequest) (*GetSubchannelResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method GetSubchannel not implemented")
-}
-func (*UnimplementedChannelzServer) GetSocket(ctx context.Context, req *GetSocketRequest) (*GetSocketResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method GetSocket not implemented")
-}
-
-func RegisterChannelzServer(s *grpc.Server, srv ChannelzServer) {
-	s.RegisterService(&_Channelz_serviceDesc, srv)
-}
-
-func _Channelz_GetTopChannels_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(GetTopChannelsRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(ChannelzServer).GetTopChannels(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/grpc.channelz.v1.Channelz/GetTopChannels",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(ChannelzServer).GetTopChannels(ctx, req.(*GetTopChannelsRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _Channelz_GetServers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(GetServersRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(ChannelzServer).GetServers(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/grpc.channelz.v1.Channelz/GetServers",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(ChannelzServer).GetServers(ctx, req.(*GetServersRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _Channelz_GetServer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(GetServerRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(ChannelzServer).GetServer(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/grpc.channelz.v1.Channelz/GetServer",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(ChannelzServer).GetServer(ctx, req.(*GetServerRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _Channelz_GetServerSockets_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(GetServerSocketsRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(ChannelzServer).GetServerSockets(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/grpc.channelz.v1.Channelz/GetServerSockets",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(ChannelzServer).GetServerSockets(ctx, req.(*GetServerSocketsRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _Channelz_GetChannel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(GetChannelRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(ChannelzServer).GetChannel(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/grpc.channelz.v1.Channelz/GetChannel",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(ChannelzServer).GetChannel(ctx, req.(*GetChannelRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _Channelz_GetSubchannel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(GetSubchannelRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(ChannelzServer).GetSubchannel(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/grpc.channelz.v1.Channelz/GetSubchannel",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(ChannelzServer).GetSubchannel(ctx, req.(*GetSubchannelRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _Channelz_GetSocket_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(GetSocketRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(ChannelzServer).GetSocket(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/grpc.channelz.v1.Channelz/GetSocket",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(ChannelzServer).GetSocket(ctx, req.(*GetSocketRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-var _Channelz_serviceDesc = grpc.ServiceDesc{
-	ServiceName: "grpc.channelz.v1.Channelz",
-	HandlerType: (*ChannelzServer)(nil),
-	Methods: []grpc.MethodDesc{
-		{
-			MethodName: "GetTopChannels",
-			Handler:    _Channelz_GetTopChannels_Handler,
-		},
-		{
-			MethodName: "GetServers",
-			Handler:    _Channelz_GetServers_Handler,
-		},
-		{
-			MethodName: "GetServer",
-			Handler:    _Channelz_GetServer_Handler,
-		},
-		{
-			MethodName: "GetServerSockets",
-			Handler:    _Channelz_GetServerSockets_Handler,
-		},
-		{
-			MethodName: "GetChannel",
-			Handler:    _Channelz_GetChannel_Handler,
-		},
-		{
-			MethodName: "GetSubchannel",
-			Handler:    _Channelz_GetSubchannel_Handler,
-		},
-		{
-			MethodName: "GetSocket",
-			Handler:    _Channelz_GetSocket_Handler,
-		},
-	},
-	Streams:  []grpc.StreamDesc{},
-	Metadata: "grpc/channelz/v1/channelz.proto",
-}
diff --git a/channelz/grpc_channelz_v1/channelz_grpc.pb.go b/channelz/grpc_channelz_v1/channelz_grpc.pb.go
index bc6083b..791151f 100644
--- a/channelz/grpc_channelz_v1/channelz_grpc.pb.go
+++ b/channelz/grpc_channelz_v1/channelz_grpc.pb.go
@@ -13,6 +13,126 @@
 // is compatible with the grpc package it is being compiled against.
 const _ = grpc.SupportPackageIsVersion7
 
+// ChannelzClient is the client API for Channelz service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
+type ChannelzClient interface {
+	// Gets all root channels (i.e. channels the application has directly
+	// created). This does not include subchannels nor non-top level channels.
+	GetTopChannels(ctx context.Context, in *GetTopChannelsRequest, opts ...grpc.CallOption) (*GetTopChannelsResponse, error)
+	// Gets all servers that exist in the process.
+	GetServers(ctx context.Context, in *GetServersRequest, opts ...grpc.CallOption) (*GetServersResponse, error)
+	// Returns a single Server, or else a NOT_FOUND code.
+	GetServer(ctx context.Context, in *GetServerRequest, opts ...grpc.CallOption) (*GetServerResponse, error)
+	// Gets all server sockets that exist in the process.
+	GetServerSockets(ctx context.Context, in *GetServerSocketsRequest, opts ...grpc.CallOption) (*GetServerSocketsResponse, error)
+	// Returns a single Channel, or else a NOT_FOUND code.
+	GetChannel(ctx context.Context, in *GetChannelRequest, opts ...grpc.CallOption) (*GetChannelResponse, error)
+	// Returns a single Subchannel, or else a NOT_FOUND code.
+	GetSubchannel(ctx context.Context, in *GetSubchannelRequest, opts ...grpc.CallOption) (*GetSubchannelResponse, error)
+	// Returns a single Socket or else a NOT_FOUND code.
+	GetSocket(ctx context.Context, in *GetSocketRequest, opts ...grpc.CallOption) (*GetSocketResponse, error)
+}
+
+type channelzClient struct {
+	cc grpc.ClientConnInterface
+}
+
+func NewChannelzClient(cc grpc.ClientConnInterface) ChannelzClient {
+	return &channelzClient{cc}
+}
+
+var channelzGetTopChannelsStreamDesc = &grpc.StreamDesc{
+	StreamName: "GetTopChannels",
+}
+
+func (c *channelzClient) GetTopChannels(ctx context.Context, in *GetTopChannelsRequest, opts ...grpc.CallOption) (*GetTopChannelsResponse, error) {
+	out := new(GetTopChannelsResponse)
+	err := c.cc.Invoke(ctx, "/grpc.channelz.v1.Channelz/GetTopChannels", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+var channelzGetServersStreamDesc = &grpc.StreamDesc{
+	StreamName: "GetServers",
+}
+
+func (c *channelzClient) GetServers(ctx context.Context, in *GetServersRequest, opts ...grpc.CallOption) (*GetServersResponse, error) {
+	out := new(GetServersResponse)
+	err := c.cc.Invoke(ctx, "/grpc.channelz.v1.Channelz/GetServers", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+var channelzGetServerStreamDesc = &grpc.StreamDesc{
+	StreamName: "GetServer",
+}
+
+func (c *channelzClient) GetServer(ctx context.Context, in *GetServerRequest, opts ...grpc.CallOption) (*GetServerResponse, error) {
+	out := new(GetServerResponse)
+	err := c.cc.Invoke(ctx, "/grpc.channelz.v1.Channelz/GetServer", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+var channelzGetServerSocketsStreamDesc = &grpc.StreamDesc{
+	StreamName: "GetServerSockets",
+}
+
+func (c *channelzClient) GetServerSockets(ctx context.Context, in *GetServerSocketsRequest, opts ...grpc.CallOption) (*GetServerSocketsResponse, error) {
+	out := new(GetServerSocketsResponse)
+	err := c.cc.Invoke(ctx, "/grpc.channelz.v1.Channelz/GetServerSockets", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+var channelzGetChannelStreamDesc = &grpc.StreamDesc{
+	StreamName: "GetChannel",
+}
+
+func (c *channelzClient) GetChannel(ctx context.Context, in *GetChannelRequest, opts ...grpc.CallOption) (*GetChannelResponse, error) {
+	out := new(GetChannelResponse)
+	err := c.cc.Invoke(ctx, "/grpc.channelz.v1.Channelz/GetChannel", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+var channelzGetSubchannelStreamDesc = &grpc.StreamDesc{
+	StreamName: "GetSubchannel",
+}
+
+func (c *channelzClient) GetSubchannel(ctx context.Context, in *GetSubchannelRequest, opts ...grpc.CallOption) (*GetSubchannelResponse, error) {
+	out := new(GetSubchannelResponse)
+	err := c.cc.Invoke(ctx, "/grpc.channelz.v1.Channelz/GetSubchannel", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+var channelzGetSocketStreamDesc = &grpc.StreamDesc{
+	StreamName: "GetSocket",
+}
+
+func (c *channelzClient) GetSocket(ctx context.Context, in *GetSocketRequest, opts ...grpc.CallOption) (*GetSocketResponse, error) {
+	out := new(GetSocketResponse)
+	err := c.cc.Invoke(ctx, "/grpc.channelz.v1.Channelz/GetSocket", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // ChannelzService is the service API for Channelz service.
 // Fields should be assigned to their respective handler implementations only before
 // RegisterChannelzService is called.  Any unassigned fields will result in the
@@ -232,57 +352,11 @@
 	s.RegisterService(&sd, nil)
 }
 
-// NewChannelzService creates a new ChannelzService containing the
-// implemented methods of the Channelz service in s.  Any unimplemented
-// methods will result in the gRPC server returning an UNIMPLEMENTED status to the client.
-// This includes situations where the method handler is misspelled or has the wrong
-// signature.  For this reason, this function should be used with great care and
-// is not recommended to be used by most users.
-func NewChannelzService(s interface{}) *ChannelzService {
-	ns := &ChannelzService{}
-	if h, ok := s.(interface {
-		GetTopChannels(context.Context, *GetTopChannelsRequest) (*GetTopChannelsResponse, error)
-	}); ok {
-		ns.GetTopChannels = h.GetTopChannels
-	}
-	if h, ok := s.(interface {
-		GetServers(context.Context, *GetServersRequest) (*GetServersResponse, error)
-	}); ok {
-		ns.GetServers = h.GetServers
-	}
-	if h, ok := s.(interface {
-		GetServer(context.Context, *GetServerRequest) (*GetServerResponse, error)
-	}); ok {
-		ns.GetServer = h.GetServer
-	}
-	if h, ok := s.(interface {
-		GetServerSockets(context.Context, *GetServerSocketsRequest) (*GetServerSocketsResponse, error)
-	}); ok {
-		ns.GetServerSockets = h.GetServerSockets
-	}
-	if h, ok := s.(interface {
-		GetChannel(context.Context, *GetChannelRequest) (*GetChannelResponse, error)
-	}); ok {
-		ns.GetChannel = h.GetChannel
-	}
-	if h, ok := s.(interface {
-		GetSubchannel(context.Context, *GetSubchannelRequest) (*GetSubchannelResponse, error)
-	}); ok {
-		ns.GetSubchannel = h.GetSubchannel
-	}
-	if h, ok := s.(interface {
-		GetSocket(context.Context, *GetSocketRequest) (*GetSocketResponse, error)
-	}); ok {
-		ns.GetSocket = h.GetSocket
-	}
-	return ns
-}
-
-// UnstableChannelzService is the service API for Channelz service.
+// ChannelzServer is the service API for Channelz service.
 // New methods may be added to this interface if they are added to the service
 // definition, which is not a backward-compatible change.  For this reason,
-// use of this type is not recommended.
-type UnstableChannelzService interface {
+// use of this type is not recommended unless you own the service definition.
+type ChannelzServer interface {
 	// Gets all root channels (i.e. channels the application has directly
 	// created). This does not include subchannels nor non-top level channels.
 	GetTopChannels(context.Context, *GetTopChannelsRequest) (*GetTopChannelsResponse, error)
@@ -299,3 +373,44 @@
 	// Returns a single Socket or else a NOT_FOUND code.
 	GetSocket(context.Context, *GetSocketRequest) (*GetSocketResponse, error)
 }
+
+// UnimplementedChannelzServer can be embedded to have forward compatible implementations of
+// ChannelzServer
+type UnimplementedChannelzServer struct {
+}
+
+func (*UnimplementedChannelzServer) GetTopChannels(context.Context, *GetTopChannelsRequest) (*GetTopChannelsResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method GetTopChannels not implemented")
+}
+func (*UnimplementedChannelzServer) GetServers(context.Context, *GetServersRequest) (*GetServersResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method GetServers not implemented")
+}
+func (*UnimplementedChannelzServer) GetServer(context.Context, *GetServerRequest) (*GetServerResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method GetServer not implemented")
+}
+func (*UnimplementedChannelzServer) GetServerSockets(context.Context, *GetServerSocketsRequest) (*GetServerSocketsResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method GetServerSockets not implemented")
+}
+func (*UnimplementedChannelzServer) GetChannel(context.Context, *GetChannelRequest) (*GetChannelResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method GetChannel not implemented")
+}
+func (*UnimplementedChannelzServer) GetSubchannel(context.Context, *GetSubchannelRequest) (*GetSubchannelResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method GetSubchannel not implemented")
+}
+func (*UnimplementedChannelzServer) GetSocket(context.Context, *GetSocketRequest) (*GetSocketResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method GetSocket not implemented")
+}
+
+// RegisterChannelzServer registers a service implementation with a gRPC server.
+func RegisterChannelzServer(s grpc.ServiceRegistrar, srv ChannelzServer) {
+	str := &ChannelzService{
+		GetTopChannels:   srv.GetTopChannels,
+		GetServers:       srv.GetServers,
+		GetServer:        srv.GetServer,
+		GetServerSockets: srv.GetServerSockets,
+		GetChannel:       srv.GetChannel,
+		GetSubchannel:    srv.GetSubchannel,
+		GetSocket:        srv.GetSocket,
+	}
+	RegisterChannelzService(s, str)
+}
diff --git a/cmd/protoc-gen-go-grpc/README.md b/cmd/protoc-gen-go-grpc/README.md
index 6d047f1..d5b0a3b 100644
--- a/cmd/protoc-gen-go-grpc/README.md
+++ b/cmd/protoc-gen-go-grpc/README.md
@@ -98,7 +98,7 @@
 
 // Optional; not recommended: to guarantee myEchoService fully implements
 // EchoService:
-var _ pb.UnstableEchoService = &myEchoService{}
+var _ pb.EchoServer = &myEchoService{}
 
 func main() {
      // ...
@@ -111,7 +111,7 @@
 
 
      // Optional: to gracefully detect missing methods:
-     if _, ok := &myEchoService{}.(pb.UnstableEchoService); !ok {
+     if _, ok := &myEchoService{}.(pb.EchoServer); !ok {
         fmt.Println("myEchoService does not implement all methods of EchoService.")
      }
 
diff --git a/cmd/protoc-gen-go-grpc/grpc.go b/cmd/protoc-gen-go-grpc/grpc.go
index 13bd755..358bae2 100644
--- a/cmd/protoc-gen-go-grpc/grpc.go
+++ b/cmd/protoc-gen-go-grpc/grpc.go
@@ -63,14 +63,13 @@
 	for _, service := range file.Services {
 		genClient(gen, file, g, service)
 		genService(gen, file, g, service)
-		genUnstableServiceInterface(gen, file, g, service)
+		if *genUnstableServerInterfaces {
+			genUnstableServerInterface(gen, file, g, service)
+		}
 	}
 }
 
 func genClient(gen *protogen.Plugin, file *protogen.File, g *protogen.GeneratedFile, service *protogen.Service) {
-	if *migrationMode {
-		return
-	}
 	clientName := service.GoName + "Client"
 
 	g.P("// ", clientName, " is the client API for ", service.GoName, " service.")
@@ -258,9 +257,6 @@
 
 	// Service registration.
 	genRegisterFunction(gen, file, g, service)
-
-	// Short-cut service constructor.
-	genServiceConstructor(gen, g, service)
 }
 
 func genRegisterFunction(gen *protogen.Plugin, file *protogen.File, g *protogen.GeneratedFile, service *protogen.Service) {
@@ -324,40 +320,21 @@
 	g.P()
 }
 
-func genServiceConstructor(gen *protogen.Plugin, g *protogen.GeneratedFile, service *protogen.Service) {
-	g.P("// New", service.GoName, "Service creates a new ", service.GoName, "Service containing the")
-	g.P("// implemented methods of the ", service.GoName, " service in s.  Any unimplemented")
-	g.P("// methods will result in the gRPC server returning an UNIMPLEMENTED status to the client.")
-	g.P("// This includes situations where the method handler is misspelled or has the wrong")
-	g.P("// signature.  For this reason, this function should be used with great care and")
-	g.P("// is not recommended to be used by most users.")
-	g.P("func New", service.GoName, "Service(s interface{}) *", service.GoName, "Service {")
-	g.P("ns := &", service.GoName, "Service{}")
-	for _, method := range service.Methods {
-		g.P("if h, ok := s.(interface {", methodSignature(g, method), "}); ok {")
-		g.P("ns.", method.GoName, " = h.", method.GoName)
-		g.P("}")
-	}
-	g.P("return ns")
-	g.P("}")
-	g.P()
-}
-
-func genUnstableServiceInterface(gen *protogen.Plugin, file *protogen.File, g *protogen.GeneratedFile, service *protogen.Service) {
+func genUnstableServerInterface(gen *protogen.Plugin, file *protogen.File, g *protogen.GeneratedFile, service *protogen.Service) {
 	// Service interface.
-	serviceType := service.GoName + "Service"
-	g.P("// Unstable", serviceType, " is the service API for ", service.GoName, " service.")
+	serverType := service.GoName + "Server"
+	g.P("// ", serverType, " is the service API for ", service.GoName, " service.")
 	g.P("// New methods may be added to this interface if they are added to the service")
 	g.P("// definition, which is not a backward-compatible change.  For this reason, ")
-	g.P("// use of this type is not recommended.")
+	g.P("// use of this type is not recommended unless you own the service definition.")
 	if service.Desc.Options().(*descriptorpb.ServiceOptions).GetDeprecated() {
 		g.P("//")
 		g.P(deprecationComment)
 	}
-	g.Annotate("Unstable"+serviceType, service.Location)
-	g.P("type Unstable", serviceType, " interface {")
+	g.Annotate(serverType, service.Location)
+	g.P("type ", serverType, " interface {")
 	for _, method := range service.Methods {
-		g.Annotate("Unstable"+serviceType+"."+method.GoName, method.Location)
+		g.Annotate(serverType+"."+method.GoName, method.Location)
 		if method.Desc.Options().(*descriptorpb.MethodOptions).GetDeprecated() {
 			g.P(deprecationComment)
 		}
@@ -366,6 +343,50 @@
 	}
 	g.P("}")
 	g.P()
+
+	// Unimplemented implementation.
+	genUnimplementedServer(gen, file, g, service)
+
+	// Service registration.
+	genUnstableRegisterFunction(gen, file, g, service)
+}
+
+func genUnimplementedServer(gen *protogen.Plugin, file *protogen.File, g *protogen.GeneratedFile, service *protogen.Service) {
+	// Server Unimplemented struct for forward compatibility.
+	serverType := service.GoName + "Server"
+	g.P("// Unimplemented", serverType, " can be embedded to have forward compatible implementations of")
+	g.P("// ", serverType)
+	g.P("type Unimplemented", serverType, " struct {")
+	g.P("}")
+	g.P()
+	for _, method := range service.Methods {
+		nilArg := ""
+		if !method.Desc.IsStreamingClient() && !method.Desc.IsStreamingServer() {
+			nilArg = "nil,"
+		}
+		g.P("func (Unimplemented", serverType, ") ", methodSignature(g, method), "{")
+		g.P("return ", nilArg, statusPackage.Ident("Errorf"), "(", codesPackage.Ident("Unimplemented"), `, "method `, method.GoName, ` not implemented")`)
+		g.P("}")
+	}
+	g.P()
+}
+
+func genUnstableRegisterFunction(gen *protogen.Plugin, file *protogen.File, g *protogen.GeneratedFile, service *protogen.Service) {
+	serverType := service.GoName + "Server"
+	g.P("// Register", serverType, " registers a service implementation with a gRPC server.")
+	if service.Desc.Options().(*descriptorpb.ServiceOptions).GetDeprecated() {
+		g.P("//")
+		g.P(deprecationComment)
+	}
+	g.P("func Register", serverType, "(s ", grpcPackage.Ident("ServiceRegistrar"), ", srv ", serverType, ") {")
+	g.P("str := &", service.GoName, "Service{")
+	for _, method := range service.Methods {
+		g.P(method.GoName, ": srv.", method.GoName, ",")
+	}
+	g.P("}")
+	g.P("Register", service.GoName, "Service(s, str)")
+	g.P("}")
+	g.P()
 }
 
 func methodSignature(g *protogen.GeneratedFile, method *protogen.Method) string {
@@ -452,9 +473,6 @@
 }
 
 func genServerStreamTypes(gen *protogen.Plugin, g *protogen.GeneratedFile, method *protogen.Method) {
-	if *migrationMode {
-		return
-	}
 	if !method.Desc.IsStreamingClient() && !method.Desc.IsStreamingServer() {
 		// Unary method
 		return
diff --git a/cmd/protoc-gen-go-grpc/main.go b/cmd/protoc-gen-go-grpc/main.go
index 0d7e76c..65896f1 100644
--- a/cmd/protoc-gen-go-grpc/main.go
+++ b/cmd/protoc-gen-go-grpc/main.go
@@ -37,11 +37,11 @@
 	"google.golang.org/protobuf/types/pluginpb"
 )
 
-var migrationMode *bool
+var genUnstableServerInterfaces *bool
 
 func main() {
 	var flags flag.FlagSet
-	migrationMode = flags.Bool("migration_mode", false, "set to generate new symbols only; requires symbols produced by legacy protoc-gen-go")
+	genUnstableServerInterfaces = flags.Bool("gen_unstable_server_interfaces", false, `set to generate legacy "Server" interfaces which do not guarantee backward compatibility`)
 
 	protogen.Options{
 		ParamFunc: flags.Set,
diff --git a/credentials/alts/internal/proto/grpc_gcp/handshaker.pb.go b/credentials/alts/internal/proto/grpc_gcp/handshaker.pb.go
index a2060de..6d9c304 100644
--- a/credentials/alts/internal/proto/grpc_gcp/handshaker.pb.go
+++ b/credentials/alts/internal/proto/grpc_gcp/handshaker.pb.go
@@ -4,12 +4,8 @@
 package grpc_gcp
 
 import (
-	context "context"
 	fmt "fmt"
 	proto "github.com/golang/protobuf/proto"
-	grpc "google.golang.org/grpc"
-	codes "google.golang.org/grpc/codes"
-	status "google.golang.org/grpc/status"
 	math "math"
 )
 
@@ -979,127 +975,3 @@
 	0x5f, 0xef, 0xa8, 0xf5, 0x83, 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0xc1, 0xf9, 0x9d, 0xf2, 0xd9,
 	0x0b, 0x00, 0x00,
 }
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ context.Context
-var _ grpc.ClientConnInterface
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the grpc package it is being compiled against.
-const _ = grpc.SupportPackageIsVersion6
-
-// HandshakerServiceClient is the client API for HandshakerService service.
-//
-// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
-type HandshakerServiceClient interface {
-	// Handshaker service accepts a stream of handshaker request, returning a
-	// stream of handshaker response. Client is expected to send exactly one
-	// message with either client_start or server_start followed by one or more
-	// messages with next. Each time client sends a request, the handshaker
-	// service expects to respond. Client does not have to wait for service's
-	// response before sending next request.
-	DoHandshake(ctx context.Context, opts ...grpc.CallOption) (HandshakerService_DoHandshakeClient, error)
-}
-
-type handshakerServiceClient struct {
-	cc grpc.ClientConnInterface
-}
-
-func NewHandshakerServiceClient(cc grpc.ClientConnInterface) HandshakerServiceClient {
-	return &handshakerServiceClient{cc}
-}
-
-func (c *handshakerServiceClient) DoHandshake(ctx context.Context, opts ...grpc.CallOption) (HandshakerService_DoHandshakeClient, error) {
-	stream, err := c.cc.NewStream(ctx, &_HandshakerService_serviceDesc.Streams[0], "/grpc.gcp.HandshakerService/DoHandshake", opts...)
-	if err != nil {
-		return nil, err
-	}
-	x := &handshakerServiceDoHandshakeClient{stream}
-	return x, nil
-}
-
-type HandshakerService_DoHandshakeClient interface {
-	Send(*HandshakerReq) error
-	Recv() (*HandshakerResp, error)
-	grpc.ClientStream
-}
-
-type handshakerServiceDoHandshakeClient struct {
-	grpc.ClientStream
-}
-
-func (x *handshakerServiceDoHandshakeClient) Send(m *HandshakerReq) error {
-	return x.ClientStream.SendMsg(m)
-}
-
-func (x *handshakerServiceDoHandshakeClient) Recv() (*HandshakerResp, error) {
-	m := new(HandshakerResp)
-	if err := x.ClientStream.RecvMsg(m); err != nil {
-		return nil, err
-	}
-	return m, nil
-}
-
-// HandshakerServiceServer is the server API for HandshakerService service.
-type HandshakerServiceServer interface {
-	// Handshaker service accepts a stream of handshaker request, returning a
-	// stream of handshaker response. Client is expected to send exactly one
-	// message with either client_start or server_start followed by one or more
-	// messages with next. Each time client sends a request, the handshaker
-	// service expects to respond. Client does not have to wait for service's
-	// response before sending next request.
-	DoHandshake(HandshakerService_DoHandshakeServer) error
-}
-
-// UnimplementedHandshakerServiceServer can be embedded to have forward compatible implementations.
-type UnimplementedHandshakerServiceServer struct {
-}
-
-func (*UnimplementedHandshakerServiceServer) DoHandshake(srv HandshakerService_DoHandshakeServer) error {
-	return status.Errorf(codes.Unimplemented, "method DoHandshake not implemented")
-}
-
-func RegisterHandshakerServiceServer(s *grpc.Server, srv HandshakerServiceServer) {
-	s.RegisterService(&_HandshakerService_serviceDesc, srv)
-}
-
-func _HandshakerService_DoHandshake_Handler(srv interface{}, stream grpc.ServerStream) error {
-	return srv.(HandshakerServiceServer).DoHandshake(&handshakerServiceDoHandshakeServer{stream})
-}
-
-type HandshakerService_DoHandshakeServer interface {
-	Send(*HandshakerResp) error
-	Recv() (*HandshakerReq, error)
-	grpc.ServerStream
-}
-
-type handshakerServiceDoHandshakeServer struct {
-	grpc.ServerStream
-}
-
-func (x *handshakerServiceDoHandshakeServer) Send(m *HandshakerResp) error {
-	return x.ServerStream.SendMsg(m)
-}
-
-func (x *handshakerServiceDoHandshakeServer) Recv() (*HandshakerReq, error) {
-	m := new(HandshakerReq)
-	if err := x.ServerStream.RecvMsg(m); err != nil {
-		return nil, err
-	}
-	return m, nil
-}
-
-var _HandshakerService_serviceDesc = grpc.ServiceDesc{
-	ServiceName: "grpc.gcp.HandshakerService",
-	HandlerType: (*HandshakerServiceServer)(nil),
-	Methods:     []grpc.MethodDesc{},
-	Streams: []grpc.StreamDesc{
-		{
-			StreamName:    "DoHandshake",
-			Handler:       _HandshakerService_DoHandshake_Handler,
-			ServerStreams: true,
-			ClientStreams: true,
-		},
-	},
-	Metadata: "grpc/gcp/handshaker.proto",
-}
diff --git a/credentials/alts/internal/proto/grpc_gcp/handshaker_grpc.pb.go b/credentials/alts/internal/proto/grpc_gcp/handshaker_grpc.pb.go
index d6f3af2..d2f2971 100644
--- a/credentials/alts/internal/proto/grpc_gcp/handshaker_grpc.pb.go
+++ b/credentials/alts/internal/proto/grpc_gcp/handshaker_grpc.pb.go
@@ -3,6 +3,7 @@
 package grpc_gcp
 
 import (
+	context "context"
 	grpc "google.golang.org/grpc"
 	codes "google.golang.org/grpc/codes"
 	status "google.golang.org/grpc/status"
@@ -12,6 +13,64 @@
 // is compatible with the grpc package it is being compiled against.
 const _ = grpc.SupportPackageIsVersion7
 
+// HandshakerServiceClient is the client API for HandshakerService service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
+type HandshakerServiceClient interface {
+	// Handshaker service accepts a stream of handshaker request, returning a
+	// stream of handshaker response. Client is expected to send exactly one
+	// message with either client_start or server_start followed by one or more
+	// messages with next. Each time client sends a request, the handshaker
+	// service expects to respond. Client does not have to wait for service's
+	// response before sending next request.
+	DoHandshake(ctx context.Context, opts ...grpc.CallOption) (HandshakerService_DoHandshakeClient, error)
+}
+
+type handshakerServiceClient struct {
+	cc grpc.ClientConnInterface
+}
+
+func NewHandshakerServiceClient(cc grpc.ClientConnInterface) HandshakerServiceClient {
+	return &handshakerServiceClient{cc}
+}
+
+var handshakerServiceDoHandshakeStreamDesc = &grpc.StreamDesc{
+	StreamName:    "DoHandshake",
+	ServerStreams: true,
+	ClientStreams: true,
+}
+
+func (c *handshakerServiceClient) DoHandshake(ctx context.Context, opts ...grpc.CallOption) (HandshakerService_DoHandshakeClient, error) {
+	stream, err := c.cc.NewStream(ctx, handshakerServiceDoHandshakeStreamDesc, "/grpc.gcp.HandshakerService/DoHandshake", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &handshakerServiceDoHandshakeClient{stream}
+	return x, nil
+}
+
+type HandshakerService_DoHandshakeClient interface {
+	Send(*HandshakerReq) error
+	Recv() (*HandshakerResp, error)
+	grpc.ClientStream
+}
+
+type handshakerServiceDoHandshakeClient struct {
+	grpc.ClientStream
+}
+
+func (x *handshakerServiceDoHandshakeClient) Send(m *HandshakerReq) error {
+	return x.ClientStream.SendMsg(m)
+}
+
+func (x *handshakerServiceDoHandshakeClient) Recv() (*HandshakerResp, error) {
+	m := new(HandshakerResp)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
 // HandshakerServiceService is the service API for HandshakerService service.
 // Fields should be assigned to their respective handler implementations only before
 // RegisterHandshakerServiceService is called.  Any unassigned fields will result in the
@@ -30,6 +89,28 @@
 	return s.DoHandshake(&handshakerServiceDoHandshakeServer{stream})
 }
 
+type HandshakerService_DoHandshakeServer interface {
+	Send(*HandshakerResp) error
+	Recv() (*HandshakerReq, error)
+	grpc.ServerStream
+}
+
+type handshakerServiceDoHandshakeServer struct {
+	grpc.ServerStream
+}
+
+func (x *handshakerServiceDoHandshakeServer) Send(m *HandshakerResp) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+func (x *handshakerServiceDoHandshakeServer) Recv() (*HandshakerReq, error) {
+	m := new(HandshakerReq)
+	if err := x.ServerStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
 // RegisterHandshakerServiceService registers a service implementation with a gRPC server.
 func RegisterHandshakerServiceService(s grpc.ServiceRegistrar, srv *HandshakerServiceService) {
 	srvCopy := *srv
@@ -55,27 +136,11 @@
 	s.RegisterService(&sd, nil)
 }
 
-// NewHandshakerServiceService creates a new HandshakerServiceService containing the
-// implemented methods of the HandshakerService service in s.  Any unimplemented
-// methods will result in the gRPC server returning an UNIMPLEMENTED status to the client.
-// This includes situations where the method handler is misspelled or has the wrong
-// signature.  For this reason, this function should be used with great care and
-// is not recommended to be used by most users.
-func NewHandshakerServiceService(s interface{}) *HandshakerServiceService {
-	ns := &HandshakerServiceService{}
-	if h, ok := s.(interface {
-		DoHandshake(HandshakerService_DoHandshakeServer) error
-	}); ok {
-		ns.DoHandshake = h.DoHandshake
-	}
-	return ns
-}
-
-// UnstableHandshakerServiceService is the service API for HandshakerService service.
+// HandshakerServiceServer is the service API for HandshakerService service.
 // New methods may be added to this interface if they are added to the service
 // definition, which is not a backward-compatible change.  For this reason,
-// use of this type is not recommended.
-type UnstableHandshakerServiceService interface {
+// use of this type is not recommended unless you own the service definition.
+type HandshakerServiceServer interface {
 	// Handshaker service accepts a stream of handshaker request, returning a
 	// stream of handshaker response. Client is expected to send exactly one
 	// message with either client_start or server_start followed by one or more
@@ -84,3 +149,20 @@
 	// response before sending next request.
 	DoHandshake(HandshakerService_DoHandshakeServer) error
 }
+
+// UnimplementedHandshakerServiceServer can be embedded to have forward compatible implementations of
+// HandshakerServiceServer
+type UnimplementedHandshakerServiceServer struct {
+}
+
+func (*UnimplementedHandshakerServiceServer) DoHandshake(HandshakerService_DoHandshakeServer) error {
+	return status.Errorf(codes.Unimplemented, "method DoHandshake not implemented")
+}
+
+// RegisterHandshakerServiceServer registers a service implementation with a gRPC server.
+func RegisterHandshakerServiceServer(s grpc.ServiceRegistrar, srv HandshakerServiceServer) {
+	str := &HandshakerServiceService{
+		DoHandshake: srv.DoHandshake,
+	}
+	RegisterHandshakerServiceService(s, str)
+}
diff --git a/credentials/tls/certprovider/meshca/internal/v1/meshca.pb.go b/credentials/tls/certprovider/meshca/internal/v1/meshca.pb.go
index b09de93..16122f7 100644
--- a/credentials/tls/certprovider/meshca/internal/v1/meshca.pb.go
+++ b/credentials/tls/certprovider/meshca/internal/v1/meshca.pb.go
@@ -4,13 +4,9 @@
 package google_security_meshca_v1
 
 import (
-	context "context"
 	fmt "fmt"
 	proto "github.com/golang/protobuf/proto"
 	duration "github.com/golang/protobuf/ptypes/duration"
-	grpc "google.golang.org/grpc"
-	codes "google.golang.org/grpc/codes"
-	status "google.golang.org/grpc/status"
 	math "math"
 )
 
@@ -157,87 +153,3 @@
 	0x75, 0x36, 0xec, 0xba, 0x62, 0xee, 0x66, 0x99, 0x93, 0xe5, 0x45, 0xb7, 0xcf, 0xc3, 0x77, 0x00,
 	0x00, 0x00, 0xff, 0xff, 0xb7, 0x0d, 0xfd, 0xff, 0xf7, 0x01, 0x00, 0x00,
 }
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ context.Context
-var _ grpc.ClientConnInterface
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the grpc package it is being compiled against.
-const _ = grpc.SupportPackageIsVersion6
-
-// MeshCertificateServiceClient is the client API for MeshCertificateService service.
-//
-// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
-type MeshCertificateServiceClient interface {
-	// Using provided CSR, returns a signed certificate that represents a GCP
-	// service account identity.
-	CreateCertificate(ctx context.Context, in *MeshCertificateRequest, opts ...grpc.CallOption) (*MeshCertificateResponse, error)
-}
-
-type meshCertificateServiceClient struct {
-	cc grpc.ClientConnInterface
-}
-
-func NewMeshCertificateServiceClient(cc grpc.ClientConnInterface) MeshCertificateServiceClient {
-	return &meshCertificateServiceClient{cc}
-}
-
-func (c *meshCertificateServiceClient) CreateCertificate(ctx context.Context, in *MeshCertificateRequest, opts ...grpc.CallOption) (*MeshCertificateResponse, error) {
-	out := new(MeshCertificateResponse)
-	err := c.cc.Invoke(ctx, "/google.security.meshca.v1.MeshCertificateService/CreateCertificate", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-// MeshCertificateServiceServer is the server API for MeshCertificateService service.
-type MeshCertificateServiceServer interface {
-	// Using provided CSR, returns a signed certificate that represents a GCP
-	// service account identity.
-	CreateCertificate(context.Context, *MeshCertificateRequest) (*MeshCertificateResponse, error)
-}
-
-// UnimplementedMeshCertificateServiceServer can be embedded to have forward compatible implementations.
-type UnimplementedMeshCertificateServiceServer struct {
-}
-
-func (*UnimplementedMeshCertificateServiceServer) CreateCertificate(ctx context.Context, req *MeshCertificateRequest) (*MeshCertificateResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method CreateCertificate not implemented")
-}
-
-func RegisterMeshCertificateServiceServer(s *grpc.Server, srv MeshCertificateServiceServer) {
-	s.RegisterService(&_MeshCertificateService_serviceDesc, srv)
-}
-
-func _MeshCertificateService_CreateCertificate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(MeshCertificateRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(MeshCertificateServiceServer).CreateCertificate(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/google.security.meshca.v1.MeshCertificateService/CreateCertificate",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(MeshCertificateServiceServer).CreateCertificate(ctx, req.(*MeshCertificateRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-var _MeshCertificateService_serviceDesc = grpc.ServiceDesc{
-	ServiceName: "google.security.meshca.v1.MeshCertificateService",
-	HandlerType: (*MeshCertificateServiceServer)(nil),
-	Methods: []grpc.MethodDesc{
-		{
-			MethodName: "CreateCertificate",
-			Handler:    _MeshCertificateService_CreateCertificate_Handler,
-		},
-	},
-	Streams:  []grpc.StreamDesc{},
-	Metadata: "istio/google/security/meshca/v1/meshca.proto",
-}
diff --git a/credentials/tls/certprovider/meshca/internal/v1/meshca_grpc.pb.go b/credentials/tls/certprovider/meshca/internal/v1/meshca_grpc.pb.go
index 3a82e6a..4dbb2ac 100644
--- a/credentials/tls/certprovider/meshca/internal/v1/meshca_grpc.pb.go
+++ b/credentials/tls/certprovider/meshca/internal/v1/meshca_grpc.pb.go
@@ -13,6 +13,36 @@
 // is compatible with the grpc package it is being compiled against.
 const _ = grpc.SupportPackageIsVersion7
 
+// MeshCertificateServiceClient is the client API for MeshCertificateService service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
+type MeshCertificateServiceClient interface {
+	// Using provided CSR, returns a signed certificate that represents a GCP
+	// service account identity.
+	CreateCertificate(ctx context.Context, in *MeshCertificateRequest, opts ...grpc.CallOption) (*MeshCertificateResponse, error)
+}
+
+type meshCertificateServiceClient struct {
+	cc grpc.ClientConnInterface
+}
+
+func NewMeshCertificateServiceClient(cc grpc.ClientConnInterface) MeshCertificateServiceClient {
+	return &meshCertificateServiceClient{cc}
+}
+
+var meshCertificateServiceCreateCertificateStreamDesc = &grpc.StreamDesc{
+	StreamName: "CreateCertificate",
+}
+
+func (c *meshCertificateServiceClient) CreateCertificate(ctx context.Context, in *MeshCertificateRequest, opts ...grpc.CallOption) (*MeshCertificateResponse, error) {
+	out := new(MeshCertificateResponse)
+	err := c.cc.Invoke(ctx, "/google.security.meshca.v1.MeshCertificateService/CreateCertificate", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // MeshCertificateServiceService is the service API for MeshCertificateService service.
 // Fields should be assigned to their respective handler implementations only before
 // RegisterMeshCertificateServiceService is called.  Any unassigned fields will result in the
@@ -64,28 +94,29 @@
 	s.RegisterService(&sd, nil)
 }
 
-// NewMeshCertificateServiceService creates a new MeshCertificateServiceService containing the
-// implemented methods of the MeshCertificateService service in s.  Any unimplemented
-// methods will result in the gRPC server returning an UNIMPLEMENTED status to the client.
-// This includes situations where the method handler is misspelled or has the wrong
-// signature.  For this reason, this function should be used with great care and
-// is not recommended to be used by most users.
-func NewMeshCertificateServiceService(s interface{}) *MeshCertificateServiceService {
-	ns := &MeshCertificateServiceService{}
-	if h, ok := s.(interface {
-		CreateCertificate(context.Context, *MeshCertificateRequest) (*MeshCertificateResponse, error)
-	}); ok {
-		ns.CreateCertificate = h.CreateCertificate
-	}
-	return ns
-}
-
-// UnstableMeshCertificateServiceService is the service API for MeshCertificateService service.
+// MeshCertificateServiceServer is the service API for MeshCertificateService service.
 // New methods may be added to this interface if they are added to the service
 // definition, which is not a backward-compatible change.  For this reason,
-// use of this type is not recommended.
-type UnstableMeshCertificateServiceService interface {
+// use of this type is not recommended unless you own the service definition.
+type MeshCertificateServiceServer interface {
 	// Using provided CSR, returns a signed certificate that represents a GCP
 	// service account identity.
 	CreateCertificate(context.Context, *MeshCertificateRequest) (*MeshCertificateResponse, error)
 }
+
+// UnimplementedMeshCertificateServiceServer can be embedded to have forward compatible implementations of
+// MeshCertificateServiceServer
+type UnimplementedMeshCertificateServiceServer struct {
+}
+
+func (*UnimplementedMeshCertificateServiceServer) CreateCertificate(context.Context, *MeshCertificateRequest) (*MeshCertificateResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method CreateCertificate not implemented")
+}
+
+// RegisterMeshCertificateServiceServer registers a service implementation with a gRPC server.
+func RegisterMeshCertificateServiceServer(s grpc.ServiceRegistrar, srv MeshCertificateServiceServer) {
+	str := &MeshCertificateServiceService{
+		CreateCertificate: srv.CreateCertificate,
+	}
+	RegisterMeshCertificateServiceService(s, str)
+}
diff --git a/examples/features/proto/echo/echo_grpc.pb.go b/examples/features/proto/echo/echo_grpc.pb.go
index d1d6cf0..ff30c65 100644
--- a/examples/features/proto/echo/echo_grpc.pb.go
+++ b/examples/features/proto/echo/echo_grpc.pb.go
@@ -318,49 +318,3 @@
 
 	s.RegisterService(&sd, nil)
 }
-
-// NewEchoService creates a new EchoService containing the
-// implemented methods of the Echo service in s.  Any unimplemented
-// methods will result in the gRPC server returning an UNIMPLEMENTED status to the client.
-// This includes situations where the method handler is misspelled or has the wrong
-// signature.  For this reason, this function should be used with great care and
-// is not recommended to be used by most users.
-func NewEchoService(s interface{}) *EchoService {
-	ns := &EchoService{}
-	if h, ok := s.(interface {
-		UnaryEcho(context.Context, *EchoRequest) (*EchoResponse, error)
-	}); ok {
-		ns.UnaryEcho = h.UnaryEcho
-	}
-	if h, ok := s.(interface {
-		ServerStreamingEcho(*EchoRequest, Echo_ServerStreamingEchoServer) error
-	}); ok {
-		ns.ServerStreamingEcho = h.ServerStreamingEcho
-	}
-	if h, ok := s.(interface {
-		ClientStreamingEcho(Echo_ClientStreamingEchoServer) error
-	}); ok {
-		ns.ClientStreamingEcho = h.ClientStreamingEcho
-	}
-	if h, ok := s.(interface {
-		BidirectionalStreamingEcho(Echo_BidirectionalStreamingEchoServer) error
-	}); ok {
-		ns.BidirectionalStreamingEcho = h.BidirectionalStreamingEcho
-	}
-	return ns
-}
-
-// UnstableEchoService is the service API for Echo service.
-// New methods may be added to this interface if they are added to the service
-// definition, which is not a backward-compatible change.  For this reason,
-// use of this type is not recommended.
-type UnstableEchoService interface {
-	// UnaryEcho is unary echo.
-	UnaryEcho(context.Context, *EchoRequest) (*EchoResponse, error)
-	// ServerStreamingEcho is server side streaming.
-	ServerStreamingEcho(*EchoRequest, Echo_ServerStreamingEchoServer) error
-	// ClientStreamingEcho is client side streaming.
-	ClientStreamingEcho(Echo_ClientStreamingEchoServer) error
-	// BidirectionalStreamingEcho is bidi streaming.
-	BidirectionalStreamingEcho(Echo_BidirectionalStreamingEchoServer) error
-}
diff --git a/examples/helloworld/helloworld/helloworld_grpc.pb.go b/examples/helloworld/helloworld/helloworld_grpc.pb.go
index 3a88bb1..78d6025 100644
--- a/examples/helloworld/helloworld/helloworld_grpc.pb.go
+++ b/examples/helloworld/helloworld/helloworld_grpc.pb.go
@@ -91,28 +91,3 @@
 
 	s.RegisterService(&sd, nil)
 }
-
-// NewGreeterService creates a new GreeterService containing the
-// implemented methods of the Greeter service in s.  Any unimplemented
-// methods will result in the gRPC server returning an UNIMPLEMENTED status to the client.
-// This includes situations where the method handler is misspelled or has the wrong
-// signature.  For this reason, this function should be used with great care and
-// is not recommended to be used by most users.
-func NewGreeterService(s interface{}) *GreeterService {
-	ns := &GreeterService{}
-	if h, ok := s.(interface {
-		SayHello(context.Context, *HelloRequest) (*HelloReply, error)
-	}); ok {
-		ns.SayHello = h.SayHello
-	}
-	return ns
-}
-
-// UnstableGreeterService is the service API for Greeter service.
-// New methods may be added to this interface if they are added to the service
-// definition, which is not a backward-compatible change.  For this reason,
-// use of this type is not recommended.
-type UnstableGreeterService interface {
-	// Sends a greeting
-	SayHello(context.Context, *HelloRequest) (*HelloReply, error)
-}
diff --git a/examples/route_guide/routeguide/route_guide_grpc.pb.go b/examples/route_guide/routeguide/route_guide_grpc.pb.go
index eb406ec..bbcfe7d 100644
--- a/examples/route_guide/routeguide/route_guide_grpc.pb.go
+++ b/examples/route_guide/routeguide/route_guide_grpc.pb.go
@@ -350,65 +350,3 @@
 
 	s.RegisterService(&sd, nil)
 }
-
-// NewRouteGuideService creates a new RouteGuideService containing the
-// implemented methods of the RouteGuide service in s.  Any unimplemented
-// methods will result in the gRPC server returning an UNIMPLEMENTED status to the client.
-// This includes situations where the method handler is misspelled or has the wrong
-// signature.  For this reason, this function should be used with great care and
-// is not recommended to be used by most users.
-func NewRouteGuideService(s interface{}) *RouteGuideService {
-	ns := &RouteGuideService{}
-	if h, ok := s.(interface {
-		GetFeature(context.Context, *Point) (*Feature, error)
-	}); ok {
-		ns.GetFeature = h.GetFeature
-	}
-	if h, ok := s.(interface {
-		ListFeatures(*Rectangle, RouteGuide_ListFeaturesServer) error
-	}); ok {
-		ns.ListFeatures = h.ListFeatures
-	}
-	if h, ok := s.(interface {
-		RecordRoute(RouteGuide_RecordRouteServer) error
-	}); ok {
-		ns.RecordRoute = h.RecordRoute
-	}
-	if h, ok := s.(interface {
-		RouteChat(RouteGuide_RouteChatServer) error
-	}); ok {
-		ns.RouteChat = h.RouteChat
-	}
-	return ns
-}
-
-// UnstableRouteGuideService is the service API for RouteGuide service.
-// New methods may be added to this interface if they are added to the service
-// definition, which is not a backward-compatible change.  For this reason,
-// use of this type is not recommended.
-type UnstableRouteGuideService interface {
-	// A simple RPC.
-	//
-	// Obtains the feature at a given position.
-	//
-	// A feature with an empty name is returned if there's no feature at the given
-	// position.
-	GetFeature(context.Context, *Point) (*Feature, error)
-	// A server-to-client streaming RPC.
-	//
-	// Obtains the Features available within the given Rectangle.  Results are
-	// streamed rather than returned at once (e.g. in a response message with a
-	// repeated field), as the rectangle may cover a large area and contain a
-	// huge number of features.
-	ListFeatures(*Rectangle, RouteGuide_ListFeaturesServer) error
-	// A client-to-server streaming RPC.
-	//
-	// Accepts a stream of Points on a route being traversed, returning a
-	// RouteSummary when traversal is completed.
-	RecordRoute(RouteGuide_RecordRouteServer) error
-	// A Bidirectional streaming RPC.
-	//
-	// Accepts a stream of RouteNotes sent while a route is being traversed,
-	// while receiving other RouteNotes (e.g. from other users).
-	RouteChat(RouteGuide_RouteChatServer) error
-}
diff --git a/examples/route_guide/server/server.go b/examples/route_guide/server/server.go
index 7c959dd..3c0775e 100644
--- a/examples/route_guide/server/server.go
+++ b/examples/route_guide/server/server.go
@@ -60,6 +60,15 @@
 	routeNotes map[string][]*pb.RouteNote
 }
 
+func (s *routeGuideServer) Svc() *pb.RouteGuideService {
+	return &pb.RouteGuideService{
+		GetFeature:   s.GetFeature,
+		ListFeatures: s.ListFeatures,
+		RecordRoute:  s.RecordRoute,
+		RouteChat:    s.RouteChat,
+	}
+}
+
 // GetFeature returns the feature at the given point.
 func (s *routeGuideServer) GetFeature(ctx context.Context, point *pb.Point) (*pb.Feature, error) {
 	for _, feature := range s.savedFeatures {
@@ -237,7 +246,7 @@
 		opts = []grpc.ServerOption{grpc.Creds(creds)}
 	}
 	grpcServer := grpc.NewServer(opts...)
-	pb.RegisterRouteGuideService(grpcServer, pb.NewRouteGuideService(newServer()))
+	pb.RegisterRouteGuideService(grpcServer, newServer().Svc())
 	grpcServer.Serve(lis)
 }
 
diff --git a/health/grpc_health_v1/health.pb.go b/health/grpc_health_v1/health.pb.go
index 4c2a527..e9919c0 100644
--- a/health/grpc_health_v1/health.pb.go
+++ b/health/grpc_health_v1/health.pb.go
@@ -4,12 +4,8 @@
 package grpc_health_v1
 
 import (
-	context "context"
 	fmt "fmt"
 	proto "github.com/golang/protobuf/proto"
-	grpc "google.golang.org/grpc"
-	codes "google.golang.org/grpc/codes"
-	status "google.golang.org/grpc/status"
 	math "math"
 )
 
@@ -163,181 +159,3 @@
 	0xd3, 0x20, 0x46, 0xe8, 0x85, 0x19, 0x26, 0xb1, 0x81, 0x93, 0x83, 0x31, 0x20, 0x00, 0x00, 0xff,
 	0xff, 0x12, 0x7d, 0x96, 0xcb, 0x2d, 0x02, 0x00, 0x00,
 }
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ context.Context
-var _ grpc.ClientConnInterface
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the grpc package it is being compiled against.
-const _ = grpc.SupportPackageIsVersion6
-
-// HealthClient is the client API for Health service.
-//
-// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
-type HealthClient interface {
-	// If the requested service is unknown, the call will fail with status
-	// NOT_FOUND.
-	Check(ctx context.Context, in *HealthCheckRequest, opts ...grpc.CallOption) (*HealthCheckResponse, error)
-	// Performs a watch for the serving status of the requested service.
-	// The server will immediately send back a message indicating the current
-	// serving status.  It will then subsequently send a new message whenever
-	// the service's serving status changes.
-	//
-	// If the requested service is unknown when the call is received, the
-	// server will send a message setting the serving status to
-	// SERVICE_UNKNOWN but will *not* terminate the call.  If at some
-	// future point, the serving status of the service becomes known, the
-	// server will send a new message with the service's serving status.
-	//
-	// If the call terminates with status UNIMPLEMENTED, then clients
-	// should assume this method is not supported and should not retry the
-	// call.  If the call terminates with any other status (including OK),
-	// clients should retry the call with appropriate exponential backoff.
-	Watch(ctx context.Context, in *HealthCheckRequest, opts ...grpc.CallOption) (Health_WatchClient, error)
-}
-
-type healthClient struct {
-	cc grpc.ClientConnInterface
-}
-
-func NewHealthClient(cc grpc.ClientConnInterface) HealthClient {
-	return &healthClient{cc}
-}
-
-func (c *healthClient) Check(ctx context.Context, in *HealthCheckRequest, opts ...grpc.CallOption) (*HealthCheckResponse, error) {
-	out := new(HealthCheckResponse)
-	err := c.cc.Invoke(ctx, "/grpc.health.v1.Health/Check", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *healthClient) Watch(ctx context.Context, in *HealthCheckRequest, opts ...grpc.CallOption) (Health_WatchClient, error) {
-	stream, err := c.cc.NewStream(ctx, &_Health_serviceDesc.Streams[0], "/grpc.health.v1.Health/Watch", opts...)
-	if err != nil {
-		return nil, err
-	}
-	x := &healthWatchClient{stream}
-	if err := x.ClientStream.SendMsg(in); err != nil {
-		return nil, err
-	}
-	if err := x.ClientStream.CloseSend(); err != nil {
-		return nil, err
-	}
-	return x, nil
-}
-
-type Health_WatchClient interface {
-	Recv() (*HealthCheckResponse, error)
-	grpc.ClientStream
-}
-
-type healthWatchClient struct {
-	grpc.ClientStream
-}
-
-func (x *healthWatchClient) Recv() (*HealthCheckResponse, error) {
-	m := new(HealthCheckResponse)
-	if err := x.ClientStream.RecvMsg(m); err != nil {
-		return nil, err
-	}
-	return m, nil
-}
-
-// HealthServer is the server API for Health service.
-type HealthServer interface {
-	// If the requested service is unknown, the call will fail with status
-	// NOT_FOUND.
-	Check(context.Context, *HealthCheckRequest) (*HealthCheckResponse, error)
-	// Performs a watch for the serving status of the requested service.
-	// The server will immediately send back a message indicating the current
-	// serving status.  It will then subsequently send a new message whenever
-	// the service's serving status changes.
-	//
-	// If the requested service is unknown when the call is received, the
-	// server will send a message setting the serving status to
-	// SERVICE_UNKNOWN but will *not* terminate the call.  If at some
-	// future point, the serving status of the service becomes known, the
-	// server will send a new message with the service's serving status.
-	//
-	// If the call terminates with status UNIMPLEMENTED, then clients
-	// should assume this method is not supported and should not retry the
-	// call.  If the call terminates with any other status (including OK),
-	// clients should retry the call with appropriate exponential backoff.
-	Watch(*HealthCheckRequest, Health_WatchServer) error
-}
-
-// UnimplementedHealthServer can be embedded to have forward compatible implementations.
-type UnimplementedHealthServer struct {
-}
-
-func (*UnimplementedHealthServer) Check(ctx context.Context, req *HealthCheckRequest) (*HealthCheckResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method Check not implemented")
-}
-func (*UnimplementedHealthServer) Watch(req *HealthCheckRequest, srv Health_WatchServer) error {
-	return status.Errorf(codes.Unimplemented, "method Watch not implemented")
-}
-
-func RegisterHealthServer(s *grpc.Server, srv HealthServer) {
-	s.RegisterService(&_Health_serviceDesc, srv)
-}
-
-func _Health_Check_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(HealthCheckRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(HealthServer).Check(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/grpc.health.v1.Health/Check",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(HealthServer).Check(ctx, req.(*HealthCheckRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _Health_Watch_Handler(srv interface{}, stream grpc.ServerStream) error {
-	m := new(HealthCheckRequest)
-	if err := stream.RecvMsg(m); err != nil {
-		return err
-	}
-	return srv.(HealthServer).Watch(m, &healthWatchServer{stream})
-}
-
-type Health_WatchServer interface {
-	Send(*HealthCheckResponse) error
-	grpc.ServerStream
-}
-
-type healthWatchServer struct {
-	grpc.ServerStream
-}
-
-func (x *healthWatchServer) Send(m *HealthCheckResponse) error {
-	return x.ServerStream.SendMsg(m)
-}
-
-var _Health_serviceDesc = grpc.ServiceDesc{
-	ServiceName: "grpc.health.v1.Health",
-	HandlerType: (*HealthServer)(nil),
-	Methods: []grpc.MethodDesc{
-		{
-			MethodName: "Check",
-			Handler:    _Health_Check_Handler,
-		},
-	},
-	Streams: []grpc.StreamDesc{
-		{
-			StreamName:    "Watch",
-			Handler:       _Health_Watch_Handler,
-			ServerStreams: true,
-		},
-	},
-	Metadata: "grpc/health/v1/health.proto",
-}
diff --git a/health/grpc_health_v1/health_grpc.pb.go b/health/grpc_health_v1/health_grpc.pb.go
index f848b41..fa3a6a7 100644
--- a/health/grpc_health_v1/health_grpc.pb.go
+++ b/health/grpc_health_v1/health_grpc.pb.go
@@ -13,6 +13,89 @@
 // is compatible with the grpc package it is being compiled against.
 const _ = grpc.SupportPackageIsVersion7
 
+// HealthClient is the client API for Health service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
+type HealthClient interface {
+	// If the requested service is unknown, the call will fail with status
+	// NOT_FOUND.
+	Check(ctx context.Context, in *HealthCheckRequest, opts ...grpc.CallOption) (*HealthCheckResponse, error)
+	// Performs a watch for the serving status of the requested service.
+	// The server will immediately send back a message indicating the current
+	// serving status.  It will then subsequently send a new message whenever
+	// the service's serving status changes.
+	//
+	// If the requested service is unknown when the call is received, the
+	// server will send a message setting the serving status to
+	// SERVICE_UNKNOWN but will *not* terminate the call.  If at some
+	// future point, the serving status of the service becomes known, the
+	// server will send a new message with the service's serving status.
+	//
+	// If the call terminates with status UNIMPLEMENTED, then clients
+	// should assume this method is not supported and should not retry the
+	// call.  If the call terminates with any other status (including OK),
+	// clients should retry the call with appropriate exponential backoff.
+	Watch(ctx context.Context, in *HealthCheckRequest, opts ...grpc.CallOption) (Health_WatchClient, error)
+}
+
+type healthClient struct {
+	cc grpc.ClientConnInterface
+}
+
+func NewHealthClient(cc grpc.ClientConnInterface) HealthClient {
+	return &healthClient{cc}
+}
+
+var healthCheckStreamDesc = &grpc.StreamDesc{
+	StreamName: "Check",
+}
+
+func (c *healthClient) Check(ctx context.Context, in *HealthCheckRequest, opts ...grpc.CallOption) (*HealthCheckResponse, error) {
+	out := new(HealthCheckResponse)
+	err := c.cc.Invoke(ctx, "/grpc.health.v1.Health/Check", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+var healthWatchStreamDesc = &grpc.StreamDesc{
+	StreamName:    "Watch",
+	ServerStreams: true,
+}
+
+func (c *healthClient) Watch(ctx context.Context, in *HealthCheckRequest, opts ...grpc.CallOption) (Health_WatchClient, error) {
+	stream, err := c.cc.NewStream(ctx, healthWatchStreamDesc, "/grpc.health.v1.Health/Watch", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &healthWatchClient{stream}
+	if err := x.ClientStream.SendMsg(in); err != nil {
+		return nil, err
+	}
+	if err := x.ClientStream.CloseSend(); err != nil {
+		return nil, err
+	}
+	return x, nil
+}
+
+type Health_WatchClient interface {
+	Recv() (*HealthCheckResponse, error)
+	grpc.ClientStream
+}
+
+type healthWatchClient struct {
+	grpc.ClientStream
+}
+
+func (x *healthWatchClient) Recv() (*HealthCheckResponse, error) {
+	m := new(HealthCheckResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
 // HealthService is the service API for Health service.
 // Fields should be assigned to their respective handler implementations only before
 // RegisterHealthService is called.  Any unassigned fields will result in the
@@ -64,6 +147,19 @@
 	return s.Watch(m, &healthWatchServer{stream})
 }
 
+type Health_WatchServer interface {
+	Send(*HealthCheckResponse) error
+	grpc.ServerStream
+}
+
+type healthWatchServer struct {
+	grpc.ServerStream
+}
+
+func (x *healthWatchServer) Send(m *HealthCheckResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
 // RegisterHealthService registers a service implementation with a gRPC server.
 func RegisterHealthService(s grpc.ServiceRegistrar, srv *HealthService) {
 	srvCopy := *srv
@@ -98,32 +194,11 @@
 	s.RegisterService(&sd, nil)
 }
 
-// NewHealthService creates a new HealthService containing the
-// implemented methods of the Health service in s.  Any unimplemented
-// methods will result in the gRPC server returning an UNIMPLEMENTED status to the client.
-// This includes situations where the method handler is misspelled or has the wrong
-// signature.  For this reason, this function should be used with great care and
-// is not recommended to be used by most users.
-func NewHealthService(s interface{}) *HealthService {
-	ns := &HealthService{}
-	if h, ok := s.(interface {
-		Check(context.Context, *HealthCheckRequest) (*HealthCheckResponse, error)
-	}); ok {
-		ns.Check = h.Check
-	}
-	if h, ok := s.(interface {
-		Watch(*HealthCheckRequest, Health_WatchServer) error
-	}); ok {
-		ns.Watch = h.Watch
-	}
-	return ns
-}
-
-// UnstableHealthService is the service API for Health service.
+// HealthServer is the service API for Health service.
 // New methods may be added to this interface if they are added to the service
 // definition, which is not a backward-compatible change.  For this reason,
-// use of this type is not recommended.
-type UnstableHealthService interface {
+// use of this type is not recommended unless you own the service definition.
+type HealthServer interface {
 	// If the requested service is unknown, the call will fail with status
 	// NOT_FOUND.
 	Check(context.Context, *HealthCheckRequest) (*HealthCheckResponse, error)
@@ -144,3 +219,24 @@
 	// clients should retry the call with appropriate exponential backoff.
 	Watch(*HealthCheckRequest, Health_WatchServer) error
 }
+
+// UnimplementedHealthServer can be embedded to have forward compatible implementations of
+// HealthServer
+type UnimplementedHealthServer struct {
+}
+
+func (*UnimplementedHealthServer) Check(context.Context, *HealthCheckRequest) (*HealthCheckResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method Check not implemented")
+}
+func (*UnimplementedHealthServer) Watch(*HealthCheckRequest, Health_WatchServer) error {
+	return status.Errorf(codes.Unimplemented, "method Watch not implemented")
+}
+
+// RegisterHealthServer registers a service implementation with a gRPC server.
+func RegisterHealthServer(s grpc.ServiceRegistrar, srv HealthServer) {
+	str := &HealthService{
+		Check: srv.Check,
+		Watch: srv.Watch,
+	}
+	RegisterHealthService(s, str)
+}
diff --git a/internal/binarylog/binarylog_end2end_test.go b/internal/binarylog/binarylog_end2end_test.go
index bdce754..54dd3da 100644
--- a/internal/binarylog/binarylog_end2end_test.go
+++ b/internal/binarylog/binarylog_end2end_test.go
@@ -118,7 +118,14 @@
 	te *test
 }
 
-var _ testpb.UnstableTestServiceService = (*testServer)(nil)
+func (s *testServer) Svc() *testpb.TestServiceService {
+	return &testpb.TestServiceService{
+		UnaryCall:        s.UnaryCall,
+		FullDuplexCall:   s.FullDuplexCall,
+		ClientStreamCall: s.ClientStreamCall,
+		ServerStreamCall: s.ServerStreamCall,
+	}
+}
 
 func (s *testServer) UnaryCall(ctx context.Context, in *testpb.SimpleRequest) (*testpb.SimpleResponse, error) {
 	md, ok := metadata.FromIncomingContext(ctx)
@@ -784,7 +791,7 @@
 
 func runRPCs(t *testing.T, tc *testConfig, cc *rpcConfig) *expectedData {
 	te := newTest(t, tc)
-	te.startServer(testpb.NewTestServiceService(&testServer{te: te}))
+	te.startServer((&testServer{te: te}).Svc())
 	defer te.tearDown()
 
 	expect := &expectedData{
diff --git a/interop/grpc_testing/test_grpc.pb.go b/interop/grpc_testing/test_grpc.pb.go
index 9496348..e158bb4 100644
--- a/interop/grpc_testing/test_grpc.pb.go
+++ b/interop/grpc_testing/test_grpc.pb.go
@@ -455,74 +455,6 @@
 	s.RegisterService(&sd, nil)
 }
 
-// NewTestServiceService creates a new TestServiceService containing the
-// implemented methods of the TestService service in s.  Any unimplemented
-// methods will result in the gRPC server returning an UNIMPLEMENTED status to the client.
-// This includes situations where the method handler is misspelled or has the wrong
-// signature.  For this reason, this function should be used with great care and
-// is not recommended to be used by most users.
-func NewTestServiceService(s interface{}) *TestServiceService {
-	ns := &TestServiceService{}
-	if h, ok := s.(interface {
-		EmptyCall(context.Context, *Empty) (*Empty, error)
-	}); ok {
-		ns.EmptyCall = h.EmptyCall
-	}
-	if h, ok := s.(interface {
-		UnaryCall(context.Context, *SimpleRequest) (*SimpleResponse, error)
-	}); ok {
-		ns.UnaryCall = h.UnaryCall
-	}
-	if h, ok := s.(interface {
-		StreamingOutputCall(*StreamingOutputCallRequest, TestService_StreamingOutputCallServer) error
-	}); ok {
-		ns.StreamingOutputCall = h.StreamingOutputCall
-	}
-	if h, ok := s.(interface {
-		StreamingInputCall(TestService_StreamingInputCallServer) error
-	}); ok {
-		ns.StreamingInputCall = h.StreamingInputCall
-	}
-	if h, ok := s.(interface {
-		FullDuplexCall(TestService_FullDuplexCallServer) error
-	}); ok {
-		ns.FullDuplexCall = h.FullDuplexCall
-	}
-	if h, ok := s.(interface {
-		HalfDuplexCall(TestService_HalfDuplexCallServer) error
-	}); ok {
-		ns.HalfDuplexCall = h.HalfDuplexCall
-	}
-	return ns
-}
-
-// UnstableTestServiceService is the service API for TestService service.
-// New methods may be added to this interface if they are added to the service
-// definition, which is not a backward-compatible change.  For this reason,
-// use of this type is not recommended.
-type UnstableTestServiceService interface {
-	// One empty request followed by one empty response.
-	EmptyCall(context.Context, *Empty) (*Empty, error)
-	// One request followed by one response.
-	// The server returns the client payload as-is.
-	UnaryCall(context.Context, *SimpleRequest) (*SimpleResponse, error)
-	// One request followed by a sequence of responses (streamed download).
-	// The server returns the payload with client desired type and sizes.
-	StreamingOutputCall(*StreamingOutputCallRequest, TestService_StreamingOutputCallServer) error
-	// A sequence of requests followed by one response (streamed upload).
-	// The server returns the aggregated size of client payload as the result.
-	StreamingInputCall(TestService_StreamingInputCallServer) error
-	// A sequence of requests with each request served by the server immediately.
-	// As one request could lead to multiple responses, this interface
-	// demonstrates the idea of full duplexing.
-	FullDuplexCall(TestService_FullDuplexCallServer) error
-	// A sequence of requests followed by a sequence of responses.
-	// The server buffers all the client requests and then serves them in order. A
-	// stream of responses are returned to the client when the server starts with
-	// first request.
-	HalfDuplexCall(TestService_HalfDuplexCallServer) error
-}
-
 // UnimplementedServiceClient is the client API for UnimplementedService service.
 //
 // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
@@ -602,31 +534,6 @@
 	s.RegisterService(&sd, nil)
 }
 
-// NewUnimplementedServiceService creates a new UnimplementedServiceService containing the
-// implemented methods of the UnimplementedService service in s.  Any unimplemented
-// methods will result in the gRPC server returning an UNIMPLEMENTED status to the client.
-// This includes situations where the method handler is misspelled or has the wrong
-// signature.  For this reason, this function should be used with great care and
-// is not recommended to be used by most users.
-func NewUnimplementedServiceService(s interface{}) *UnimplementedServiceService {
-	ns := &UnimplementedServiceService{}
-	if h, ok := s.(interface {
-		UnimplementedCall(context.Context, *Empty) (*Empty, error)
-	}); ok {
-		ns.UnimplementedCall = h.UnimplementedCall
-	}
-	return ns
-}
-
-// UnstableUnimplementedServiceService is the service API for UnimplementedService service.
-// New methods may be added to this interface if they are added to the service
-// definition, which is not a backward-compatible change.  For this reason,
-// use of this type is not recommended.
-type UnstableUnimplementedServiceService interface {
-	// A call that no server should implement
-	UnimplementedCall(context.Context, *Empty) (*Empty, error)
-}
-
 // LoadBalancerStatsServiceClient is the client API for LoadBalancerStatsService service.
 //
 // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
@@ -705,28 +612,3 @@
 
 	s.RegisterService(&sd, nil)
 }
-
-// NewLoadBalancerStatsServiceService creates a new LoadBalancerStatsServiceService containing the
-// implemented methods of the LoadBalancerStatsService service in s.  Any unimplemented
-// methods will result in the gRPC server returning an UNIMPLEMENTED status to the client.
-// This includes situations where the method handler is misspelled or has the wrong
-// signature.  For this reason, this function should be used with great care and
-// is not recommended to be used by most users.
-func NewLoadBalancerStatsServiceService(s interface{}) *LoadBalancerStatsServiceService {
-	ns := &LoadBalancerStatsServiceService{}
-	if h, ok := s.(interface {
-		GetClientStats(context.Context, *LoadBalancerStatsRequest) (*LoadBalancerStatsResponse, error)
-	}); ok {
-		ns.GetClientStats = h.GetClientStats
-	}
-	return ns
-}
-
-// UnstableLoadBalancerStatsServiceService is the service API for LoadBalancerStatsService service.
-// New methods may be added to this interface if they are added to the service
-// definition, which is not a backward-compatible change.  For this reason,
-// use of this type is not recommended.
-type UnstableLoadBalancerStatsServiceService interface {
-	// Gets the backend distribution for RPCs sent by a test client.
-	GetClientStats(context.Context, *LoadBalancerStatsRequest) (*LoadBalancerStatsResponse, error)
-}
diff --git a/interop/test_utils.go b/interop/test_utils.go
index 7a42116..dd2a731 100644
--- a/interop/test_utils.go
+++ b/interop/test_utils.go
@@ -677,7 +677,15 @@
 
 // NewTestServer creates a test server for test service.
 func NewTestServer() *testpb.TestServiceService {
-	return testpb.NewTestServiceService(testpb.UnstableTestServiceService(&testServer{}))
+	s := testServer{}
+	return &testpb.TestServiceService{
+		EmptyCall:           s.EmptyCall,
+		UnaryCall:           s.UnaryCall,
+		StreamingOutputCall: s.StreamingOutputCall,
+		StreamingInputCall:  s.StreamingInputCall,
+		FullDuplexCall:      s.FullDuplexCall,
+		HalfDuplexCall:      s.HalfDuplexCall,
+	}
 }
 
 func (s *testServer) EmptyCall(ctx context.Context, in *testpb.Empty) (*testpb.Empty, error) {
diff --git a/profiling/proto/service.pb.go b/profiling/proto/service.pb.go
index 90f0282..831a627 100644
--- a/profiling/proto/service.pb.go
+++ b/profiling/proto/service.pb.go
@@ -4,12 +4,8 @@
 package proto
 
 import (
-	context "context"
 	fmt "fmt"
 	proto "github.com/golang/protobuf/proto"
-	grpc "google.golang.org/grpc"
-	codes "google.golang.org/grpc/codes"
-	status "google.golang.org/grpc/status"
 	math "math"
 )
 
@@ -366,125 +362,3 @@
 	0x95, 0xbb, 0x2e, 0xf9, 0xc9, 0xfd, 0xaf, 0x42, 0xfa, 0xbc, 0xf9, 0x13, 0x00, 0x00, 0xff, 0xff,
 	0x5d, 0x47, 0x09, 0xa9, 0x19, 0x03, 0x00, 0x00,
 }
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ context.Context
-var _ grpc.ClientConnInterface
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the grpc package it is being compiled against.
-const _ = grpc.SupportPackageIsVersion6
-
-// ProfilingClient is the client API for Profiling service.
-//
-// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
-type ProfilingClient interface {
-	// Enable allows users to toggle profiling on and off remotely.
-	Enable(ctx context.Context, in *EnableRequest, opts ...grpc.CallOption) (*EnableResponse, error)
-	// GetStreamStats is used to retrieve an array of stream-level stats from a
-	// gRPC client/server.
-	GetStreamStats(ctx context.Context, in *GetStreamStatsRequest, opts ...grpc.CallOption) (*GetStreamStatsResponse, error)
-}
-
-type profilingClient struct {
-	cc grpc.ClientConnInterface
-}
-
-func NewProfilingClient(cc grpc.ClientConnInterface) ProfilingClient {
-	return &profilingClient{cc}
-}
-
-func (c *profilingClient) Enable(ctx context.Context, in *EnableRequest, opts ...grpc.CallOption) (*EnableResponse, error) {
-	out := new(EnableResponse)
-	err := c.cc.Invoke(ctx, "/grpc.go.profiling.v1alpha.Profiling/Enable", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *profilingClient) GetStreamStats(ctx context.Context, in *GetStreamStatsRequest, opts ...grpc.CallOption) (*GetStreamStatsResponse, error) {
-	out := new(GetStreamStatsResponse)
-	err := c.cc.Invoke(ctx, "/grpc.go.profiling.v1alpha.Profiling/GetStreamStats", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-// ProfilingServer is the server API for Profiling service.
-type ProfilingServer interface {
-	// Enable allows users to toggle profiling on and off remotely.
-	Enable(context.Context, *EnableRequest) (*EnableResponse, error)
-	// GetStreamStats is used to retrieve an array of stream-level stats from a
-	// gRPC client/server.
-	GetStreamStats(context.Context, *GetStreamStatsRequest) (*GetStreamStatsResponse, error)
-}
-
-// UnimplementedProfilingServer can be embedded to have forward compatible implementations.
-type UnimplementedProfilingServer struct {
-}
-
-func (*UnimplementedProfilingServer) Enable(ctx context.Context, req *EnableRequest) (*EnableResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method Enable not implemented")
-}
-func (*UnimplementedProfilingServer) GetStreamStats(ctx context.Context, req *GetStreamStatsRequest) (*GetStreamStatsResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method GetStreamStats not implemented")
-}
-
-func RegisterProfilingServer(s *grpc.Server, srv ProfilingServer) {
-	s.RegisterService(&_Profiling_serviceDesc, srv)
-}
-
-func _Profiling_Enable_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(EnableRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(ProfilingServer).Enable(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/grpc.go.profiling.v1alpha.Profiling/Enable",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(ProfilingServer).Enable(ctx, req.(*EnableRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _Profiling_GetStreamStats_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(GetStreamStatsRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(ProfilingServer).GetStreamStats(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/grpc.go.profiling.v1alpha.Profiling/GetStreamStats",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(ProfilingServer).GetStreamStats(ctx, req.(*GetStreamStatsRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-var _Profiling_serviceDesc = grpc.ServiceDesc{
-	ServiceName: "grpc.go.profiling.v1alpha.Profiling",
-	HandlerType: (*ProfilingServer)(nil),
-	Methods: []grpc.MethodDesc{
-		{
-			MethodName: "Enable",
-			Handler:    _Profiling_Enable_Handler,
-		},
-		{
-			MethodName: "GetStreamStats",
-			Handler:    _Profiling_GetStreamStats_Handler,
-		},
-	},
-	Streams:  []grpc.StreamDesc{},
-	Metadata: "profiling/proto/service.proto",
-}
diff --git a/profiling/proto/service_grpc.pb.go b/profiling/proto/service_grpc.pb.go
index 4145087..02783c9 100644
--- a/profiling/proto/service_grpc.pb.go
+++ b/profiling/proto/service_grpc.pb.go
@@ -13,6 +13,51 @@
 // is compatible with the grpc package it is being compiled against.
 const _ = grpc.SupportPackageIsVersion7
 
+// ProfilingClient is the client API for Profiling service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
+type ProfilingClient interface {
+	// Enable allows users to toggle profiling on and off remotely.
+	Enable(ctx context.Context, in *EnableRequest, opts ...grpc.CallOption) (*EnableResponse, error)
+	// GetStreamStats is used to retrieve an array of stream-level stats from a
+	// gRPC client/server.
+	GetStreamStats(ctx context.Context, in *GetStreamStatsRequest, opts ...grpc.CallOption) (*GetStreamStatsResponse, error)
+}
+
+type profilingClient struct {
+	cc grpc.ClientConnInterface
+}
+
+func NewProfilingClient(cc grpc.ClientConnInterface) ProfilingClient {
+	return &profilingClient{cc}
+}
+
+var profilingEnableStreamDesc = &grpc.StreamDesc{
+	StreamName: "Enable",
+}
+
+func (c *profilingClient) Enable(ctx context.Context, in *EnableRequest, opts ...grpc.CallOption) (*EnableResponse, error) {
+	out := new(EnableResponse)
+	err := c.cc.Invoke(ctx, "/grpc.go.profiling.v1alpha.Profiling/Enable", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+var profilingGetStreamStatsStreamDesc = &grpc.StreamDesc{
+	StreamName: "GetStreamStats",
+}
+
+func (c *profilingClient) GetStreamStats(ctx context.Context, in *GetStreamStatsRequest, opts ...grpc.CallOption) (*GetStreamStatsResponse, error) {
+	out := new(GetStreamStatsResponse)
+	err := c.cc.Invoke(ctx, "/grpc.go.profiling.v1alpha.Profiling/GetStreamStats", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // ProfilingService is the service API for Profiling service.
 // Fields should be assigned to their respective handler implementations only before
 // RegisterProfilingService is called.  Any unassigned fields will result in the
@@ -92,35 +137,35 @@
 	s.RegisterService(&sd, nil)
 }
 
-// NewProfilingService creates a new ProfilingService containing the
-// implemented methods of the Profiling service in s.  Any unimplemented
-// methods will result in the gRPC server returning an UNIMPLEMENTED status to the client.
-// This includes situations where the method handler is misspelled or has the wrong
-// signature.  For this reason, this function should be used with great care and
-// is not recommended to be used by most users.
-func NewProfilingService(s interface{}) *ProfilingService {
-	ns := &ProfilingService{}
-	if h, ok := s.(interface {
-		Enable(context.Context, *EnableRequest) (*EnableResponse, error)
-	}); ok {
-		ns.Enable = h.Enable
-	}
-	if h, ok := s.(interface {
-		GetStreamStats(context.Context, *GetStreamStatsRequest) (*GetStreamStatsResponse, error)
-	}); ok {
-		ns.GetStreamStats = h.GetStreamStats
-	}
-	return ns
-}
-
-// UnstableProfilingService is the service API for Profiling service.
+// ProfilingServer is the service API for Profiling service.
 // New methods may be added to this interface if they are added to the service
 // definition, which is not a backward-compatible change.  For this reason,
-// use of this type is not recommended.
-type UnstableProfilingService interface {
+// use of this type is not recommended unless you own the service definition.
+type ProfilingServer interface {
 	// Enable allows users to toggle profiling on and off remotely.
 	Enable(context.Context, *EnableRequest) (*EnableResponse, error)
 	// GetStreamStats is used to retrieve an array of stream-level stats from a
 	// gRPC client/server.
 	GetStreamStats(context.Context, *GetStreamStatsRequest) (*GetStreamStatsResponse, error)
 }
+
+// UnimplementedProfilingServer can be embedded to have forward compatible implementations of
+// ProfilingServer
+type UnimplementedProfilingServer struct {
+}
+
+func (*UnimplementedProfilingServer) Enable(context.Context, *EnableRequest) (*EnableResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method Enable not implemented")
+}
+func (*UnimplementedProfilingServer) GetStreamStats(context.Context, *GetStreamStatsRequest) (*GetStreamStatsResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method GetStreamStats not implemented")
+}
+
+// RegisterProfilingServer registers a service implementation with a gRPC server.
+func RegisterProfilingServer(s grpc.ServiceRegistrar, srv ProfilingServer) {
+	str := &ProfilingService{
+		Enable:         srv.Enable,
+		GetStreamStats: srv.GetStreamStats,
+	}
+	RegisterProfilingService(s, str)
+}
diff --git a/reflection/grpc_reflection_v1alpha/reflection.pb.go b/reflection/grpc_reflection_v1alpha/reflection.pb.go
index 900bd6c..382612d 100644
--- a/reflection/grpc_reflection_v1alpha/reflection.pb.go
+++ b/reflection/grpc_reflection_v1alpha/reflection.pb.go
@@ -4,12 +4,8 @@
 package grpc_reflection_v1alpha
 
 import (
-	context "context"
 	fmt "fmt"
 	proto "github.com/golang/protobuf/proto"
-	grpc "google.golang.org/grpc"
-	codes "google.golang.org/grpc/codes"
-	status "google.golang.org/grpc/status"
 	math "math"
 )
 
@@ -636,119 +632,3 @@
 	0xcb, 0xb3, 0xdb, 0x8c, 0xdb, 0xea, 0x53, 0xd5, 0xb9, 0xfd, 0xd3, 0x35, 0xdc, 0x54, 0xbe, 0x39,
 	0xfd, 0x1b, 0x00, 0x00, 0xff, 0xff, 0x6c, 0x74, 0x3a, 0x67, 0xe7, 0x06, 0x00, 0x00,
 }
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ context.Context
-var _ grpc.ClientConnInterface
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the grpc package it is being compiled against.
-const _ = grpc.SupportPackageIsVersion6
-
-// ServerReflectionClient is the client API for ServerReflection service.
-//
-// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
-type ServerReflectionClient interface {
-	// The reflection service is structured as a bidirectional stream, ensuring
-	// all related requests go to a single server.
-	ServerReflectionInfo(ctx context.Context, opts ...grpc.CallOption) (ServerReflection_ServerReflectionInfoClient, error)
-}
-
-type serverReflectionClient struct {
-	cc grpc.ClientConnInterface
-}
-
-func NewServerReflectionClient(cc grpc.ClientConnInterface) ServerReflectionClient {
-	return &serverReflectionClient{cc}
-}
-
-func (c *serverReflectionClient) ServerReflectionInfo(ctx context.Context, opts ...grpc.CallOption) (ServerReflection_ServerReflectionInfoClient, error) {
-	stream, err := c.cc.NewStream(ctx, &_ServerReflection_serviceDesc.Streams[0], "/grpc.reflection.v1alpha.ServerReflection/ServerReflectionInfo", opts...)
-	if err != nil {
-		return nil, err
-	}
-	x := &serverReflectionServerReflectionInfoClient{stream}
-	return x, nil
-}
-
-type ServerReflection_ServerReflectionInfoClient interface {
-	Send(*ServerReflectionRequest) error
-	Recv() (*ServerReflectionResponse, error)
-	grpc.ClientStream
-}
-
-type serverReflectionServerReflectionInfoClient struct {
-	grpc.ClientStream
-}
-
-func (x *serverReflectionServerReflectionInfoClient) Send(m *ServerReflectionRequest) error {
-	return x.ClientStream.SendMsg(m)
-}
-
-func (x *serverReflectionServerReflectionInfoClient) Recv() (*ServerReflectionResponse, error) {
-	m := new(ServerReflectionResponse)
-	if err := x.ClientStream.RecvMsg(m); err != nil {
-		return nil, err
-	}
-	return m, nil
-}
-
-// ServerReflectionServer is the server API for ServerReflection service.
-type ServerReflectionServer interface {
-	// The reflection service is structured as a bidirectional stream, ensuring
-	// all related requests go to a single server.
-	ServerReflectionInfo(ServerReflection_ServerReflectionInfoServer) error
-}
-
-// UnimplementedServerReflectionServer can be embedded to have forward compatible implementations.
-type UnimplementedServerReflectionServer struct {
-}
-
-func (*UnimplementedServerReflectionServer) ServerReflectionInfo(srv ServerReflection_ServerReflectionInfoServer) error {
-	return status.Errorf(codes.Unimplemented, "method ServerReflectionInfo not implemented")
-}
-
-func RegisterServerReflectionServer(s *grpc.Server, srv ServerReflectionServer) {
-	s.RegisterService(&_ServerReflection_serviceDesc, srv)
-}
-
-func _ServerReflection_ServerReflectionInfo_Handler(srv interface{}, stream grpc.ServerStream) error {
-	return srv.(ServerReflectionServer).ServerReflectionInfo(&serverReflectionServerReflectionInfoServer{stream})
-}
-
-type ServerReflection_ServerReflectionInfoServer interface {
-	Send(*ServerReflectionResponse) error
-	Recv() (*ServerReflectionRequest, error)
-	grpc.ServerStream
-}
-
-type serverReflectionServerReflectionInfoServer struct {
-	grpc.ServerStream
-}
-
-func (x *serverReflectionServerReflectionInfoServer) Send(m *ServerReflectionResponse) error {
-	return x.ServerStream.SendMsg(m)
-}
-
-func (x *serverReflectionServerReflectionInfoServer) Recv() (*ServerReflectionRequest, error) {
-	m := new(ServerReflectionRequest)
-	if err := x.ServerStream.RecvMsg(m); err != nil {
-		return nil, err
-	}
-	return m, nil
-}
-
-var _ServerReflection_serviceDesc = grpc.ServiceDesc{
-	ServiceName: "grpc.reflection.v1alpha.ServerReflection",
-	HandlerType: (*ServerReflectionServer)(nil),
-	Methods:     []grpc.MethodDesc{},
-	Streams: []grpc.StreamDesc{
-		{
-			StreamName:    "ServerReflectionInfo",
-			Handler:       _ServerReflection_ServerReflectionInfo_Handler,
-			ServerStreams: true,
-			ClientStreams: true,
-		},
-	},
-	Metadata: "reflection/grpc_reflection_v1alpha/reflection.proto",
-}
diff --git a/reflection/grpc_reflection_v1alpha/reflection_grpc.pb.go b/reflection/grpc_reflection_v1alpha/reflection_grpc.pb.go
index 5524152..eface9e 100644
--- a/reflection/grpc_reflection_v1alpha/reflection_grpc.pb.go
+++ b/reflection/grpc_reflection_v1alpha/reflection_grpc.pb.go
@@ -3,6 +3,7 @@
 package grpc_reflection_v1alpha
 
 import (
+	context "context"
 	grpc "google.golang.org/grpc"
 	codes "google.golang.org/grpc/codes"
 	status "google.golang.org/grpc/status"
@@ -12,6 +13,60 @@
 // is compatible with the grpc package it is being compiled against.
 const _ = grpc.SupportPackageIsVersion7
 
+// ServerReflectionClient is the client API for ServerReflection service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
+type ServerReflectionClient interface {
+	// The reflection service is structured as a bidirectional stream, ensuring
+	// all related requests go to a single server.
+	ServerReflectionInfo(ctx context.Context, opts ...grpc.CallOption) (ServerReflection_ServerReflectionInfoClient, error)
+}
+
+type serverReflectionClient struct {
+	cc grpc.ClientConnInterface
+}
+
+func NewServerReflectionClient(cc grpc.ClientConnInterface) ServerReflectionClient {
+	return &serverReflectionClient{cc}
+}
+
+var serverReflectionServerReflectionInfoStreamDesc = &grpc.StreamDesc{
+	StreamName:    "ServerReflectionInfo",
+	ServerStreams: true,
+	ClientStreams: true,
+}
+
+func (c *serverReflectionClient) ServerReflectionInfo(ctx context.Context, opts ...grpc.CallOption) (ServerReflection_ServerReflectionInfoClient, error) {
+	stream, err := c.cc.NewStream(ctx, serverReflectionServerReflectionInfoStreamDesc, "/grpc.reflection.v1alpha.ServerReflection/ServerReflectionInfo", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &serverReflectionServerReflectionInfoClient{stream}
+	return x, nil
+}
+
+type ServerReflection_ServerReflectionInfoClient interface {
+	Send(*ServerReflectionRequest) error
+	Recv() (*ServerReflectionResponse, error)
+	grpc.ClientStream
+}
+
+type serverReflectionServerReflectionInfoClient struct {
+	grpc.ClientStream
+}
+
+func (x *serverReflectionServerReflectionInfoClient) Send(m *ServerReflectionRequest) error {
+	return x.ClientStream.SendMsg(m)
+}
+
+func (x *serverReflectionServerReflectionInfoClient) Recv() (*ServerReflectionResponse, error) {
+	m := new(ServerReflectionResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
 // ServerReflectionService is the service API for ServerReflection service.
 // Fields should be assigned to their respective handler implementations only before
 // RegisterServerReflectionService is called.  Any unassigned fields will result in the
@@ -26,6 +81,28 @@
 	return s.ServerReflectionInfo(&serverReflectionServerReflectionInfoServer{stream})
 }
 
+type ServerReflection_ServerReflectionInfoServer interface {
+	Send(*ServerReflectionResponse) error
+	Recv() (*ServerReflectionRequest, error)
+	grpc.ServerStream
+}
+
+type serverReflectionServerReflectionInfoServer struct {
+	grpc.ServerStream
+}
+
+func (x *serverReflectionServerReflectionInfoServer) Send(m *ServerReflectionResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+func (x *serverReflectionServerReflectionInfoServer) Recv() (*ServerReflectionRequest, error) {
+	m := new(ServerReflectionRequest)
+	if err := x.ServerStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
 // RegisterServerReflectionService registers a service implementation with a gRPC server.
 func RegisterServerReflectionService(s grpc.ServiceRegistrar, srv *ServerReflectionService) {
 	srvCopy := *srv
@@ -51,28 +128,29 @@
 	s.RegisterService(&sd, nil)
 }
 
-// NewServerReflectionService creates a new ServerReflectionService containing the
-// implemented methods of the ServerReflection service in s.  Any unimplemented
-// methods will result in the gRPC server returning an UNIMPLEMENTED status to the client.
-// This includes situations where the method handler is misspelled or has the wrong
-// signature.  For this reason, this function should be used with great care and
-// is not recommended to be used by most users.
-func NewServerReflectionService(s interface{}) *ServerReflectionService {
-	ns := &ServerReflectionService{}
-	if h, ok := s.(interface {
-		ServerReflectionInfo(ServerReflection_ServerReflectionInfoServer) error
-	}); ok {
-		ns.ServerReflectionInfo = h.ServerReflectionInfo
-	}
-	return ns
-}
-
-// UnstableServerReflectionService is the service API for ServerReflection service.
+// ServerReflectionServer is the service API for ServerReflection service.
 // New methods may be added to this interface if they are added to the service
 // definition, which is not a backward-compatible change.  For this reason,
-// use of this type is not recommended.
-type UnstableServerReflectionService interface {
+// use of this type is not recommended unless you own the service definition.
+type ServerReflectionServer interface {
 	// The reflection service is structured as a bidirectional stream, ensuring
 	// all related requests go to a single server.
 	ServerReflectionInfo(ServerReflection_ServerReflectionInfoServer) error
 }
+
+// UnimplementedServerReflectionServer can be embedded to have forward compatible implementations of
+// ServerReflectionServer
+type UnimplementedServerReflectionServer struct {
+}
+
+func (*UnimplementedServerReflectionServer) ServerReflectionInfo(ServerReflection_ServerReflectionInfoServer) error {
+	return status.Errorf(codes.Unimplemented, "method ServerReflectionInfo not implemented")
+}
+
+// RegisterServerReflectionServer registers a service implementation with a gRPC server.
+func RegisterServerReflectionServer(s grpc.ServiceRegistrar, srv ServerReflectionServer) {
+	str := &ServerReflectionService{
+		ServerReflectionInfo: srv.ServerReflectionInfo,
+	}
+	RegisterServerReflectionService(s, str)
+}
diff --git a/reflection/grpc_testing/test_grpc.pb.go b/reflection/grpc_testing/test_grpc.pb.go
index 2749e16..503c856 100644
--- a/reflection/grpc_testing/test_grpc.pb.go
+++ b/reflection/grpc_testing/test_grpc.pb.go
@@ -165,33 +165,3 @@
 
 	s.RegisterService(&sd, nil)
 }
-
-// NewSearchServiceService creates a new SearchServiceService containing the
-// implemented methods of the SearchService service in s.  Any unimplemented
-// methods will result in the gRPC server returning an UNIMPLEMENTED status to the client.
-// This includes situations where the method handler is misspelled or has the wrong
-// signature.  For this reason, this function should be used with great care and
-// is not recommended to be used by most users.
-func NewSearchServiceService(s interface{}) *SearchServiceService {
-	ns := &SearchServiceService{}
-	if h, ok := s.(interface {
-		Search(context.Context, *SearchRequest) (*SearchResponse, error)
-	}); ok {
-		ns.Search = h.Search
-	}
-	if h, ok := s.(interface {
-		StreamingSearch(SearchService_StreamingSearchServer) error
-	}); ok {
-		ns.StreamingSearch = h.StreamingSearch
-	}
-	return ns
-}
-
-// UnstableSearchServiceService is the service API for SearchService service.
-// New methods may be added to this interface if they are added to the service
-// definition, which is not a backward-compatible change.  For this reason,
-// use of this type is not recommended.
-type UnstableSearchServiceService interface {
-	Search(context.Context, *SearchRequest) (*SearchResponse, error)
-	StreamingSearch(SearchService_StreamingSearchServer) error
-}
diff --git a/reflection/serverreflection_test.go b/reflection/serverreflection_test.go
index 9f252d7..95b8269 100644
--- a/reflection/serverreflection_test.go
+++ b/reflection/serverreflection_test.go
@@ -168,7 +168,12 @@
 
 type server struct{}
 
-var _ pb.UnstableSearchServiceService = (*server)(nil)
+func (s *server) Svc() *pb.SearchServiceService {
+	return &pb.SearchServiceService{
+		Search:          s.Search,
+		StreamingSearch: s.StreamingSearch,
+	}
+}
 
 func (s *server) Search(ctx context.Context, in *pb.SearchRequest) (*pb.SearchResponse, error) {
 	return &pb.SearchResponse{}, nil
@@ -195,7 +200,7 @@
 		t.Fatalf("failed to listen: %v", err)
 	}
 	s := grpc.NewServer()
-	pb.RegisterSearchServiceService(s, pb.NewSearchServiceService(&server{}))
+	pb.RegisterSearchServiceService(s, (&server{}).Svc())
 	pbv3.RegisterSearchServiceV3Server(s, &serverV3{})
 	// Register reflection service on s.
 	Register(s)
diff --git a/regenerate.sh b/regenerate.sh
index 750e350..c10bc99 100755
--- a/regenerate.sh
+++ b/regenerate.sh
@@ -96,7 +96,7 @@
 
 for src in ${LEGACY_SOURCES[@]}; do
   echo "protoc ${src}"
-  protoc --go_out=${OPTS},plugins=grpc:${WORKDIR}/out --go-grpc_out=${OPTS},migration_mode=true:${WORKDIR}/out \
+  protoc --go_out=${OPTS}:${WORKDIR}/out --go-grpc_out=${OPTS},gen_unstable_server_interfaces=true:${WORKDIR}/out \
     -I"." \
     -I${WORKDIR}/grpc-proto \
     -I${WORKDIR}/googleapis \
diff --git a/security/advancedtls/advancedtls_integration_test.go b/security/advancedtls/advancedtls_integration_test.go
index a794e0d..dc4f513 100644
--- a/security/advancedtls/advancedtls_integration_test.go
+++ b/security/advancedtls/advancedtls_integration_test.go
@@ -130,11 +130,8 @@
 	return nil
 }
 
-// serverImpl is used to implement pb.GreeterServer.
-type serverImpl struct{}
-
-// SayHello is a simple implementation of pb.GreeterServer.
-func (s *serverImpl) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloReply, error) {
+// sayHello is a simple implementation of the pb.GreeterServer SayHello method.
+func sayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloReply, error) {
 	return &pb.HelloReply{Message: "Hello " + in.Name}, nil
 }
 
@@ -409,7 +406,7 @@
 				t.Fatalf("failed to listen: %v", err)
 			}
 			defer lis.Close()
-			pb.RegisterGreeterService(s, pb.NewGreeterService(&serverImpl{}))
+			pb.RegisterGreeterService(s, &pb.GreeterService{SayHello: sayHello})
 			go s.Serve(lis)
 			clientOptions := &ClientOptions{
 				Certificates:         test.clientCert,
diff --git a/stats/grpc_testing/test_grpc.pb.go b/stats/grpc_testing/test_grpc.pb.go
index c131efe..32f93dd 100644
--- a/stats/grpc_testing/test_grpc.pb.go
+++ b/stats/grpc_testing/test_grpc.pb.go
@@ -324,52 +324,3 @@
 
 	s.RegisterService(&sd, nil)
 }
-
-// NewTestServiceService creates a new TestServiceService containing the
-// implemented methods of the TestService service in s.  Any unimplemented
-// methods will result in the gRPC server returning an UNIMPLEMENTED status to the client.
-// This includes situations where the method handler is misspelled or has the wrong
-// signature.  For this reason, this function should be used with great care and
-// is not recommended to be used by most users.
-func NewTestServiceService(s interface{}) *TestServiceService {
-	ns := &TestServiceService{}
-	if h, ok := s.(interface {
-		UnaryCall(context.Context, *SimpleRequest) (*SimpleResponse, error)
-	}); ok {
-		ns.UnaryCall = h.UnaryCall
-	}
-	if h, ok := s.(interface {
-		FullDuplexCall(TestService_FullDuplexCallServer) error
-	}); ok {
-		ns.FullDuplexCall = h.FullDuplexCall
-	}
-	if h, ok := s.(interface {
-		ClientStreamCall(TestService_ClientStreamCallServer) error
-	}); ok {
-		ns.ClientStreamCall = h.ClientStreamCall
-	}
-	if h, ok := s.(interface {
-		ServerStreamCall(*SimpleRequest, TestService_ServerStreamCallServer) error
-	}); ok {
-		ns.ServerStreamCall = h.ServerStreamCall
-	}
-	return ns
-}
-
-// UnstableTestServiceService is the service API for TestService service.
-// New methods may be added to this interface if they are added to the service
-// definition, which is not a backward-compatible change.  For this reason,
-// use of this type is not recommended.
-type UnstableTestServiceService interface {
-	// One request followed by one response.
-	// The server returns the client id as-is.
-	UnaryCall(context.Context, *SimpleRequest) (*SimpleResponse, error)
-	// A sequence of requests with each request served by the server immediately.
-	// As one request could lead to multiple responses, this interface
-	// demonstrates the idea of full duplexing.
-	FullDuplexCall(TestService_FullDuplexCallServer) error
-	// Client stream
-	ClientStreamCall(TestService_ClientStreamCallServer) error
-	// Server stream
-	ServerStreamCall(*SimpleRequest, TestService_ServerStreamCallServer) error
-}
diff --git a/stats/stats_test.go b/stats/stats_test.go
index 628533e..90b9cdb 100644
--- a/stats/stats_test.go
+++ b/stats/stats_test.go
@@ -75,7 +75,14 @@
 
 type testServer struct{}
 
-var _ testpb.UnstableTestServiceService = (*testServer)(nil)
+func (s *testServer) Svc() *testpb.TestServiceService {
+	return &testpb.TestServiceService{
+		UnaryCall:        s.UnaryCall,
+		FullDuplexCall:   s.FullDuplexCall,
+		ClientStreamCall: s.ClientStreamCall,
+		ServerStreamCall: s.ServerStreamCall,
+	}
+}
 
 func (s *testServer) UnaryCall(ctx context.Context, in *testpb.SimpleRequest) (*testpb.SimpleResponse, error) {
 	if err := grpc.SendHeader(ctx, testHeaderMetadata); err != nil {
@@ -815,7 +822,7 @@
 func testServerStats(t *testing.T, tc *testConfig, cc *rpcConfig, checkFuncs []func(t *testing.T, d *gotData, e *expectedData)) {
 	h := &statshandler{}
 	te := newTest(t, tc, nil, h)
-	te.startServer(testpb.NewTestServiceService(&testServer{}))
+	te.startServer((&testServer{}).Svc())
 	defer te.tearDown()
 
 	var (
@@ -1106,7 +1113,7 @@
 func testClientStats(t *testing.T, tc *testConfig, cc *rpcConfig, checkFuncs map[int]*checkFuncWithCount) {
 	h := &statshandler{}
 	te := newTest(t, tc, h, nil)
-	te.startServer(testpb.NewTestServiceService(&testServer{}))
+	te.startServer((&testServer{}).Svc())
 	defer te.tearDown()
 
 	var (
diff --git a/stress/client/main.go b/stress/client/main.go
index 0353476..c91aeb0 100644
--- a/stress/client/main.go
+++ b/stress/client/main.go
@@ -151,13 +151,18 @@
 	gauges map[string]*gauge
 }
 
-var _ metricspb.UnstableMetricsServiceService = (*server)(nil)
-
 // newMetricsServer returns a new metrics server.
 func newMetricsServer() *server {
 	return &server{gauges: make(map[string]*gauge)}
 }
 
+func (s *server) Svc() *metricspb.MetricsServiceService {
+	return &metricspb.MetricsServiceService{
+		GetAllGauges: s.GetAllGauges,
+		GetGauge:     s.GetGauge,
+	}
+}
+
 // GetAllGauges returns all gauges.
 func (s *server) GetAllGauges(in *metricspb.EmptyMessage, stream metricspb.MetricsService_GetAllGaugesServer) error {
 	s.mutex.RLock()
@@ -203,9 +208,8 @@
 	}
 
 	s := grpc.NewServer()
-	metricspb.RegisterMetricsServiceService(s, metricspb.NewMetricsServiceService(server))
+	metricspb.RegisterMetricsServiceService(s, server.Svc())
 	s.Serve(lis)
-
 }
 
 // performRPCs uses weightedRandomTestSelector to select test case and runs the tests.
diff --git a/stress/grpc_testing/metrics_grpc.pb.go b/stress/grpc_testing/metrics_grpc.pb.go
index 6ae1c80..b28a52e 100644
--- a/stress/grpc_testing/metrics_grpc.pb.go
+++ b/stress/grpc_testing/metrics_grpc.pb.go
@@ -165,36 +165,3 @@
 
 	s.RegisterService(&sd, nil)
 }
-
-// NewMetricsServiceService creates a new MetricsServiceService containing the
-// implemented methods of the MetricsService service in s.  Any unimplemented
-// methods will result in the gRPC server returning an UNIMPLEMENTED status to the client.
-// This includes situations where the method handler is misspelled or has the wrong
-// signature.  For this reason, this function should be used with great care and
-// is not recommended to be used by most users.
-func NewMetricsServiceService(s interface{}) *MetricsServiceService {
-	ns := &MetricsServiceService{}
-	if h, ok := s.(interface {
-		GetAllGauges(*EmptyMessage, MetricsService_GetAllGaugesServer) error
-	}); ok {
-		ns.GetAllGauges = h.GetAllGauges
-	}
-	if h, ok := s.(interface {
-		GetGauge(context.Context, *GaugeRequest) (*GaugeResponse, error)
-	}); ok {
-		ns.GetGauge = h.GetGauge
-	}
-	return ns
-}
-
-// UnstableMetricsServiceService is the service API for MetricsService service.
-// New methods may be added to this interface if they are added to the service
-// definition, which is not a backward-compatible change.  For this reason,
-// use of this type is not recommended.
-type UnstableMetricsServiceService interface {
-	// Returns the values of all the gauges that are currently being maintained by
-	// the service
-	GetAllGauges(*EmptyMessage, MetricsService_GetAllGaugesServer) error
-	// Returns the value of one gauge
-	GetGauge(context.Context, *GaugeRequest) (*GaugeResponse, error)
-}
diff --git a/test/balancer_test.go b/test/balancer_test.go
index a94e25a..43e5021 100644
--- a/test/balancer_test.go
+++ b/test/balancer_test.go
@@ -179,7 +179,7 @@
 		grpc.WithBalancerName(testBalancerName),
 		grpc.WithUserAgent(testUserAgent),
 	}
-	te.startServer((&testServer{security: e.security}).Svc())
+	te.startServer(testServer{security: e.security}.Svc())
 	defer te.tearDown()
 
 	// Set resolver to xds to trigger the extra metadata code path.
@@ -228,7 +228,7 @@
 		grpc.WithBalancerName(testBalancerName),
 	}
 	te.userAgent = failAppUA
-	te.startServer((&testServer{security: e.security}).Svc())
+	te.startServer(testServer{security: e.security}.Svc())
 	defer te.tearDown()
 
 	cc := te.clientConn()
@@ -498,7 +498,7 @@
 	}
 
 	s := grpc.NewServer()
-	testpb.RegisterTestServiceService(s, testServer{}.Svc())
+	testpb.RegisterTestServiceService(s, (&testServer{}).Svc())
 	go s.Serve(lis)
 	defer s.Stop()
 	t.Logf("Started gRPC server at %s...", lis.Addr().String())
diff --git a/test/end2end_test.go b/test/end2end_test.go
index b0fa10b..01f99cb 100644
--- a/test/end2end_test.go
+++ b/test/end2end_test.go
@@ -134,8 +134,6 @@
 	unaryCallSleepTime time.Duration
 }
 
-var _ testpb.UnstableTestServiceService = (*testServer)(nil)
-
 // Svc returns a registerable TestService for this testServer instances.
 // Because `s` is passed by value for convenience, any subsequent changes to
 // `s` are not recognized.
@@ -4859,10 +4857,10 @@
 	defer lis.Close()
 
 	s := grpc.NewServer()
-	testpb.RegisterTestServiceService(s, testpb.NewTestServiceService(&flowControlLogicalRaceServer{
+	testpb.RegisterTestServiceService(s, (&flowControlLogicalRaceServer{
 		itemCount: itemCount,
 		itemSize:  itemSize,
-	}))
+	}).Svc())
 	defer s.Stop()
 
 	go s.Serve(lis)
@@ -4920,6 +4918,12 @@
 	itemCount int
 }
 
+func (s *flowControlLogicalRaceServer) Svc() *testpb.TestServiceService {
+	return &testpb.TestServiceService{
+		StreamingOutputCall: s.StreamingOutputCall,
+	}
+}
+
 func (s *flowControlLogicalRaceServer) StreamingOutputCall(req *testpb.StreamingOutputCallRequest, srv testpb.TestService_StreamingOutputCallServer) error {
 	for i := 0; i < s.itemCount; i++ {
 		err := srv.Send(&testpb.StreamingOutputCallResponse{
@@ -5083,16 +5087,12 @@
 	r *manual.Resolver
 }
 
-func (ss *stubServer) EmptyCall(ctx context.Context, in *testpb.Empty) (*testpb.Empty, error) {
-	return ss.emptyCall(ctx, in)
-}
-
-func (ss *stubServer) UnaryCall(ctx context.Context, in *testpb.SimpleRequest) (*testpb.SimpleResponse, error) {
-	return ss.unaryCall(ctx, in)
-}
-
-func (ss *stubServer) FullDuplexCall(stream testpb.TestService_FullDuplexCallServer) error {
-	return ss.fullDuplexCall(stream)
+func (ss *stubServer) Svc() *testpb.TestServiceService {
+	return &testpb.TestServiceService{
+		EmptyCall:      ss.emptyCall,
+		UnaryCall:      ss.unaryCall,
+		FullDuplexCall: ss.fullDuplexCall,
+	}
 }
 
 // Start starts the server and creates a client connected to it.
@@ -5115,7 +5115,7 @@
 	ss.cleanups = append(ss.cleanups, func() { lis.Close() })
 
 	s := grpc.NewServer(sopts...)
-	testpb.RegisterTestServiceService(s, testpb.NewTestServiceService(ss))
+	testpb.RegisterTestServiceService(s, ss.Svc())
 	go s.Serve(lis)
 	ss.cleanups = append(ss.cleanups, s.Stop)
 	ss.s = s
@@ -6258,7 +6258,7 @@
 
 	s := grpc.NewServer()
 	defer s.Stop()
-	testpb.RegisterTestServiceService(s, testpb.NewTestServiceService(ss))
+	testpb.RegisterTestServiceService(s, ss.Svc())
 
 	lis, err := net.Listen("tcp", "localhost:0")
 	if err != nil {
@@ -6477,7 +6477,7 @@
 	}
 
 	s := grpc.NewServer(grpc.WriteBufferSize(0), grpc.ReadBufferSize(0))
-	testpb.RegisterTestServiceService(s, testpb.NewTestServiceService(ss))
+	testpb.RegisterTestServiceService(s, ss.Svc())
 
 	lis, err := net.Listen("tcp", "localhost:0")
 	if err != nil {
diff --git a/test/goaway_test.go b/test/goaway_test.go
index 93d9648..1e00976 100644
--- a/test/goaway_test.go
+++ b/test/goaway_test.go
@@ -48,7 +48,7 @@
 
 	s := grpc.NewServer(grpc.KeepaliveParams(keepalive.ServerParameters{MaxConnectionAge: maxConnAge}))
 	defer s.Stop()
-	testpb.RegisterTestServiceService(s, testpb.NewTestServiceService(ss))
+	testpb.RegisterTestServiceService(s, ss.Svc())
 
 	lis, err := net.Listen("tcp", "localhost:0")
 	if err != nil {
diff --git a/test/gracefulstop_test.go b/test/gracefulstop_test.go
index f765952..1f5f1e7 100644
--- a/test/gracefulstop_test.go
+++ b/test/gracefulstop_test.go
@@ -117,7 +117,7 @@
 		},
 	}
 	s := grpc.NewServer()
-	testpb.RegisterTestServiceService(s, testpb.NewTestServiceService(ss))
+	testpb.RegisterTestServiceService(s, ss.Svc())
 
 	// 1. Start Server
 	wg := sync.WaitGroup{}
diff --git a/test/grpc_testing/test_grpc.pb.go b/test/grpc_testing/test_grpc.pb.go
index 7bcc9b0..45ae655 100644
--- a/test/grpc_testing/test_grpc.pb.go
+++ b/test/grpc_testing/test_grpc.pb.go
@@ -454,71 +454,3 @@
 
 	s.RegisterService(&sd, nil)
 }
-
-// NewTestServiceService creates a new TestServiceService containing the
-// implemented methods of the TestService service in s.  Any unimplemented
-// methods will result in the gRPC server returning an UNIMPLEMENTED status to the client.
-// This includes situations where the method handler is misspelled or has the wrong
-// signature.  For this reason, this function should be used with great care and
-// is not recommended to be used by most users.
-func NewTestServiceService(s interface{}) *TestServiceService {
-	ns := &TestServiceService{}
-	if h, ok := s.(interface {
-		EmptyCall(context.Context, *Empty) (*Empty, error)
-	}); ok {
-		ns.EmptyCall = h.EmptyCall
-	}
-	if h, ok := s.(interface {
-		UnaryCall(context.Context, *SimpleRequest) (*SimpleResponse, error)
-	}); ok {
-		ns.UnaryCall = h.UnaryCall
-	}
-	if h, ok := s.(interface {
-		StreamingOutputCall(*StreamingOutputCallRequest, TestService_StreamingOutputCallServer) error
-	}); ok {
-		ns.StreamingOutputCall = h.StreamingOutputCall
-	}
-	if h, ok := s.(interface {
-		StreamingInputCall(TestService_StreamingInputCallServer) error
-	}); ok {
-		ns.StreamingInputCall = h.StreamingInputCall
-	}
-	if h, ok := s.(interface {
-		FullDuplexCall(TestService_FullDuplexCallServer) error
-	}); ok {
-		ns.FullDuplexCall = h.FullDuplexCall
-	}
-	if h, ok := s.(interface {
-		HalfDuplexCall(TestService_HalfDuplexCallServer) error
-	}); ok {
-		ns.HalfDuplexCall = h.HalfDuplexCall
-	}
-	return ns
-}
-
-// UnstableTestServiceService is the service API for TestService service.
-// New methods may be added to this interface if they are added to the service
-// definition, which is not a backward-compatible change.  For this reason,
-// use of this type is not recommended.
-type UnstableTestServiceService interface {
-	// One empty request followed by one empty response.
-	EmptyCall(context.Context, *Empty) (*Empty, error)
-	// One request followed by one response.
-	// The server returns the client payload as-is.
-	UnaryCall(context.Context, *SimpleRequest) (*SimpleResponse, error)
-	// One request followed by a sequence of responses (streamed download).
-	// The server returns the payload with client desired type and sizes.
-	StreamingOutputCall(*StreamingOutputCallRequest, TestService_StreamingOutputCallServer) error
-	// A sequence of requests followed by one response (streamed upload).
-	// The server returns the aggregated size of client payload as the result.
-	StreamingInputCall(TestService_StreamingInputCallServer) error
-	// A sequence of requests with each request served by the server immediately.
-	// As one request could lead to multiple responses, this interface
-	// demonstrates the idea of full duplexing.
-	FullDuplexCall(TestService_FullDuplexCallServer) error
-	// A sequence of requests followed by a sequence of responses.
-	// The server buffers all the client requests and then serves them in order. A
-	// stream of responses are returned to the client when the server starts with
-	// first request.
-	HalfDuplexCall(TestService_HalfDuplexCallServer) error
-}
diff --git a/test/local_creds_test.go b/test/local_creds_test.go
index 12af20b..86969c1 100644
--- a/test/local_creds_test.go
+++ b/test/local_creds_test.go
@@ -64,7 +64,7 @@
 	s := grpc.NewServer(sopts...)
 	defer s.Stop()
 
-	testpb.RegisterTestServiceService(s, testpb.NewTestServiceService(ss))
+	testpb.RegisterTestServiceService(s, ss.Svc())
 
 	lis, err := net.Listen(network, address)
 	if err != nil {
@@ -162,7 +162,7 @@
 	s := grpc.NewServer(sopts...)
 	defer s.Stop()
 
-	testpb.RegisterTestServiceService(s, testpb.NewTestServiceService(ss))
+	testpb.RegisterTestServiceService(s, ss.Svc())
 
 	lis, err := net.Listen("tcp", "localhost:0")
 	if err != nil {