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

package nextgenv1

import (
	context "context"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
)

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

const (
	ResourcePoolService_CreateResourcePool_FullMethodName                  = "/global.nextgen.v1.ResourcePoolService/CreateResourcePool"
	ResourcePoolService_ListResourcePools_FullMethodName                   = "/global.nextgen.v1.ResourcePoolService/ListResourcePools"
	ResourcePoolService_UpdateResourcePoolName_FullMethodName              = "/global.nextgen.v1.ResourcePoolService/UpdateResourcePoolName"
	ResourcePoolService_UpdateResourcePoolInstanceLimit_FullMethodName     = "/global.nextgen.v1.ResourcePoolService/UpdateResourcePoolInstanceLimit"
	ResourcePoolService_GetResourcePool_FullMethodName                     = "/global.nextgen.v1.ResourcePoolService/GetResourcePool"
	ResourcePoolService_DeleteResourcePool_FullMethodName                  = "/global.nextgen.v1.ResourcePoolService/DeleteResourcePool"
	ResourcePoolService_ListOwnerResourcePools_FullMethodName              = "/global.nextgen.v1.ResourcePoolService/ListOwnerResourcePools"
	ResourcePoolService_UpdateOrgDefaultResourcePool_FullMethodName        = "/global.nextgen.v1.ResourcePoolService/UpdateOrgDefaultResourcePool"
	ResourcePoolService_GetResourcePoolCapacityConstraints_FullMethodName  = "/global.nextgen.v1.ResourcePoolService/GetResourcePoolCapacityConstraints"
	ResourcePoolService_ResizeResourcePoolCapacity_FullMethodName          = "/global.nextgen.v1.ResourcePoolService/ResizeResourcePoolCapacity"
	ResourcePoolService_UpsertResourcePoolCloudResourceTags_FullMethodName = "/global.nextgen.v1.ResourcePoolService/UpsertResourcePoolCloudResourceTags"
	ResourcePoolService_PauseResourcePool_FullMethodName                   = "/global.nextgen.v1.ResourcePoolService/PauseResourcePool"
	ResourcePoolService_BeginPauseResourcePoolAdmission_FullMethodName     = "/global.nextgen.v1.ResourcePoolService/BeginPauseResourcePoolAdmission"
	ResourcePoolService_ResolvePauseResourcePoolAdmission_FullMethodName   = "/global.nextgen.v1.ResourcePoolService/ResolvePauseResourcePoolAdmission"
	ResourcePoolService_ResumeResourcePool_FullMethodName                  = "/global.nextgen.v1.ResourcePoolService/ResumeResourcePool"
	ResourcePoolService_GetResourcePoolPauseResumeOperation_FullMethodName = "/global.nextgen.v1.ResourcePoolService/GetResourcePoolPauseResumeOperation"
)

