// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.6.1
// - protoc             v6.31.1
// source: service/manager_api/grpc/manager/manager.proto

package manager

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.64.0 or later.
const _ = grpc.SupportPackageIsVersion9

const (
	Manager_CreateSquad_FullMethodName                = "/manager_api.v1.Manager/CreateSquad"
	Manager_GetSquads_FullMethodName                  = "/manager_api.v1.Manager/GetSquads"
	Manager_GetSquadsCount_FullMethodName             = "/manager_api.v1.Manager/GetSquadsCount"
	Manager_GetSquad_FullMethodName                   = "/manager_api.v1.Manager/GetSquad"
	Manager_UpdateSquad_FullMethodName                = "/manager_api.v1.Manager/UpdateSquad"
	Manager_DeleteSquad_FullMethodName                = "/manager_api.v1.Manager/DeleteSquad"
	Manager_CreateNode_FullMethodName                 = "/manager_api.v1.Manager/CreateNode"
	Manager_GetNodes_FullMethodName                   = "/manager_api.v1.Manager/GetNodes"
	Manager_GetNodesCount_FullMethodName              = "/manager_api.v1.Manager/GetNodesCount"
	Manager_GetNode_FullMethodName                    = "/manager_api.v1.Manager/GetNode"
	Manager_GetNodeStatus_FullMethodName              = "/manager_api.v1.Manager/GetNodeStatus"
	Manager_UpdateNode_FullMethodName                 = "/manager_api.v1.Manager/UpdateNode"
	Manager_DeleteNode_FullMethodName                 = "/manager_api.v1.Manager/DeleteNode"
	Manager_CreateUser_FullMethodName                 = "/manager_api.v1.Manager/CreateUser"
	Manager_GetUsers_FullMethodName                   = "/manager_api.v1.Manager/GetUsers"
	Manager_GetUsersCount_FullMethodName              = "/manager_api.v1.Manager/GetUsersCount"
	Manager_GetUser_FullMethodName                    = "/manager_api.v1.Manager/GetUser"
	Manager_UpdateUser_FullMethodName                 = "/manager_api.v1.Manager/UpdateUser"
	Manager_DeleteUser_FullMethodName                 = "/manager_api.v1.Manager/DeleteUser"
	Manager_CreateBandwidthLimiter_FullMethodName     = "/manager_api.v1.Manager/CreateBandwidthLimiter"
	Manager_GetBandwidthLimiters_FullMethodName       = "/manager_api.v1.Manager/GetBandwidthLimiters"
	Manager_GetBandwidthLimitersCount_FullMethodName  = "/manager_api.v1.Manager/GetBandwidthLimitersCount"
	Manager_GetBandwidthLimiter_FullMethodName        = "/manager_api.v1.Manager/GetBandwidthLimiter"
	Manager_UpdateBandwidthLimiter_FullMethodName     = "/manager_api.v1.Manager/UpdateBandwidthLimiter"
	Manager_DeleteBandwidthLimiter_FullMethodName     = "/manager_api.v1.Manager/DeleteBandwidthLimiter"
	Manager_CreateTrafficLimiter_FullMethodName       = "/manager_api.v1.Manager/CreateTrafficLimiter"
	Manager_GetTrafficLimiters_FullMethodName         = "/manager_api.v1.Manager/GetTrafficLimiters"
	Manager_GetTrafficLimitersCount_FullMethodName    = "/manager_api.v1.Manager/GetTrafficLimitersCount"
	Manager_GetTrafficLimiter_FullMethodName          = "/manager_api.v1.Manager/GetTrafficLimiter"
	Manager_UpdateTrafficLimiter_FullMethodName       = "/manager_api.v1.Manager/UpdateTrafficLimiter"
	Manager_DeleteTrafficLimiter_FullMethodName       = "/manager_api.v1.Manager/DeleteTrafficLimiter"
	Manager_CreateConnectionLimiter_FullMethodName    = "/manager_api.v1.Manager/CreateConnectionLimiter"
	Manager_GetConnectionLimiters_FullMethodName      = "/manager_api.v1.Manager/GetConnectionLimiters"
	Manager_GetConnectionLimitersCount_FullMethodName = "/manager_api.v1.Manager/GetConnectionLimitersCount"
	Manager_GetConnectionLimiter_FullMethodName       = "/manager_api.v1.Manager/GetConnectionLimiter"
	Manager_UpdateConnectionLimiter_FullMethodName    = "/manager_api.v1.Manager/UpdateConnectionLimiter"
	Manager_DeleteConnectionLimiter_FullMethodName    = "/manager_api.v1.Manager/DeleteConnectionLimiter"
	Manager_CreateRateLimiter_FullMethodName          = "/manager_api.v1.Manager/CreateRateLimiter"
	Manager_GetRateLimiters_FullMethodName            = "/manager_api.v1.Manager/GetRateLimiters"
	Manager_GetRateLimitersCount_FullMethodName       = "/manager_api.v1.Manager/GetRateLimitersCount"
	Manager_GetRateLimiter_FullMethodName             = "/manager_api.v1.Manager/GetRateLimiter"
	Manager_UpdateRateLimiter_FullMethodName          = "/manager_api.v1.Manager/UpdateRateLimiter"
	Manager_DeleteRateLimiter_FullMethodName          = "/manager_api.v1.Manager/DeleteRateLimiter"
)

// ManagerClient is the client API for Manager 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 ManagerClient interface {
	CreateSquad(ctx context.Context, in *SquadCreate, opts ...grpc.CallOption) (*Squad, error)
	GetSquads(ctx context.Context, in *Filters, opts ...grpc.CallOption) (*SquadList, error)
	GetSquadsCount(ctx context.Context, in *Filters, opts ...grpc.CallOption) (*CountReply, error)
	GetSquad(ctx context.Context, in *IdRequest, opts ...grpc.CallOption) (*Squad, error)
	UpdateSquad(ctx context.Context, in *SquadUpdateRequest, opts ...grpc.CallOption) (*Squad, error)
	DeleteSquad(ctx context.Context, in *IdRequest, opts ...grpc.CallOption) (*Squad, error)
	CreateNode(ctx context.Context, in *NodeCreate, opts ...grpc.CallOption) (*Node, error)
	GetNodes(ctx context.Context, in *Filters, opts ...grpc.CallOption) (*NodeList, error)
	GetNodesCount(ctx context.Context, in *Filters, opts ...grpc.CallOption) (*CountReply, error)
	GetNode(ctx context.Context, in *UuidRequest, opts ...grpc.CallOption) (*Node, error)
	GetNodeStatus(ctx context.Context, in *UuidRequest, opts ...grpc.CallOption) (*NodeStatusReply, error)
	UpdateNode(ctx context.Context, in *NodeUpdateRequest, opts ...grpc.CallOption) (*Node, error)
	DeleteNode(ctx context.Context, in *UuidRequest, opts ...grpc.CallOption) (*Node, error)
	CreateUser(ctx context.Context, in *UserCreate, opts ...grpc.CallOption) (*User, error)
	GetUsers(ctx context.Context, in *Filters, opts ...grpc.CallOption) (*UserList, error)
	GetUsersCount(ctx context.Context, in *Filters, opts ...grpc.CallOption) (*CountReply, error)
	GetUser(ctx context.Context, in *IdRequest, opts ...grpc.CallOption) (*User, error)
	UpdateUser(ctx context.Context, in *UserUpdateRequest, opts ...grpc.CallOption) (*User, error)
	DeleteUser(ctx context.Context, in *IdRequest, opts ...grpc.CallOption) (*User, error)
	CreateBandwidthLimiter(ctx context.Context, in *BandwidthLimiterCreate, opts ...grpc.CallOption) (*BandwidthLimiter, error)
	GetBandwidthLimiters(ctx context.Context, in *Filters, opts ...grpc.CallOption) (*BandwidthLimiterList, error)
	GetBandwidthLimitersCount(ctx context.Context, in *Filters, opts ...grpc.CallOption) (*CountReply, error)
	GetBandwidthLimiter(ctx context.Context, in *IdRequest, opts ...grpc.CallOption) (*BandwidthLimiter, error)
	UpdateBandwidthLimiter(ctx context.Context, in *BandwidthLimiterUpdateRequest, opts ...grpc.CallOption) (*BandwidthLimiter, error)
	DeleteBandwidthLimiter(ctx context.Context, in *IdRequest, opts ...grpc.CallOption) (*BandwidthLimiter, error)
	CreateTrafficLimiter(ctx context.Context, in *TrafficLimiterCreate, opts ...grpc.CallOption) (*TrafficLimiter, error)
	GetTrafficLimiters(ctx context.Context, in *Filters, opts ...grpc.CallOption) (*TrafficLimiterList, error)
	GetTrafficLimitersCount(ctx context.Context, in *Filters, opts ...grpc.CallOption) (*CountReply, error)
	GetTrafficLimiter(ctx context.Context, in *IdRequest, opts ...grpc.CallOption) (*TrafficLimiter, error)
	UpdateTrafficLimiter(ctx context.Context, in *TrafficLimiterUpdateRequest, opts ...grpc.CallOption) (*TrafficLimiter, error)
	DeleteTrafficLimiter(ctx context.Context, in *IdRequest, opts ...grpc.CallOption) (*TrafficLimiter, error)
	CreateConnectionLimiter(ctx context.Context, in *ConnectionLimiterCreate, opts ...grpc.CallOption) (*ConnectionLimiter, error)
	GetConnectionLimiters(ctx context.Context, in *Filters, opts ...grpc.CallOption) (*ConnectionLimiterList, error)
	GetConnectionLimitersCount(ctx context.Context, in *Filters, opts ...grpc.CallOption) (*CountReply, error)
	GetConnectionLimiter(ctx context.Context, in *IdRequest, opts ...grpc.CallOption) (*ConnectionLimiter, error)
	UpdateConnectionLimiter(ctx context.Context, in *ConnectionLimiterUpdateRequest, opts ...grpc.CallOption) (*ConnectionLimiter, error)
	DeleteConnectionLimiter(ctx context.Context, in *IdRequest, opts ...grpc.CallOption) (*ConnectionLimiter, error)
	CreateRateLimiter(ctx context.Context, in *RateLimiterCreate, opts ...grpc.CallOption) (*RateLimiter, error)
	GetRateLimiters(ctx context.Context, in *Filters, opts ...grpc.CallOption) (*RateLimiterList, error)
	GetRateLimitersCount(ctx context.Context, in *Filters, opts ...grpc.CallOption) (*CountReply, error)
	GetRateLimiter(ctx context.Context, in *IdRequest, opts ...grpc.CallOption) (*RateLimiter, error)
	UpdateRateLimiter(ctx context.Context, in *RateLimiterUpdateRequest, opts ...grpc.CallOption) (*RateLimiter, error)
	DeleteRateLimiter(ctx context.Context, in *IdRequest, opts ...grpc.CallOption) (*RateLimiter, error)
}

type managerClient struct {
	cc grpc.ClientConnInterface
}

func NewManagerClient(cc grpc.ClientConnInterface) ManagerClient {
	return &managerClient{cc}
}