// ResourcePoolServiceClient is the client API for ResourcePoolService 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 ResourcePoolServiceClient interface {
	CreateResourcePool(ctx context.Context, in *CreateResourcePoolRequest, opts ...grpc.CallOption) (*ResourcePoolProfile, error)
	ListResourcePools(ctx context.Context, in *ListResourcePoolsRequest, opts ...grpc.CallOption) (*ListResourcePoolsResponse, error)
	UpdateResourcePoolName(ctx context.Context, in *UpdateResourcePoolNameRequest, opts ...grpc.CallOption) (*ResourcePool, error)
	UpdateResourcePoolInstanceLimit(ctx context.Context, in *UpdateResourcePoolInstanceLimitRequest, opts ...grpc.CallOption) (*ResourcePool, error)
	GetResourcePool(ctx context.Context, in *GetResourcePoolRequest, opts ...grpc.CallOption) (*ResourcePoolProfile, error)
	DeleteResourcePool(ctx context.Context, in *DeleteResourcePoolRequest, opts ...grpc.CallOption) (*ResourcePool, error)
	ListOwnerResourcePools(ctx context.Context, in *ListOwnerResourcePoolsRequest, opts ...grpc.CallOption) (*ListOwnerResourcePoolsResponse, error)
	UpdateOrgDefaultResourcePool(ctx context.Context, in *UpdateOrgDefaultResourcePoolRequest, opts ...grpc.CallOption) (*ResourcePoolStrategy, error)
	GetResourcePoolCapacityConstraints(ctx context.Context, in *GetResourcePoolCapacityConstraintsRequest, opts ...grpc.CallOption) (*ResourcePoolCapacityConstraints, error)
	ResizeResourcePoolCapacity(ctx context.Context, in *ResizeResourcePoolCapacityRequest, opts ...grpc.CallOption) (*ResizeResourcePoolCapacityResponse, error)
	UpsertResourcePoolCloudResourceTags(ctx context.Context, in *UpsertResourcePoolCloudResourceTagsRequest, opts ...grpc.CallOption) (*UpsertResourcePoolCloudResourceTagsResponse, error)
	// Resource Pool lifecycle control APIs are internal-only. They validate,
	// start, and monitor asynchronous Pause/Resume workflows. Once a workflow
	// is accepted, it cannot be canceled through the current contract; canceling
	// a caller-side DevOps operation does not cancel the Global or Regional
	// operation.
	PauseResourcePool(ctx context.Context, in *PauseResourcePoolRequest, opts ...grpc.CallOption) (*PauseResourcePoolResponse, error)
	BeginPauseResourcePoolAdmission(ctx context.Context, in *BeginPauseResourcePoolAdmissionRequest, opts ...grpc.CallOption) (*BeginPauseResourcePoolAdmissionResponse, error)
	ResolvePauseResourcePoolAdmission(ctx context.Context, in *ResolvePauseResourcePoolAdmissionRequest, opts ...grpc.CallOption) (*ResolvePauseResourcePoolAdmissionResponse, error)
	ResumeResourcePool(ctx context.Context, in *ResumeResourcePoolRequest, opts ...grpc.CallOption) (*ResumeResourcePoolResponse, error)
	// Queries the Regional Pause/Resume operation for an asynchronous request.
	// The same operation_id is used by Global and Regional services.
	GetResourcePoolPauseResumeOperation(ctx context.Context, in *GetResourcePoolPauseResumeOperationRequest, opts ...grpc.CallOption) (*ResourcePoolPauseResumeOperation, error)
}

type resourcePoolServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewResourcePoolServiceClient(cc grpc.ClientConnInterface) ResourcePoolServiceClient {
	return &resourcePoolServiceClient{cc}
}