func (c *managerClient) CreateSquad(ctx context.Context, in *SquadCreate, opts ...grpc.CallOption) (*Squad, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Squad)
	err := c.cc.Invoke(ctx, Manager_CreateSquad_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managerClient) GetSquads(ctx context.Context, in *Filters, opts ...grpc.CallOption) (*SquadList, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(SquadList)
	err := c.cc.Invoke(ctx, Manager_GetSquads_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managerClient) GetSquadsCount(ctx context.Context, in *Filters, opts ...grpc.CallOption) (*CountReply, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CountReply)
	err := c.cc.Invoke(ctx, Manager_GetSquadsCount_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managerClient) GetSquad(ctx context.Context, in *IdRequest, opts ...grpc.CallOption) (*Squad, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Squad)
	err := c.cc.Invoke(ctx, Manager_GetSquad_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managerClient) UpdateSquad(ctx context.Context, in *SquadUpdateRequest, opts ...grpc.CallOption) (*Squad, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Squad)
	err := c.cc.Invoke(ctx, Manager_UpdateSquad_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managerClient) DeleteSquad(ctx context.Context, in *IdRequest, opts ...grpc.CallOption) (*Squad, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Squad)
	err := c.cc.Invoke(ctx, Manager_DeleteSquad_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managerClient) CreateNode(ctx context.Context, in *NodeCreate, opts ...grpc.CallOption) (*Node, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Node)
	err := c.cc.Invoke(ctx, Manager_CreateNode_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managerClient) GetNodes(ctx context.Context, in *Filters, opts ...grpc.CallOption) (*NodeList, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(NodeList)
	err := c.cc.Invoke(ctx, Manager_GetNodes_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managerClient) GetNodesCount(ctx context.Context, in *Filters, opts ...grpc.CallOption) (*CountReply, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CountReply)
	err := c.cc.Invoke(ctx, Manager_GetNodesCount_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managerClient) GetNode(ctx context.Context, in *UuidRequest, opts ...grpc.CallOption) (*Node, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Node)
	err := c.cc.Invoke(ctx, Manager_GetNode_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managerClient) GetNodeStatus(ctx context.Context, in *UuidRequest, opts ...grpc.CallOption) (*NodeStatusReply, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(NodeStatusReply)
	err := c.cc.Invoke(ctx, Manager_GetNodeStatus_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managerClient) UpdateNode(ctx context.Context, in *NodeUpdateRequest, opts ...grpc.CallOption) (*Node, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Node)
	err := c.cc.Invoke(ctx, Manager_UpdateNode_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managerClient) DeleteNode(ctx context.Context, in *UuidRequest, opts ...grpc.CallOption) (*Node, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Node)
	err := c.cc.Invoke(ctx, Manager_DeleteNode_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managerClient) CreateUser(ctx context.Context, in *UserCreate, opts ...grpc.CallOption) (*User, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(User)
	err := c.cc.Invoke(ctx, Manager_CreateUser_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managerClient) GetUsers(ctx context.Context, in *Filters, opts ...grpc.CallOption) (*UserList, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(UserList)
	err := c.cc.Invoke(ctx, Manager_GetUsers_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managerClient) GetUsersCount(ctx context.Context, in *Filters, opts ...grpc.CallOption) (*CountReply, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CountReply)
	err := c.cc.Invoke(ctx, Manager_GetUsersCount_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managerClient) GetUser(ctx context.Context, in *IdRequest, opts ...grpc.CallOption) (*User, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(User)
	err := c.cc.Invoke(ctx, Manager_GetUser_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managerClient) UpdateUser(ctx context.Context, in *UserUpdateRequest, opts ...grpc.CallOption) (*User, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(User)
	err := c.cc.Invoke(ctx, Manager_UpdateUser_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managerClient) DeleteUser(ctx context.Context, in *IdRequest, opts ...grpc.CallOption) (*User, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(User)
	err := c.cc.Invoke(ctx, Manager_DeleteUser_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managerClient) CreateBandwidthLimiter(ctx context.Context, in *BandwidthLimiterCreate, opts ...grpc.CallOption) (*BandwidthLimiter, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(BandwidthLimiter)
	err := c.cc.Invoke(ctx, Manager_CreateBandwidthLimiter_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managerClient) GetBandwidthLimiters(ctx context.Context, in *Filters, opts ...grpc.CallOption) (*BandwidthLimiterList, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(BandwidthLimiterList)
	err := c.cc.Invoke(ctx, Manager_GetBandwidthLimiters_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managerClient) GetBandwidthLimitersCount(ctx context.Context, in *Filters, opts ...grpc.CallOption) (*CountReply, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CountReply)
	err := c.cc.Invoke(ctx, Manager_GetBandwidthLimitersCount_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managerClient) GetBandwidthLimiter(ctx context.Context, in *IdRequest, opts ...grpc.CallOption) (*BandwidthLimiter, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(BandwidthLimiter)
	err := c.cc.Invoke(ctx, Manager_GetBandwidthLimiter_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managerClient) UpdateBandwidthLimiter(ctx context.Context, in *BandwidthLimiterUpdateRequest, opts ...grpc.CallOption) (*BandwidthLimiter, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(BandwidthLimiter)
	err := c.cc.Invoke(ctx, Manager_UpdateBandwidthLimiter_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managerClient) DeleteBandwidthLimiter(ctx context.Context, in *IdRequest, opts ...grpc.CallOption) (*BandwidthLimiter, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(BandwidthLimiter)
	err := c.cc.Invoke(ctx, Manager_DeleteBandwidthLimiter_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managerClient) CreateTrafficLimiter(ctx context.Context, in *TrafficLimiterCreate, opts ...grpc.CallOption) (*TrafficLimiter, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(TrafficLimiter)
	err := c.cc.Invoke(ctx, Manager_CreateTrafficLimiter_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managerClient) GetTrafficLimiters(ctx context.Context, in *Filters, opts ...grpc.CallOption) (*TrafficLimiterList, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(TrafficLimiterList)
	err := c.cc.Invoke(ctx, Manager_GetTrafficLimiters_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managerClient) GetTrafficLimitersCount(ctx context.Context, in *Filters, opts ...grpc.CallOption) (*CountReply, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CountReply)
	err := c.cc.Invoke(ctx, Manager_GetTrafficLimitersCount_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managerClient) GetTrafficLimiter(ctx context.Context, in *IdRequest, opts ...grpc.CallOption) (*TrafficLimiter, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(TrafficLimiter)
	err := c.cc.Invoke(ctx, Manager_GetTrafficLimiter_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managerClient) UpdateTrafficLimiter(ctx context.Context, in *TrafficLimiterUpdateRequest, opts ...grpc.CallOption) (*TrafficLimiter, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(TrafficLimiter)
	err := c.cc.Invoke(ctx, Manager_UpdateTrafficLimiter_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managerClient) DeleteTrafficLimiter(ctx context.Context, in *IdRequest, opts ...grpc.CallOption) (*TrafficLimiter, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(TrafficLimiter)
	err := c.cc.Invoke(ctx, Manager_DeleteTrafficLimiter_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managerClient) CreateConnectionLimiter(ctx context.Context, in *ConnectionLimiterCreate, opts ...grpc.CallOption) (*ConnectionLimiter, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ConnectionLimiter)
	err := c.cc.Invoke(ctx, Manager_CreateConnectionLimiter_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managerClient) GetConnectionLimiters(ctx context.Context, in *Filters, opts ...grpc.CallOption) (*ConnectionLimiterList, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ConnectionLimiterList)
	err := c.cc.Invoke(ctx, Manager_GetConnectionLimiters_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managerClient) GetConnectionLimitersCount(ctx context.Context, in *Filters, opts ...grpc.CallOption) (*CountReply, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CountReply)
	err := c.cc.Invoke(ctx, Manager_GetConnectionLimitersCount_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managerClient) GetConnectionLimiter(ctx context.Context, in *IdRequest, opts ...grpc.CallOption) (*ConnectionLimiter, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ConnectionLimiter)
	err := c.cc.Invoke(ctx, Manager_GetConnectionLimiter_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managerClient) UpdateConnectionLimiter(ctx context.Context, in *ConnectionLimiterUpdateRequest, opts ...grpc.CallOption) (*ConnectionLimiter, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ConnectionLimiter)
	err := c.cc.Invoke(ctx, Manager_UpdateConnectionLimiter_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managerClient) DeleteConnectionLimiter(ctx context.Context, in *IdRequest, opts ...grpc.CallOption) (*ConnectionLimiter, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ConnectionLimiter)
	err := c.cc.Invoke(ctx, Manager_DeleteConnectionLimiter_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managerClient) CreateRateLimiter(ctx context.Context, in *RateLimiterCreate, opts ...grpc.CallOption) (*RateLimiter, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(RateLimiter)
	err := c.cc.Invoke(ctx, Manager_CreateRateLimiter_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managerClient) GetRateLimiters(ctx context.Context, in *Filters, opts ...grpc.CallOption) (*RateLimiterList, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(RateLimiterList)
	err := c.cc.Invoke(ctx, Manager_GetRateLimiters_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managerClient) GetRateLimitersCount(ctx context.Context, in *Filters, opts ...grpc.CallOption) (*CountReply, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CountReply)
	err := c.cc.Invoke(ctx, Manager_GetRateLimitersCount_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managerClient) GetRateLimiter(ctx context.Context, in *IdRequest, opts ...grpc.CallOption) (*RateLimiter, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(RateLimiter)
	err := c.cc.Invoke(ctx, Manager_GetRateLimiter_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managerClient) UpdateRateLimiter(ctx context.Context, in *RateLimiterUpdateRequest, opts ...grpc.CallOption) (*RateLimiter, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(RateLimiter)
	err := c.cc.Invoke(ctx, Manager_UpdateRateLimiter_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managerClient) DeleteRateLimiter(ctx context.Context, in *IdRequest, opts ...grpc.CallOption) (*RateLimiter, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(RateLimiter)
	err := c.cc.Invoke(ctx, Manager_DeleteRateLimiter_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ManagerServer is the server API for Manager service.
// All implementations must embed UnimplementedManagerServer
// for forward compatibility.
type ManagerServer interface {
	CreateSquad(context.Context, *SquadCreate) (*Squad, error)
	GetSquads(context.Context, *Filters) (*SquadList, error)
	GetSquadsCount(context.Context, *Filters) (*CountReply, error)
	GetSquad(context.Context, *IdRequest) (*Squad, error)
	UpdateSquad(context.Context, *SquadUpdateRequest) (*Squad, error)
	DeleteSquad(context.Context, *IdRequest) (*Squad, error)
	CreateNode(context.Context, *NodeCreate) (*Node, error)
	GetNodes(context.Context, *Filters) (*NodeList, error)
	GetNodesCount(context.Context, *Filters) (*CountReply, error)
	GetNode(context.Context, *UuidRequest) (*Node, error)
	GetNodeStatus(context.Context, *UuidRequest) (*NodeStatusReply, error)
	UpdateNode(context.Context, *NodeUpdateRequest) (*Node, error)
	DeleteNode(context.Context, *UuidRequest) (*Node, error)
	CreateUser(context.Context, *UserCreate) (*User, error)
	GetUsers(context.Context, *Filters) (*UserList, error)
	GetUsersCount(context.Context, *Filters) (*CountReply, error)
	GetUser(context.Context, *IdRequest) (*User, error)
	UpdateUser(context.Context, *UserUpdateRequest) (*User, error)
	DeleteUser(context.Context, *IdRequest) (*User, error)
	CreateBandwidthLimiter(context.Context, *BandwidthLimiterCreate) (*BandwidthLimiter, error)
	GetBandwidthLimiters(context.Context, *Filters) (*BandwidthLimiterList, error)
	GetBandwidthLimitersCount(context.Context, *Filters) (*CountReply, error)
	GetBandwidthLimiter(context.Context, *IdRequest) (*BandwidthLimiter, error)
	UpdateBandwidthLimiter(context.Context, *BandwidthLimiterUpdateRequest) (*BandwidthLimiter, error)
	DeleteBandwidthLimiter(context.Context, *IdRequest) (*BandwidthLimiter, error)
	CreateTrafficLimiter(context.Context, *TrafficLimiterCreate) (*TrafficLimiter, error)
	GetTrafficLimiters(context.Context, *Filters) (*TrafficLimiterList, error)
	GetTrafficLimitersCount(context.Context, *Filters) (*CountReply, error)
	GetTrafficLimiter(context.Context, *IdRequest) (*TrafficLimiter, error)
	UpdateTrafficLimiter(context.Context, *TrafficLimiterUpdateRequest) (*TrafficLimiter, error)
	DeleteTrafficLimiter(context.Context, *IdRequest) (*TrafficLimiter, error)
	CreateConnectionLimiter(context.Context, *ConnectionLimiterCreate) (*ConnectionLimiter, error)
	GetConnectionLimiters(context.Context, *Filters) (*ConnectionLimiterList, error)
	GetConnectionLimitersCount(context.Context, *Filters) (*CountReply, error)
	GetConnectionLimiter(context.Context, *IdRequest) (*ConnectionLimiter, error)
	UpdateConnectionLimiter(context.Context, *ConnectionLimiterUpdateRequest) (*ConnectionLimiter, error)
	DeleteConnectionLimiter(context.Context, *IdRequest) (*ConnectionLimiter, error)
	CreateRateLimiter(context.Context, *RateLimiterCreate) (*RateLimiter, error)
	GetRateLimiters(context.Context, *Filters) (*RateLimiterList, error)
	GetRateLimitersCount(context.Context, *Filters) (*CountReply, error)
	GetRateLimiter(context.Context, *IdRequest) (*RateLimiter, error)
	UpdateRateLimiter(context.Context, *RateLimiterUpdateRequest) (*RateLimiter, error)
	DeleteRateLimiter(context.Context, *IdRequest) (*RateLimiter, error)
	mustEmbedUnimplementedManagerServer()
}

// UnimplementedManagerServer must be embedded to have
// forward compatible implementations.
//
// NOTE: this should be embedded by value instead of pointer to avoid a nil
// pointer dereference when methods are called.
type UnimplementedManagerServer struct{}

func (UnimplementedManagerServer) CreateSquad(context.Context, *SquadCreate) (*Squad, error) {
	return nil, status.Error(codes.Unimplemented, "method CreateSquad not implemented")
}
func (UnimplementedManagerServer) GetSquads(context.Context, *Filters) (*SquadList, error) {
	return nil, status.Error(codes.Unimplemented, "method GetSquads not implemented")
}
func (UnimplementedManagerServer) GetSquadsCount(context.Context, *Filters) (*CountReply, error) {
	return nil, status.Error(codes.Unimplemented, "method GetSquadsCount not implemented")
}
func (UnimplementedManagerServer) GetSquad(context.Context, *IdRequest) (*Squad, error) {
	return nil, status.Error(codes.Unimplemented, "method GetSquad not implemented")
}
func (UnimplementedManagerServer) UpdateSquad(context.Context, *SquadUpdateRequest) (*Squad, error) {
	return nil, status.Error(codes.Unimplemented, "method UpdateSquad not implemented")
}
func (UnimplementedManagerServer) DeleteSquad(context.Context, *IdRequest) (*Squad, error) {
	return nil, status.Error(codes.Unimplemented, "method DeleteSquad not implemented")
}
func (UnimplementedManagerServer) CreateNode(context.Context, *NodeCreate) (*Node, error) {
	return nil, status.Error(codes.Unimplemented, "method CreateNode not implemented")
}
func (UnimplementedManagerServer) GetNodes(context.Context, *Filters) (*NodeList, error) {
	return nil, status.Error(codes.Unimplemented, "method GetNodes not implemented")
}
func (UnimplementedManagerServer) GetNodesCount(context.Context, *Filters) (*CountReply, error) {
	return nil, status.Error(codes.Unimplemented, "method GetNodesCount not implemented")
}
func (UnimplementedManagerServer) GetNode(context.Context, *UuidRequest) (*Node, error) {
	return nil, status.Error(codes.Unimplemented, "method GetNode not implemented")
}
func (UnimplementedManagerServer) GetNodeStatus(context.Context, *UuidRequest) (*NodeStatusReply, error) {
	return nil, status.Error(codes.Unimplemented, "method GetNodeStatus not implemented")
}
func (UnimplementedManagerServer) UpdateNode(context.Context, *NodeUpdateRequest) (*Node, error) {
	return nil, status.Error(codes.Unimplemented, "method UpdateNode not implemented")
}
func (UnimplementedManagerServer) DeleteNode(context.Context, *UuidRequest) (*Node, error) {
	return nil, status.Error(codes.Unimplemented, "method DeleteNode not implemented")
}
func (UnimplementedManagerServer) CreateUser(context.Context, *UserCreate) (*User, error) {
	return nil, status.Error(codes.Unimplemented, "method CreateUser not implemented")
}
func (UnimplementedManagerServer) GetUsers(context.Context, *Filters) (*UserList, error) {
	return nil, status.Error(codes.Unimplemented, "method GetUsers not implemented")
}
func (UnimplementedManagerServer) GetUsersCount(context.Context, *Filters) (*CountReply, error) {
	return nil, status.Error(codes.Unimplemented, "method GetUsersCount not implemented")
}
func (UnimplementedManagerServer) GetUser(context.Context, *IdRequest) (*User, error) {
	return nil, status.Error(codes.Unimplemented, "method GetUser not implemented")
}
func (UnimplementedManagerServer) UpdateUser(context.Context, *UserUpdateRequest) (*User, error) {
	return nil, status.Error(codes.Unimplemented, "method UpdateUser not implemented")
}
func (UnimplementedManagerServer) DeleteUser(context.Context, *IdRequest) (*User, error) {
	return nil, status.Error(codes.Unimplemented, "method DeleteUser not implemented")
}
func (UnimplementedManagerServer) CreateBandwidthLimiter(context.Context, *BandwidthLimiterCreate) (*BandwidthLimiter, error) {
	return nil, status.Error(codes.Unimplemented, "method CreateBandwidthLimiter not implemented")
}
func (UnimplementedManagerServer) GetBandwidthLimiters(context.Context, *Filters) (*BandwidthLimiterList, error) {
	return nil, status.Error(codes.Unimplemented, "method GetBandwidthLimiters not implemented")
}
func (UnimplementedManagerServer) GetBandwidthLimitersCount(context.Context, *Filters) (*CountReply, error) {
	return nil, status.Error(codes.Unimplemented, "method GetBandwidthLimitersCount not implemented")
}
func (UnimplementedManagerServer) GetBandwidthLimiter(context.Context, *IdRequest) (*BandwidthLimiter, error) {
	return nil, status.Error(codes.Unimplemented, "method GetBandwidthLimiter not implemented")
}
func (UnimplementedManagerServer) UpdateBandwidthLimiter(context.Context, *BandwidthLimiterUpdateRequest) (*BandwidthLimiter, error) {
	return nil, status.Error(codes.Unimplemented, "method UpdateBandwidthLimiter not implemented")
}
func (UnimplementedManagerServer) DeleteBandwidthLimiter(context.Context, *IdRequest) (*BandwidthLimiter, error) {
	return nil, status.Error(codes.Unimplemented, "method DeleteBandwidthLimiter not implemented")
}
func (UnimplementedManagerServer) CreateTrafficLimiter(context.Context, *TrafficLimiterCreate) (*TrafficLimiter, error) {
	return nil, status.Error(codes.Unimplemented, "method CreateTrafficLimiter not implemented")
}
func (UnimplementedManagerServer) GetTrafficLimiters(context.Context, *Filters) (*TrafficLimiterList, error) {
	return nil, status.Error(codes.Unimplemented, "method GetTrafficLimiters not implemented")
}
func (UnimplementedManagerServer) GetTrafficLimitersCount(context.Context, *Filters) (*CountReply, error) {
	return nil, status.Error(codes.Unimplemented, "method GetTrafficLimitersCount not implemented")
}
func (UnimplementedManagerServer) GetTrafficLimiter(context.Context, *IdRequest) (*TrafficLimiter, error) {
	return nil, status.Error(codes.Unimplemented, "method GetTrafficLimiter not implemented")
}
func (UnimplementedManagerServer) UpdateTrafficLimiter(context.Context, *TrafficLimiterUpdateRequest) (*TrafficLimiter, error) {
	return nil, status.Error(codes.Unimplemented, "method UpdateTrafficLimiter not implemented")
}
func (UnimplementedManagerServer) DeleteTrafficLimiter(context.Context, *IdRequest) (*TrafficLimiter, error) {
	return nil, status.Error(codes.Unimplemented, "method DeleteTrafficLimiter not implemented")
}
func (UnimplementedManagerServer) CreateConnectionLimiter(context.Context, *ConnectionLimiterCreate) (*ConnectionLimiter, error) {
	return nil, status.Error(codes.Unimplemented, "method CreateConnectionLimiter not implemented")
}
func (UnimplementedManagerServer) GetConnectionLimiters(context.Context, *Filters) (*ConnectionLimiterList, error) {
	return nil, status.Error(codes.Unimplemented, "method GetConnectionLimiters not implemented")
}
func (UnimplementedManagerServer) GetConnectionLimitersCount(context.Context, *Filters) (*CountReply, error) {
	return nil, status.Error(codes.Unimplemented, "method GetConnectionLimitersCount not implemented")
}
func (UnimplementedManagerServer) GetConnectionLimiter(context.Context, *IdRequest) (*ConnectionLimiter, error) {
	return nil, status.Error(codes.Unimplemented, "method GetConnectionLimiter not implemented")
}
func (UnimplementedManagerServer) UpdateConnectionLimiter(context.Context, *ConnectionLimiterUpdateRequest) (*ConnectionLimiter, error) {
	return nil, status.Error(codes.Unimplemented, "method UpdateConnectionLimiter not implemented")
}
func (UnimplementedManagerServer) DeleteConnectionLimiter(context.Context, *IdRequest) (*ConnectionLimiter, error) {
	return nil, status.Error(codes.Unimplemented, "method DeleteConnectionLimiter not implemented")
}
func (UnimplementedManagerServer) CreateRateLimiter(context.Context, *RateLimiterCreate) (*RateLimiter, error) {
	return nil, status.Error(codes.Unimplemented, "method CreateRateLimiter not implemented")
}
func (UnimplementedManagerServer) GetRateLimiters(context.Context, *Filters) (*RateLimiterList, error) {
	return nil, status.Error(codes.Unimplemented, "method GetRateLimiters not implemented")
}
func (UnimplementedManagerServer) GetRateLimitersCount(context.Context, *Filters) (*CountReply, error) {
	return nil, status.Error(codes.Unimplemented, "method GetRateLimitersCount not implemented")
}
func (UnimplementedManagerServer) GetRateLimiter(context.Context, *IdRequest) (*RateLimiter, error) {
	return nil, status.Error(codes.Unimplemented, "method GetRateLimiter not implemented")
}
func (UnimplementedManagerServer) UpdateRateLimiter(context.Context, *RateLimiterUpdateRequest) (*RateLimiter, error) {
	return nil, status.Error(codes.Unimplemented, "method UpdateRateLimiter not implemented")
}
func (UnimplementedManagerServer) DeleteRateLimiter(context.Context, *IdRequest) (*RateLimiter, error) {
	return nil, status.Error(codes.Unimplemented, "method DeleteRateLimiter not implemented")
}
func (UnimplementedManagerServer) mustEmbedUnimplementedManagerServer() {}
func (UnimplementedManagerServer) testEmbeddedByValue()                 {}

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

func RegisterManagerServer(s grpc.ServiceRegistrar, srv ManagerServer) {
	// If the following call panics, it indicates UnimplementedManagerServer was
	// embedded by pointer and is nil.  This will cause panics if an
	// unimplemented method is ever invoked, so we test this at initialization
	// time to prevent it from happening at runtime later due to I/O.
	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
		t.testEmbeddedByValue()
	}
	s.RegisterService(&Manager_ServiceDesc, srv)
}

func _Manager_CreateSquad_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SquadCreate)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagerServer).CreateSquad(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Manager_CreateSquad_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagerServer).CreateSquad(ctx, req.(*SquadCreate))
	}
	return interceptor(ctx, in, info, handler)
}

func _Manager_GetSquads_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Filters)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagerServer).GetSquads(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Manager_GetSquads_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagerServer).GetSquads(ctx, req.(*Filters))
	}
	return interceptor(ctx, in, info, handler)
}

func _Manager_GetSquadsCount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Filters)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagerServer).GetSquadsCount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Manager_GetSquadsCount_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagerServer).GetSquadsCount(ctx, req.(*Filters))
	}
	return interceptor(ctx, in, info, handler)
}

func _Manager_GetSquad_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(IdRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagerServer).GetSquad(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Manager_GetSquad_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagerServer).GetSquad(ctx, req.(*IdRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Manager_UpdateSquad_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SquadUpdateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagerServer).UpdateSquad(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Manager_UpdateSquad_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagerServer).UpdateSquad(ctx, req.(*SquadUpdateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Manager_DeleteSquad_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(IdRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagerServer).DeleteSquad(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Manager_DeleteSquad_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagerServer).DeleteSquad(ctx, req.(*IdRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Manager_CreateNode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(NodeCreate)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagerServer).CreateNode(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Manager_CreateNode_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagerServer).CreateNode(ctx, req.(*NodeCreate))
	}
	return interceptor(ctx, in, info, handler)
}

func _Manager_GetNodes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Filters)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagerServer).GetNodes(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Manager_GetNodes_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagerServer).GetNodes(ctx, req.(*Filters))
	}
	return interceptor(ctx, in, info, handler)
}

func _Manager_GetNodesCount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Filters)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagerServer).GetNodesCount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Manager_GetNodesCount_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagerServer).GetNodesCount(ctx, req.(*Filters))
	}
	return interceptor(ctx, in, info, handler)
}

func _Manager_GetNode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UuidRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagerServer).GetNode(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Manager_GetNode_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagerServer).GetNode(ctx, req.(*UuidRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Manager_GetNodeStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UuidRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagerServer).GetNodeStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Manager_GetNodeStatus_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagerServer).GetNodeStatus(ctx, req.(*UuidRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Manager_UpdateNode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(NodeUpdateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagerServer).UpdateNode(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Manager_UpdateNode_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagerServer).UpdateNode(ctx, req.(*NodeUpdateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Manager_DeleteNode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UuidRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagerServer).DeleteNode(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Manager_DeleteNode_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagerServer).DeleteNode(ctx, req.(*UuidRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Manager_CreateUser_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UserCreate)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagerServer).CreateUser(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Manager_CreateUser_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagerServer).CreateUser(ctx, req.(*UserCreate))
	}
	return interceptor(ctx, in, info, handler)
}

func _Manager_GetUsers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Filters)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagerServer).GetUsers(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Manager_GetUsers_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagerServer).GetUsers(ctx, req.(*Filters))
	}
	return interceptor(ctx, in, info, handler)
}

func _Manager_GetUsersCount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Filters)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagerServer).GetUsersCount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Manager_GetUsersCount_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagerServer).GetUsersCount(ctx, req.(*Filters))
	}
	return interceptor(ctx, in, info, handler)
}

func _Manager_GetUser_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(IdRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagerServer).GetUser(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Manager_GetUser_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagerServer).GetUser(ctx, req.(*IdRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Manager_UpdateUser_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UserUpdateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagerServer).UpdateUser(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Manager_UpdateUser_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagerServer).UpdateUser(ctx, req.(*UserUpdateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Manager_DeleteUser_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(IdRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagerServer).DeleteUser(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Manager_DeleteUser_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagerServer).DeleteUser(ctx, req.(*IdRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Manager_CreateBandwidthLimiter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BandwidthLimiterCreate)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagerServer).CreateBandwidthLimiter(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Manager_CreateBandwidthLimiter_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagerServer).CreateBandwidthLimiter(ctx, req.(*BandwidthLimiterCreate))
	}
	return interceptor(ctx, in, info, handler)
}

func _Manager_GetBandwidthLimiters_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Filters)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagerServer).GetBandwidthLimiters(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Manager_GetBandwidthLimiters_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagerServer).GetBandwidthLimiters(ctx, req.(*Filters))
	}
	return interceptor(ctx, in, info, handler)
}