func (c *resourcePoolServiceClient) CreateResourcePool(ctx context.Context, in *CreateResourcePoolRequest, opts ...grpc.CallOption) (*ResourcePoolProfile, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ResourcePoolProfile)
	err := c.cc.Invoke(ctx, ResourcePoolService_CreateResourcePool_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *resourcePoolServiceClient) ListResourcePools(ctx context.Context, in *ListResourcePoolsRequest, opts ...grpc.CallOption) (*ListResourcePoolsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListResourcePoolsResponse)
	err := c.cc.Invoke(ctx, ResourcePoolService_ListResourcePools_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *resourcePoolServiceClient) UpdateResourcePoolName(ctx context.Context, in *UpdateResourcePoolNameRequest, opts ...grpc.CallOption) (*ResourcePool, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ResourcePool)
	err := c.cc.Invoke(ctx, ResourcePoolService_UpdateResourcePoolName_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *resourcePoolServiceClient) UpdateResourcePoolInstanceLimit(ctx context.Context, in *UpdateResourcePoolInstanceLimitRequest, opts ...grpc.CallOption) (*ResourcePool, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ResourcePool)
	err := c.cc.Invoke(ctx, ResourcePoolService_UpdateResourcePoolInstanceLimit_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *resourcePoolServiceClient) GetResourcePool(ctx context.Context, in *GetResourcePoolRequest, opts ...grpc.CallOption) (*ResourcePoolProfile, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ResourcePoolProfile)
	err := c.cc.Invoke(ctx, ResourcePoolService_GetResourcePool_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *resourcePoolServiceClient) DeleteResourcePool(ctx context.Context, in *DeleteResourcePoolRequest, opts ...grpc.CallOption) (*ResourcePool, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ResourcePool)
	err := c.cc.Invoke(ctx, ResourcePoolService_DeleteResourcePool_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *resourcePoolServiceClient) ListOwnerResourcePools(ctx context.Context, in *ListOwnerResourcePoolsRequest, opts ...grpc.CallOption) (*ListOwnerResourcePoolsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListOwnerResourcePoolsResponse)
	err := c.cc.Invoke(ctx, ResourcePoolService_ListOwnerResourcePools_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *resourcePoolServiceClient) UpdateOrgDefaultResourcePool(ctx context.Context, in *UpdateOrgDefaultResourcePoolRequest, opts ...grpc.CallOption) (*ResourcePoolStrategy, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ResourcePoolStrategy)
	err := c.cc.Invoke(ctx, ResourcePoolService_UpdateOrgDefaultResourcePool_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *resourcePoolServiceClient) GetResourcePoolCapacityConstraints(ctx context.Context, in *GetResourcePoolCapacityConstraintsRequest, opts ...grpc.CallOption) (*ResourcePoolCapacityConstraints, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ResourcePoolCapacityConstraints)
	err := c.cc.Invoke(ctx, ResourcePoolService_GetResourcePoolCapacityConstraints_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *resourcePoolServiceClient) ResizeResourcePoolCapacity(ctx context.Context, in *ResizeResourcePoolCapacityRequest, opts ...grpc.CallOption) (*ResizeResourcePoolCapacityResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ResizeResourcePoolCapacityResponse)
	err := c.cc.Invoke(ctx, ResourcePoolService_ResizeResourcePoolCapacity_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *resourcePoolServiceClient) UpsertResourcePoolCloudResourceTags(ctx context.Context, in *UpsertResourcePoolCloudResourceTagsRequest, opts ...grpc.CallOption) (*UpsertResourcePoolCloudResourceTagsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(UpsertResourcePoolCloudResourceTagsResponse)
	err := c.cc.Invoke(ctx, ResourcePoolService_UpsertResourcePoolCloudResourceTags_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *resourcePoolServiceClient) PauseResourcePool(ctx context.Context, in *PauseResourcePoolRequest, opts ...grpc.CallOption) (*PauseResourcePoolResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(PauseResourcePoolResponse)
	err := c.cc.Invoke(ctx, ResourcePoolService_PauseResourcePool_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *resourcePoolServiceClient) BeginPauseResourcePoolAdmission(ctx context.Context, in *BeginPauseResourcePoolAdmissionRequest, opts ...grpc.CallOption) (*BeginPauseResourcePoolAdmissionResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(BeginPauseResourcePoolAdmissionResponse)
	err := c.cc.Invoke(ctx, ResourcePoolService_BeginPauseResourcePoolAdmission_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *resourcePoolServiceClient) ResolvePauseResourcePoolAdmission(ctx context.Context, in *ResolvePauseResourcePoolAdmissionRequest, opts ...grpc.CallOption) (*ResolvePauseResourcePoolAdmissionResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ResolvePauseResourcePoolAdmissionResponse)
	err := c.cc.Invoke(ctx, ResourcePoolService_ResolvePauseResourcePoolAdmission_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *resourcePoolServiceClient) ResumeResourcePool(ctx context.Context, in *ResumeResourcePoolRequest, opts ...grpc.CallOption) (*ResumeResourcePoolResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ResumeResourcePoolResponse)
	err := c.cc.Invoke(ctx, ResourcePoolService_ResumeResourcePool_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *resourcePoolServiceClient) GetResourcePoolPauseResumeOperation(ctx context.Context, in *GetResourcePoolPauseResumeOperationRequest, opts ...grpc.CallOption) (*ResourcePoolPauseResumeOperation, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ResourcePoolPauseResumeOperation)
	err := c.cc.Invoke(ctx, ResourcePoolService_GetResourcePoolPauseResumeOperation_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ResourcePoolServiceServer is the server API for ResourcePoolService service.
// All implementations should embed UnimplementedResourcePoolServiceServer
// for forward compatibility
type ResourcePoolServiceServer interface {
	CreateResourcePool(context.Context, *CreateResourcePoolRequest) (*ResourcePoolProfile, error)
	ListResourcePools(context.Context, *ListResourcePoolsRequest) (*ListResourcePoolsResponse, error)
	UpdateResourcePoolName(context.Context, *UpdateResourcePoolNameRequest) (*ResourcePool, error)
	UpdateResourcePoolInstanceLimit(context.Context, *UpdateResourcePoolInstanceLimitRequest) (*ResourcePool, error)
	GetResourcePool(context.Context, *GetResourcePoolRequest) (*ResourcePoolProfile, error)
	DeleteResourcePool(context.Context, *DeleteResourcePoolRequest) (*ResourcePool, error)
	ListOwnerResourcePools(context.Context, *ListOwnerResourcePoolsRequest) (*ListOwnerResourcePoolsResponse, error)
	UpdateOrgDefaultResourcePool(context.Context, *UpdateOrgDefaultResourcePoolRequest) (*ResourcePoolStrategy, error)
	GetResourcePoolCapacityConstraints(context.Context, *GetResourcePoolCapacityConstraintsRequest) (*ResourcePoolCapacityConstraints, error)
	ResizeResourcePoolCapacity(context.Context, *ResizeResourcePoolCapacityRequest) (*ResizeResourcePoolCapacityResponse, error)
	UpsertResourcePoolCloudResourceTags(context.Context, *UpsertResourcePoolCloudResourceTagsRequest) (*UpsertResourcePoolCloudResourceTagsResponse, error)
	// Resource Pool lifecycle control APIs are internal-only. They validate,
	// start, and monitor asynchronous Pause/Resume workflows. Once a workflow
	// is accepted, it cannot be canceled through the current contract; canceling
	// a caller-side DevOps operation does not cancel the Global or Regional
	// operation.
	PauseResourcePool(context.Context, *PauseResourcePoolRequest) (*PauseResourcePoolResponse, error)
	BeginPauseResourcePoolAdmission(context.Context, *BeginPauseResourcePoolAdmissionRequest) (*BeginPauseResourcePoolAdmissionResponse, error)
	ResolvePauseResourcePoolAdmission(context.Context, *ResolvePauseResourcePoolAdmissionRequest) (*ResolvePauseResourcePoolAdmissionResponse, error)
	ResumeResourcePool(context.Context, *ResumeResourcePoolRequest) (*ResumeResourcePoolResponse, error)
	// Queries the Regional Pause/Resume operation for an asynchronous request.
	// The same operation_id is used by Global and Regional services.
	GetResourcePoolPauseResumeOperation(context.Context, *GetResourcePoolPauseResumeOperationRequest) (*ResourcePoolPauseResumeOperation, error)
}

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

func (UnimplementedResourcePoolServiceServer) CreateResourcePool(context.Context, *CreateResourcePoolRequest) (*ResourcePoolProfile, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateResourcePool not implemented")
}
func (UnimplementedResourcePoolServiceServer) ListResourcePools(context.Context, *ListResourcePoolsRequest) (*ListResourcePoolsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListResourcePools not implemented")
}
func (UnimplementedResourcePoolServiceServer) UpdateResourcePoolName(context.Context, *UpdateResourcePoolNameRequest) (*ResourcePool, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateResourcePoolName not implemented")
}
func (UnimplementedResourcePoolServiceServer) UpdateResourcePoolInstanceLimit(context.Context, *UpdateResourcePoolInstanceLimitRequest) (*ResourcePool, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateResourcePoolInstanceLimit not implemented")
}
func (UnimplementedResourcePoolServiceServer) GetResourcePool(context.Context, *GetResourcePoolRequest) (*ResourcePoolProfile, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetResourcePool not implemented")
}
func (UnimplementedResourcePoolServiceServer) DeleteResourcePool(context.Context, *DeleteResourcePoolRequest) (*ResourcePool, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteResourcePool not implemented")
}
func (UnimplementedResourcePoolServiceServer) ListOwnerResourcePools(context.Context, *ListOwnerResourcePoolsRequest) (*ListOwnerResourcePoolsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListOwnerResourcePools not implemented")
}
func (UnimplementedResourcePoolServiceServer) UpdateOrgDefaultResourcePool(context.Context, *UpdateOrgDefaultResourcePoolRequest) (*ResourcePoolStrategy, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateOrgDefaultResourcePool not implemented")
}
func (UnimplementedResourcePoolServiceServer) GetResourcePoolCapacityConstraints(context.Context, *GetResourcePoolCapacityConstraintsRequest) (*ResourcePoolCapacityConstraints, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetResourcePoolCapacityConstraints not implemented")
}
func (UnimplementedResourcePoolServiceServer) ResizeResourcePoolCapacity(context.Context, *ResizeResourcePoolCapacityRequest) (*ResizeResourcePoolCapacityResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ResizeResourcePoolCapacity not implemented")
}
func (UnimplementedResourcePoolServiceServer) UpsertResourcePoolCloudResourceTags(context.Context, *UpsertResourcePoolCloudResourceTagsRequest) (*UpsertResourcePoolCloudResourceTagsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpsertResourcePoolCloudResourceTags not implemented")
}
func (UnimplementedResourcePoolServiceServer) PauseResourcePool(context.Context, *PauseResourcePoolRequest) (*PauseResourcePoolResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PauseResourcePool not implemented")
}
func (UnimplementedResourcePoolServiceServer) BeginPauseResourcePoolAdmission(context.Context, *BeginPauseResourcePoolAdmissionRequest) (*BeginPauseResourcePoolAdmissionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BeginPauseResourcePoolAdmission not implemented")
}
func (UnimplementedResourcePoolServiceServer) ResolvePauseResourcePoolAdmission(context.Context, *ResolvePauseResourcePoolAdmissionRequest) (*ResolvePauseResourcePoolAdmissionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ResolvePauseResourcePoolAdmission not implemented")
}
func (UnimplementedResourcePoolServiceServer) ResumeResourcePool(context.Context, *ResumeResourcePoolRequest) (*ResumeResourcePoolResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ResumeResourcePool not implemented")
}
func (UnimplementedResourcePoolServiceServer) GetResourcePoolPauseResumeOperation(context.Context, *GetResourcePoolPauseResumeOperationRequest) (*ResourcePoolPauseResumeOperation, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetResourcePoolPauseResumeOperation not implemented")
}

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

func RegisterResourcePoolServiceServer(s grpc.ServiceRegistrar, srv ResourcePoolServiceServer) {
	s.RegisterService(&ResourcePoolService_ServiceDesc, srv)
}

func _ResourcePoolService_CreateResourcePool_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateResourcePoolRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ResourcePoolServiceServer).CreateResourcePool(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ResourcePoolService_CreateResourcePool_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ResourcePoolServiceServer).CreateResourcePool(ctx, req.(*CreateResourcePoolRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ResourcePoolService_ListResourcePools_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListResourcePoolsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ResourcePoolServiceServer).ListResourcePools(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ResourcePoolService_ListResourcePools_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ResourcePoolServiceServer).ListResourcePools(ctx, req.(*ListResourcePoolsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ResourcePoolService_UpdateResourcePoolName_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateResourcePoolNameRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ResourcePoolServiceServer).UpdateResourcePoolName(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ResourcePoolService_UpdateResourcePoolName_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ResourcePoolServiceServer).UpdateResourcePoolName(ctx, req.(*UpdateResourcePoolNameRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ResourcePoolService_UpdateResourcePoolInstanceLimit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateResourcePoolInstanceLimitRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ResourcePoolServiceServer).UpdateResourcePoolInstanceLimit(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ResourcePoolService_UpdateResourcePoolInstanceLimit_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ResourcePoolServiceServer).UpdateResourcePoolInstanceLimit(ctx, req.(*UpdateResourcePoolInstanceLimitRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ResourcePoolService_GetResourcePool_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetResourcePoolRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ResourcePoolServiceServer).GetResourcePool(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ResourcePoolService_GetResourcePool_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ResourcePoolServiceServer).GetResourcePool(ctx, req.(*GetResourcePoolRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ResourcePoolService_DeleteResourcePool_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteResourcePoolRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ResourcePoolServiceServer).DeleteResourcePool(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ResourcePoolService_DeleteResourcePool_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ResourcePoolServiceServer).DeleteResourcePool(ctx, req.(*DeleteResourcePoolRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ResourcePoolService_ListOwnerResourcePools_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListOwnerResourcePoolsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ResourcePoolServiceServer).ListOwnerResourcePools(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ResourcePoolService_ListOwnerResourcePools_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ResourcePoolServiceServer).ListOwnerResourcePools(ctx, req.(*ListOwnerResourcePoolsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ResourcePoolService_UpdateOrgDefaultResourcePool_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateOrgDefaultResourcePoolRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ResourcePoolServiceServer).UpdateOrgDefaultResourcePool(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ResourcePoolService_UpdateOrgDefaultResourcePool_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ResourcePoolServiceServer).UpdateOrgDefaultResourcePool(ctx, req.(*UpdateOrgDefaultResourcePoolRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ResourcePoolService_GetResourcePoolCapacityConstraints_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetResourcePoolCapacityConstraintsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ResourcePoolServiceServer).GetResourcePoolCapacityConstraints(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ResourcePoolService_GetResourcePoolCapacityConstraints_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ResourcePoolServiceServer).GetResourcePoolCapacityConstraints(ctx, req.(*GetResourcePoolCapacityConstraintsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ResourcePoolService_ResizeResourcePoolCapacity_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ResizeResourcePoolCapacityRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ResourcePoolServiceServer).ResizeResourcePoolCapacity(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ResourcePoolService_ResizeResourcePoolCapacity_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ResourcePoolServiceServer).ResizeResourcePoolCapacity(ctx, req.(*ResizeResourcePoolCapacityRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ResourcePoolService_UpsertResourcePoolCloudResourceTags_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpsertResourcePoolCloudResourceTagsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ResourcePoolServiceServer).UpsertResourcePoolCloudResourceTags(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ResourcePoolService_UpsertResourcePoolCloudResourceTags_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ResourcePoolServiceServer).UpsertResourcePoolCloudResourceTags(ctx, req.(*UpsertResourcePoolCloudResourceTagsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ResourcePoolService_PauseResourcePool_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PauseResourcePoolRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ResourcePoolServiceServer).PauseResourcePool(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ResourcePoolService_PauseResourcePool_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ResourcePoolServiceServer).PauseResourcePool(ctx, req.(*PauseResourcePoolRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ResourcePoolService_BeginPauseResourcePoolAdmission_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BeginPauseResourcePoolAdmissionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ResourcePoolServiceServer).BeginPauseResourcePoolAdmission(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ResourcePoolService_BeginPauseResourcePoolAdmission_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ResourcePoolServiceServer).BeginPauseResourcePoolAdmission(ctx, req.(*BeginPauseResourcePoolAdmissionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ResourcePoolService_ResolvePauseResourcePoolAdmission_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ResolvePauseResourcePoolAdmissionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ResourcePoolServiceServer).ResolvePauseResourcePoolAdmission(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ResourcePoolService_ResolvePauseResourcePoolAdmission_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ResourcePoolServiceServer).ResolvePauseResourcePoolAdmission(ctx, req.(*ResolvePauseResourcePoolAdmissionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ResourcePoolService_ResumeResourcePool_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ResumeResourcePoolRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ResourcePoolServiceServer).ResumeResourcePool(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ResourcePoolService_ResumeResourcePool_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ResourcePoolServiceServer).ResumeResourcePool(ctx, req.(*ResumeResourcePoolRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ResourcePoolService_GetResourcePoolPauseResumeOperation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetResourcePoolPauseResumeOperationRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ResourcePoolServiceServer).GetResourcePoolPauseResumeOperation(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ResourcePoolService_GetResourcePoolPauseResumeOperation_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ResourcePoolServiceServer).GetResourcePoolPauseResumeOperation(ctx, req.(*GetResourcePoolPauseResumeOperationRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// ResourcePoolService_ServiceDesc is the grpc.ServiceDesc for ResourcePoolService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var ResourcePoolService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "global.nextgen.v1.ResourcePoolService",
	HandlerType: (*ResourcePoolServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateResourcePool",
			Handler:    _ResourcePoolService_CreateResourcePool_Handler,
		},
		{
			MethodName: "ListResourcePools",
			Handler:    _ResourcePoolService_ListResourcePools_Handler,
		},
		{
			MethodName: "UpdateResourcePoolName",
			Handler:    _ResourcePoolService_UpdateResourcePoolName_Handler,
		},
		{
			MethodName: "UpdateResourcePoolInstanceLimit",
			Handler:    _ResourcePoolService_UpdateResourcePoolInstanceLimit_Handler,
		},
		{
			MethodName: "GetResourcePool",
			Handler:    _ResourcePoolService_GetResourcePool_Handler,
		},
		{
			MethodName: "DeleteResourcePool",
			Handler:    _ResourcePoolService_DeleteResourcePool_Handler,
		},
		{
			MethodName: "ListOwnerResourcePools",
			Handler:    _ResourcePoolService_ListOwnerResourcePools_Handler,
		},
		{
			MethodName: "UpdateOrgDefaultResourcePool",
			Handler:    _ResourcePoolService_UpdateOrgDefaultResourcePool_Handler,
		},
		{
			MethodName: "GetResourcePoolCapacityConstraints",
			Handler:    _ResourcePoolService_GetResourcePoolCapacityConstraints_Handler,
		},
		{
			MethodName: "ResizeResourcePoolCapacity",
			Handler:    _ResourcePoolService_ResizeResourcePoolCapacity_Handler,
		},
		{
			MethodName: "UpsertResourcePoolCloudResourceTags",
			Handler:    _ResourcePoolService_UpsertResourcePoolCloudResourceTags_Handler,
		},
		{
			MethodName: "PauseResourcePool",
			Handler:    _ResourcePoolService_PauseResourcePool_Handler,
		},
		{
			MethodName: "BeginPauseResourcePoolAdmission",
			Handler:    _ResourcePoolService_BeginPauseResourcePoolAdmission_Handler,
		},
		{
			MethodName: "ResolvePauseResourcePoolAdmission",
			Handler:    _ResourcePoolService_ResolvePauseResourcePoolAdmission_Handler,
		},
		{
			MethodName: "ResumeResourcePool",
			Handler:    _ResourcePoolService_ResumeResourcePool_Handler,
		},
		{
			MethodName: "GetResourcePoolPauseResumeOperation",
			Handler:    _ResourcePoolService_GetResourcePoolPauseResumeOperation_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "global/nextgen/v1/resource_pool.proto",
}