func _Manager_GetBandwidthLimitersCount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Filters)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagerServer).GetBandwidthLimitersCount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Manager_GetBandwidthLimitersCount_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagerServer).GetBandwidthLimitersCount(ctx, req.(*Filters))
	}
	return interceptor(ctx, in, info, handler)
}

func _Manager_GetBandwidthLimiter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(IdRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagerServer).GetBandwidthLimiter(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Manager_GetBandwidthLimiter_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagerServer).GetBandwidthLimiter(ctx, req.(*IdRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Manager_UpdateBandwidthLimiter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BandwidthLimiterUpdateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagerServer).UpdateBandwidthLimiter(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Manager_UpdateBandwidthLimiter_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagerServer).UpdateBandwidthLimiter(ctx, req.(*BandwidthLimiterUpdateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Manager_DeleteBandwidthLimiter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(IdRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagerServer).DeleteBandwidthLimiter(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Manager_DeleteBandwidthLimiter_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagerServer).DeleteBandwidthLimiter(ctx, req.(*IdRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Manager_CreateTrafficLimiter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TrafficLimiterCreate)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagerServer).CreateTrafficLimiter(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Manager_CreateTrafficLimiter_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagerServer).CreateTrafficLimiter(ctx, req.(*TrafficLimiterCreate))
	}
	return interceptor(ctx, in, info, handler)
}

func _Manager_GetTrafficLimiters_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Filters)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagerServer).GetTrafficLimiters(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Manager_GetTrafficLimiters_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagerServer).GetTrafficLimiters(ctx, req.(*Filters))
	}
	return interceptor(ctx, in, info, handler)
}

func _Manager_GetTrafficLimitersCount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Filters)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagerServer).GetTrafficLimitersCount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Manager_GetTrafficLimitersCount_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagerServer).GetTrafficLimitersCount(ctx, req.(*Filters))
	}
	return interceptor(ctx, in, info, handler)
}

func _Manager_GetTrafficLimiter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(IdRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagerServer).GetTrafficLimiter(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Manager_GetTrafficLimiter_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagerServer).GetTrafficLimiter(ctx, req.(*IdRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Manager_UpdateTrafficLimiter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TrafficLimiterUpdateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagerServer).UpdateTrafficLimiter(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Manager_UpdateTrafficLimiter_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagerServer).UpdateTrafficLimiter(ctx, req.(*TrafficLimiterUpdateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Manager_DeleteTrafficLimiter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(IdRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagerServer).DeleteTrafficLimiter(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Manager_DeleteTrafficLimiter_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagerServer).DeleteTrafficLimiter(ctx, req.(*IdRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Manager_CreateConnectionLimiter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ConnectionLimiterCreate)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagerServer).CreateConnectionLimiter(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Manager_CreateConnectionLimiter_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagerServer).CreateConnectionLimiter(ctx, req.(*ConnectionLimiterCreate))
	}
	return interceptor(ctx, in, info, handler)
}

func _Manager_GetConnectionLimiters_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Filters)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagerServer).GetConnectionLimiters(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Manager_GetConnectionLimiters_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagerServer).GetConnectionLimiters(ctx, req.(*Filters))
	}
	return interceptor(ctx, in, info, handler)
}

func _Manager_GetConnectionLimitersCount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Filters)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagerServer).GetConnectionLimitersCount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Manager_GetConnectionLimitersCount_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagerServer).GetConnectionLimitersCount(ctx, req.(*Filters))
	}
	return interceptor(ctx, in, info, handler)
}

func _Manager_GetConnectionLimiter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(IdRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagerServer).GetConnectionLimiter(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Manager_GetConnectionLimiter_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagerServer).GetConnectionLimiter(ctx, req.(*IdRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Manager_UpdateConnectionLimiter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ConnectionLimiterUpdateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagerServer).UpdateConnectionLimiter(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Manager_UpdateConnectionLimiter_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagerServer).UpdateConnectionLimiter(ctx, req.(*ConnectionLimiterUpdateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Manager_DeleteConnectionLimiter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(IdRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagerServer).DeleteConnectionLimiter(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Manager_DeleteConnectionLimiter_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagerServer).DeleteConnectionLimiter(ctx, req.(*IdRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Manager_CreateRateLimiter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RateLimiterCreate)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagerServer).CreateRateLimiter(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Manager_CreateRateLimiter_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagerServer).CreateRateLimiter(ctx, req.(*RateLimiterCreate))
	}
	return interceptor(ctx, in, info, handler)
}

func _Manager_GetRateLimiters_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Filters)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagerServer).GetRateLimiters(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Manager_GetRateLimiters_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagerServer).GetRateLimiters(ctx, req.(*Filters))
	}
	return interceptor(ctx, in, info, handler)
}

func _Manager_GetRateLimitersCount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Filters)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagerServer).GetRateLimitersCount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Manager_GetRateLimitersCount_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagerServer).GetRateLimitersCount(ctx, req.(*Filters))
	}
	return interceptor(ctx, in, info, handler)
}

func _Manager_GetRateLimiter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(IdRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagerServer).GetRateLimiter(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Manager_GetRateLimiter_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagerServer).GetRateLimiter(ctx, req.(*IdRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Manager_UpdateRateLimiter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RateLimiterUpdateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagerServer).UpdateRateLimiter(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Manager_UpdateRateLimiter_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagerServer).UpdateRateLimiter(ctx, req.(*RateLimiterUpdateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Manager_DeleteRateLimiter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(IdRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagerServer).DeleteRateLimiter(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Manager_DeleteRateLimiter_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagerServer).DeleteRateLimiter(ctx, req.(*IdRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// Manager_ServiceDesc is the grpc.ServiceDesc for Manager service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var Manager_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "manager_api.v1.Manager",
	HandlerType: (*ManagerServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateSquad",
			Handler:    _Manager_CreateSquad_Handler,
		},
		{
			MethodName: "GetSquads",
			Handler:    _Manager_GetSquads_Handler,
		},
		{
			MethodName: "GetSquadsCount",
			Handler:    _Manager_GetSquadsCount_Handler,
		},
		{
			MethodName: "GetSquad",
			Handler:    _Manager_GetSquad_Handler,
		},
		{
			MethodName: "UpdateSquad",
			Handler:    _Manager_UpdateSquad_Handler,
		},
		{
			MethodName: "DeleteSquad",
			Handler:    _Manager_DeleteSquad_Handler,
		},
		{
			MethodName: "CreateNode",
			Handler:    _Manager_CreateNode_Handler,
		},
		{
			MethodName: "GetNodes",
			Handler:    _Manager_GetNodes_Handler,
		},
		{
			MethodName: "GetNodesCount",
			Handler:    _Manager_GetNodesCount_Handler,
		},
		{
			MethodName: "GetNode",
			Handler:    _Manager_GetNode_Handler,
		},
		{
			MethodName: "GetNodeStatus",
			Handler:    _Manager_GetNodeStatus_Handler,
		},
		{
			MethodName: "UpdateNode",
			Handler:    _Manager_UpdateNode_Handler,
		},
		{
			MethodName: "DeleteNode",
			Handler:    _Manager_DeleteNode_Handler,
		},
		{
			MethodName: "CreateUser",
			Handler:    _Manager_CreateUser_Handler,
		},
		{
			MethodName: "GetUsers",
			Handler:    _Manager_GetUsers_Handler,
		},
		{
			MethodName: "GetUsersCount",
			Handler:    _Manager_GetUsersCount_Handler,
		},
		{
			MethodName: "GetUser",
			Handler:    _Manager_GetUser_Handler,
		},
		{
			MethodName: "UpdateUser",
			Handler:    _Manager_UpdateUser_Handler,
		},
		{
			MethodName: "DeleteUser",
			Handler:    _Manager_DeleteUser_Handler,
		},
		{
			MethodName: "CreateBandwidthLimiter",
			Handler:    _Manager_CreateBandwidthLimiter_Handler,
		},
		{
			MethodName: "GetBandwidthLimiters",
			Handler:    _Manager_GetBandwidthLimiters_Handler,
		},
		{
			MethodName: "GetBandwidthLimitersCount",
			Handler:    _Manager_GetBandwidthLimitersCount_Handler,
		},
		{
			MethodName: "GetBandwidthLimiter",
			Handler:    _Manager_GetBandwidthLimiter_Handler,
		},
		{
			MethodName: "UpdateBandwidthLimiter",
			Handler:    _Manager_UpdateBandwidthLimiter_Handler,
		},
		{
			MethodName: "DeleteBandwidthLimiter",
			Handler:    _Manager_DeleteBandwidthLimiter_Handler,
		},
		{
			MethodName: "CreateTrafficLimiter",
			Handler:    _Manager_CreateTrafficLimiter_Handler,
		},
		{
			MethodName: "GetTrafficLimiters",
			Handler:    _Manager_GetTrafficLimiters_Handler,
		},
		{
			MethodName: "GetTrafficLimitersCount",
			Handler:    _Manager_GetTrafficLimitersCount_Handler,
		},
		{
			MethodName: "GetTrafficLimiter",
			Handler:    _Manager_GetTrafficLimiter_Handler,
		},
		{
			MethodName: "UpdateTrafficLimiter",
			Handler:    _Manager_UpdateTrafficLimiter_Handler,
		},
		{
			MethodName: "DeleteTrafficLimiter",
			Handler:    _Manager_DeleteTrafficLimiter_Handler,
		},
		{
			MethodName: "CreateConnectionLimiter",
			Handler:    _Manager_CreateConnectionLimiter_Handler,
		},
		{
			MethodName: "GetConnectionLimiters",
			Handler:    _Manager_GetConnectionLimiters_Handler,
		},
		{
			MethodName: "GetConnectionLimitersCount",
			Handler:    _Manager_GetConnectionLimitersCount_Handler,
		},
		{
			MethodName: "GetConnectionLimiter",
			Handler:    _Manager_GetConnectionLimiter_Handler,
		},
		{
			MethodName: "UpdateConnectionLimiter",
			Handler:    _Manager_UpdateConnectionLimiter_Handler,
		},
		{
			MethodName: "DeleteConnectionLimiter",
			Handler:    _Manager_DeleteConnectionLimiter_Handler,
		},
		{
			MethodName: "CreateRateLimiter",
			Handler:    _Manager_CreateRateLimiter_Handler,
		},
		{
			MethodName: "GetRateLimiters",
			Handler:    _Manager_GetRateLimiters_Handler,
		},
		{
			MethodName: "GetRateLimitersCount",
			Handler:    _Manager_GetRateLimitersCount_Handler,
		},
		{
			MethodName: "GetRateLimiter",
			Handler:    _Manager_GetRateLimiter_Handler,
		},
		{
			MethodName: "UpdateRateLimiter",
			Handler:    _Manager_UpdateRateLimiter_Handler,
		},
		{
			MethodName: "DeleteRateLimiter",
			Handler:    _Manager_DeleteRateLimiter_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "service/manager_api/grpc/manager/manager.proto",
}
