// Copyright (C) 2015-2017 Nippon Telegraph and Telephone Corporation.
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation files
// (the "Software"), to deal in the Software without restriction,
// including without limitation the rights to use, copy, modify, merge,
// publish, distribute, sublicense, and/or sell copies of the Software,
// and to permit persons to whom the Software is furnished to do so,
// subject to the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.5.1
// - protoc             (unknown)
// source: api/gobgp.proto

package api

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 (
	GoBgpService_StartBgp_FullMethodName               = "/api.GoBgpService/StartBgp"
	GoBgpService_StopBgp_FullMethodName                = "/api.GoBgpService/StopBgp"
	GoBgpService_GetBgp_FullMethodName                 = "/api.GoBgpService/GetBgp"
	GoBgpService_WatchEvent_FullMethodName             = "/api.GoBgpService/WatchEvent"
	GoBgpService_AddPeer_FullMethodName                = "/api.GoBgpService/AddPeer"
	GoBgpService_DeletePeer_FullMethodName             = "/api.GoBgpService/DeletePeer"
	GoBgpService_ListPeer_FullMethodName               = "/api.GoBgpService/ListPeer"
	GoBgpService_UpdatePeer_FullMethodName             = "/api.GoBgpService/UpdatePeer"
	GoBgpService_ResetPeer_FullMethodName              = "/api.GoBgpService/ResetPeer"
	GoBgpService_ShutdownPeer_FullMethodName           = "/api.GoBgpService/ShutdownPeer"
	GoBgpService_EnablePeer_FullMethodName             = "/api.GoBgpService/EnablePeer"
	GoBgpService_DisablePeer_FullMethodName            = "/api.GoBgpService/DisablePeer"
	GoBgpService_AddPeerGroup_FullMethodName           = "/api.GoBgpService/AddPeerGroup"
	GoBgpService_DeletePeerGroup_FullMethodName        = "/api.GoBgpService/DeletePeerGroup"
	GoBgpService_ListPeerGroup_FullMethodName          = "/api.GoBgpService/ListPeerGroup"
	GoBgpService_UpdatePeerGroup_FullMethodName        = "/api.GoBgpService/UpdatePeerGroup"
	GoBgpService_AddDynamicNeighbor_FullMethodName     = "/api.GoBgpService/AddDynamicNeighbor"
	GoBgpService_ListDynamicNeighbor_FullMethodName    = "/api.GoBgpService/ListDynamicNeighbor"
	GoBgpService_DeleteDynamicNeighbor_FullMethodName  = "/api.GoBgpService/DeleteDynamicNeighbor"
	GoBgpService_AddPath_FullMethodName                = "/api.GoBgpService/AddPath"
	GoBgpService_DeletePath_FullMethodName             = "/api.GoBgpService/DeletePath"
	GoBgpService_ListPath_FullMethodName               = "/api.GoBgpService/ListPath"
	GoBgpService_AddPathStream_FullMethodName          = "/api.GoBgpService/AddPathStream"
	GoBgpService_GetTable_FullMethodName               = "/api.GoBgpService/GetTable"
	GoBgpService_AddVrf_FullMethodName                 = "/api.GoBgpService/AddVrf"
	GoBgpService_DeleteVrf_FullMethodName              = "/api.GoBgpService/DeleteVrf"
	GoBgpService_ListVrf_FullMethodName                = "/api.GoBgpService/ListVrf"
	GoBgpService_AddPolicy_FullMethodName              = "/api.GoBgpService/AddPolicy"
	GoBgpService_DeletePolicy_FullMethodName           = "/api.GoBgpService/DeletePolicy"
	GoBgpService_ListPolicy_FullMethodName             = "/api.GoBgpService/ListPolicy"
	GoBgpService_SetPolicies_FullMethodName            = "/api.GoBgpService/SetPolicies"
	GoBgpService_AddDefinedSet_FullMethodName          = "/api.GoBgpService/AddDefinedSet"
	GoBgpService_DeleteDefinedSet_FullMethodName       = "/api.GoBgpService/DeleteDefinedSet"
	GoBgpService_ListDefinedSet_FullMethodName         = "/api.GoBgpService/ListDefinedSet"
	GoBgpService_AddStatement_FullMethodName           = "/api.GoBgpService/AddStatement"
	GoBgpService_DeleteStatement_FullMethodName        = "/api.GoBgpService/DeleteStatement"
	GoBgpService_ListStatement_FullMethodName          = "/api.GoBgpService/ListStatement"
	GoBgpService_AddPolicyAssignment_FullMethodName    = "/api.GoBgpService/AddPolicyAssignment"
	GoBgpService_DeletePolicyAssignment_FullMethodName = "/api.GoBgpService/DeletePolicyAssignment"
	GoBgpService_ListPolicyAssignment_FullMethodName   = "/api.GoBgpService/ListPolicyAssignment"
	GoBgpService_SetPolicyAssignment_FullMethodName    = "/api.GoBgpService/SetPolicyAssignment"
	GoBgpService_AddRpki_FullMethodName                = "/api.GoBgpService/AddRpki"
	GoBgpService_DeleteRpki_FullMethodName             = "/api.GoBgpService/DeleteRpki"
	GoBgpService_ListRpki_FullMethodName               = "/api.GoBgpService/ListRpki"
	GoBgpService_EnableRpki_FullMethodName             = "/api.GoBgpService/EnableRpki"
	GoBgpService_DisableRpki_FullMethodName            = "/api.GoBgpService/DisableRpki"
	GoBgpService_ResetRpki_FullMethodName              = "/api.GoBgpService/ResetRpki"
	GoBgpService_ListRpkiTable_FullMethodName          = "/api.GoBgpService/ListRpkiTable"
	GoBgpService_EnableZebra_FullMethodName            = "/api.GoBgpService/EnableZebra"
	GoBgpService_EnableMrt_FullMethodName              = "/api.GoBgpService/EnableMrt"
	GoBgpService_DisableMrt_FullMethodName             = "/api.GoBgpService/DisableMrt"
	GoBgpService_AddBmp_FullMethodName                 = "/api.GoBgpService/AddBmp"
	GoBgpService_DeleteBmp_FullMethodName              = "/api.GoBgpService/DeleteBmp"
	GoBgpService_ListBmp_FullMethodName                = "/api.GoBgpService/ListBmp"
	GoBgpService_SetLogLevel_FullMethodName            = "/api.GoBgpService/SetLogLevel"
)

// GoBgpServiceClient is the client API for GoBgpService 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.
//
// Interface exported by the server.
type GoBgpServiceClient interface {
	StartBgp(ctx context.Context, in *StartBgpRequest, opts ...grpc.CallOption) (*StartBgpResponse, error)
	StopBgp(ctx context.Context, in *StopBgpRequest, opts ...grpc.CallOption) (*StopBgpResponse, error)
	GetBgp(ctx context.Context, in *GetBgpRequest, opts ...grpc.CallOption) (*GetBgpResponse, error)
	WatchEvent(ctx context.Context, in *WatchEventRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[WatchEventResponse], error)
	AddPeer(ctx context.Context, in *AddPeerRequest, opts ...grpc.CallOption) (*AddPeerResponse, error)
	DeletePeer(ctx context.Context, in *DeletePeerRequest, opts ...grpc.CallOption) (*DeletePeerResponse, error)
	ListPeer(ctx context.Context, in *ListPeerRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ListPeerResponse], error)
	UpdatePeer(ctx context.Context, in *UpdatePeerRequest, opts ...grpc.CallOption) (*UpdatePeerResponse, error)
	ResetPeer(ctx context.Context, in *ResetPeerRequest, opts ...grpc.CallOption) (*ResetPeerResponse, error)
	ShutdownPeer(ctx context.Context, in *ShutdownPeerRequest, opts ...grpc.CallOption) (*ShutdownPeerResponse, error)
	EnablePeer(ctx context.Context, in *EnablePeerRequest, opts ...grpc.CallOption) (*EnablePeerResponse, error)
	DisablePeer(ctx context.Context, in *DisablePeerRequest, opts ...grpc.CallOption) (*DisablePeerResponse, error)
	AddPeerGroup(ctx context.Context, in *AddPeerGroupRequest, opts ...grpc.CallOption) (*AddPeerGroupResponse, error)
	DeletePeerGroup(ctx context.Context, in *DeletePeerGroupRequest, opts ...grpc.CallOption) (*DeletePeerGroupResponse, error)
	ListPeerGroup(ctx context.Context, in *ListPeerGroupRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ListPeerGroupResponse], error)
	UpdatePeerGroup(ctx context.Context, in *UpdatePeerGroupRequest, opts ...grpc.CallOption) (*UpdatePeerGroupResponse, error)
	AddDynamicNeighbor(ctx context.Context, in *AddDynamicNeighborRequest, opts ...grpc.CallOption) (*AddDynamicNeighborResponse, error)
	ListDynamicNeighbor(ctx context.Context, in *ListDynamicNeighborRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ListDynamicNeighborResponse], error)
	DeleteDynamicNeighbor(ctx context.Context, in *DeleteDynamicNeighborRequest, opts ...grpc.CallOption) (*DeleteDynamicNeighborResponse, error)
	AddPath(ctx context.Context, in *AddPathRequest, opts ...grpc.CallOption) (*AddPathResponse, error)
	DeletePath(ctx context.Context, in *DeletePathRequest, opts ...grpc.CallOption) (*DeletePathResponse, error)
	ListPath(ctx context.Context, in *ListPathRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ListPathResponse], error)
	AddPathStream(ctx context.Context, opts ...grpc.CallOption) (grpc.ClientStreamingClient[AddPathStreamRequest, AddPathStreamResponse], error)
	GetTable(ctx context.Context, in *GetTableRequest, opts ...grpc.CallOption) (*GetTableResponse, error)
	AddVrf(ctx context.Context, in *AddVrfRequest, opts ...grpc.CallOption) (*AddVrfResponse, error)
	DeleteVrf(ctx context.Context, in *DeleteVrfRequest, opts ...grpc.CallOption) (*DeleteVrfResponse, error)
	ListVrf(ctx context.Context, in *ListVrfRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ListVrfResponse], error)
	AddPolicy(ctx context.Context, in *AddPolicyRequest, opts ...grpc.CallOption) (*AddPolicyResponse, error)
	DeletePolicy(ctx context.Context, in *DeletePolicyRequest, opts ...grpc.CallOption) (*DeletePolicyResponse, error)
	ListPolicy(ctx context.Context, in *ListPolicyRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ListPolicyResponse], error)
	SetPolicies(ctx context.Context, in *SetPoliciesRequest, opts ...grpc.CallOption) (*SetPoliciesResponse, error)
	AddDefinedSet(ctx context.Context, in *AddDefinedSetRequest, opts ...grpc.CallOption) (*AddDefinedSetResponse, error)
	DeleteDefinedSet(ctx context.Context, in *DeleteDefinedSetRequest, opts ...grpc.CallOption) (*DeleteDefinedSetResponse, error)
	ListDefinedSet(ctx context.Context, in *ListDefinedSetRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ListDefinedSetResponse], error)
	AddStatement(ctx context.Context, in *AddStatementRequest, opts ...grpc.CallOption) (*AddStatementResponse, error)
	DeleteStatement(ctx context.Context, in *DeleteStatementRequest, opts ...grpc.CallOption) (*DeleteStatementResponse, error)
	ListStatement(ctx context.Context, in *ListStatementRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ListStatementResponse], error)
	AddPolicyAssignment(ctx context.Context, in *AddPolicyAssignmentRequest, opts ...grpc.CallOption) (*AddPolicyAssignmentResponse, error)
	DeletePolicyAssignment(ctx context.Context, in *DeletePolicyAssignmentRequest, opts ...grpc.CallOption) (*DeletePolicyAssignmentResponse, error)
	ListPolicyAssignment(ctx context.Context, in *ListPolicyAssignmentRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ListPolicyAssignmentResponse], error)
	SetPolicyAssignment(ctx context.Context, in *SetPolicyAssignmentRequest, opts ...grpc.CallOption) (*SetPolicyAssignmentResponse, error)
	AddRpki(ctx context.Context, in *AddRpkiRequest, opts ...grpc.CallOption) (*AddRpkiResponse, error)
	DeleteRpki(ctx context.Context, in *DeleteRpkiRequest, opts ...grpc.CallOption) (*DeleteRpkiResponse, error)
	ListRpki(ctx context.Context, in *ListRpkiRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ListRpkiResponse], error)
	EnableRpki(ctx context.Context, in *EnableRpkiRequest, opts ...grpc.CallOption) (*EnableRpkiResponse, error)
	DisableRpki(ctx context.Context, in *DisableRpkiRequest, opts ...grpc.CallOption) (*DisableRpkiResponse, error)
	ResetRpki(ctx context.Context, in *ResetRpkiRequest, opts ...grpc.CallOption) (*ResetRpkiResponse, error)
	ListRpkiTable(ctx context.Context, in *ListRpkiTableRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ListRpkiTableResponse], error)
	EnableZebra(ctx context.Context, in *EnableZebraRequest, opts ...grpc.CallOption) (*EnableZebraResponse, error)
	EnableMrt(ctx context.Context, in *EnableMrtRequest, opts ...grpc.CallOption) (*EnableMrtResponse, error)
	DisableMrt(ctx context.Context, in *DisableMrtRequest, opts ...grpc.CallOption) (*DisableMrtResponse, error)
	AddBmp(ctx context.Context, in *AddBmpRequest, opts ...grpc.CallOption) (*AddBmpResponse, error)
	DeleteBmp(ctx context.Context, in *DeleteBmpRequest, opts ...grpc.CallOption) (*DeleteBmpResponse, error)
	ListBmp(ctx context.Context, in *ListBmpRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ListBmpResponse], error)
	SetLogLevel(ctx context.Context, in *SetLogLevelRequest, opts ...grpc.CallOption) (*SetLogLevelResponse, error)
}

type goBgpServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewGoBgpServiceClient(cc grpc.ClientConnInterface) GoBgpServiceClient {
	return &goBgpServiceClient{cc}
}

func (c *goBgpServiceClient) StartBgp(ctx context.Context, in *StartBgpRequest, opts ...grpc.CallOption) (*StartBgpResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(StartBgpResponse)
	err := c.cc.Invoke(ctx, GoBgpService_StartBgp_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goBgpServiceClient) StopBgp(ctx context.Context, in *StopBgpRequest, opts ...grpc.CallOption) (*StopBgpResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(StopBgpResponse)
	err := c.cc.Invoke(ctx, GoBgpService_StopBgp_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goBgpServiceClient) GetBgp(ctx context.Context, in *GetBgpRequest, opts ...grpc.CallOption) (*GetBgpResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetBgpResponse)
	err := c.cc.Invoke(ctx, GoBgpService_GetBgp_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goBgpServiceClient) WatchEvent(ctx context.Context, in *WatchEventRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[WatchEventResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &GoBgpService_ServiceDesc.Streams[0], GoBgpService_WatchEvent_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[WatchEventRequest, WatchEventResponse]{ClientStream: stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type GoBgpService_WatchEventClient = grpc.ServerStreamingClient[WatchEventResponse]

func (c *goBgpServiceClient) AddPeer(ctx context.Context, in *AddPeerRequest, opts ...grpc.CallOption) (*AddPeerResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(AddPeerResponse)
	err := c.cc.Invoke(ctx, GoBgpService_AddPeer_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goBgpServiceClient) DeletePeer(ctx context.Context, in *DeletePeerRequest, opts ...grpc.CallOption) (*DeletePeerResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DeletePeerResponse)
	err := c.cc.Invoke(ctx, GoBgpService_DeletePeer_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goBgpServiceClient) ListPeer(ctx context.Context, in *ListPeerRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ListPeerResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &GoBgpService_ServiceDesc.Streams[1], GoBgpService_ListPeer_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[ListPeerRequest, ListPeerResponse]{ClientStream: stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type GoBgpService_ListPeerClient = grpc.ServerStreamingClient[ListPeerResponse]

func (c *goBgpServiceClient) UpdatePeer(ctx context.Context, in *UpdatePeerRequest, opts ...grpc.CallOption) (*UpdatePeerResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(UpdatePeerResponse)
	err := c.cc.Invoke(ctx, GoBgpService_UpdatePeer_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goBgpServiceClient) ResetPeer(ctx context.Context, in *ResetPeerRequest, opts ...grpc.CallOption) (*ResetPeerResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ResetPeerResponse)
	err := c.cc.Invoke(ctx, GoBgpService_ResetPeer_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goBgpServiceClient) ShutdownPeer(ctx context.Context, in *ShutdownPeerRequest, opts ...grpc.CallOption) (*ShutdownPeerResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ShutdownPeerResponse)
	err := c.cc.Invoke(ctx, GoBgpService_ShutdownPeer_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goBgpServiceClient) EnablePeer(ctx context.Context, in *EnablePeerRequest, opts ...grpc.CallOption) (*EnablePeerResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(EnablePeerResponse)
	err := c.cc.Invoke(ctx, GoBgpService_EnablePeer_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goBgpServiceClient) DisablePeer(ctx context.Context, in *DisablePeerRequest, opts ...grpc.CallOption) (*DisablePeerResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DisablePeerResponse)
	err := c.cc.Invoke(ctx, GoBgpService_DisablePeer_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goBgpServiceClient) AddPeerGroup(ctx context.Context, in *AddPeerGroupRequest, opts ...grpc.CallOption) (*AddPeerGroupResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(AddPeerGroupResponse)
	err := c.cc.Invoke(ctx, GoBgpService_AddPeerGroup_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goBgpServiceClient) DeletePeerGroup(ctx context.Context, in *DeletePeerGroupRequest, opts ...grpc.CallOption) (*DeletePeerGroupResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DeletePeerGroupResponse)
	err := c.cc.Invoke(ctx, GoBgpService_DeletePeerGroup_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goBgpServiceClient) ListPeerGroup(ctx context.Context, in *ListPeerGroupRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ListPeerGroupResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &GoBgpService_ServiceDesc.Streams[2], GoBgpService_ListPeerGroup_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[ListPeerGroupRequest, ListPeerGroupResponse]{ClientStream: stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type GoBgpService_ListPeerGroupClient = grpc.ServerStreamingClient[ListPeerGroupResponse]

func (c *goBgpServiceClient) UpdatePeerGroup(ctx context.Context, in *UpdatePeerGroupRequest, opts ...grpc.CallOption) (*UpdatePeerGroupResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(UpdatePeerGroupResponse)
	err := c.cc.Invoke(ctx, GoBgpService_UpdatePeerGroup_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goBgpServiceClient) AddDynamicNeighbor(ctx context.Context, in *AddDynamicNeighborRequest, opts ...grpc.CallOption) (*AddDynamicNeighborResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(AddDynamicNeighborResponse)
	err := c.cc.Invoke(ctx, GoBgpService_AddDynamicNeighbor_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goBgpServiceClient) ListDynamicNeighbor(ctx context.Context, in *ListDynamicNeighborRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ListDynamicNeighborResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &GoBgpService_ServiceDesc.Streams[3], GoBgpService_ListDynamicNeighbor_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[ListDynamicNeighborRequest, ListDynamicNeighborResponse]{ClientStream: stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type GoBgpService_ListDynamicNeighborClient = grpc.ServerStreamingClient[ListDynamicNeighborResponse]

func (c *goBgpServiceClient) DeleteDynamicNeighbor(ctx context.Context, in *DeleteDynamicNeighborRequest, opts ...grpc.CallOption) (*DeleteDynamicNeighborResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DeleteDynamicNeighborResponse)
	err := c.cc.Invoke(ctx, GoBgpService_DeleteDynamicNeighbor_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goBgpServiceClient) AddPath(ctx context.Context, in *AddPathRequest, opts ...grpc.CallOption) (*AddPathResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(AddPathResponse)
	err := c.cc.Invoke(ctx, GoBgpService_AddPath_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goBgpServiceClient) DeletePath(ctx context.Context, in *DeletePathRequest, opts ...grpc.CallOption) (*DeletePathResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DeletePathResponse)
	err := c.cc.Invoke(ctx, GoBgpService_DeletePath_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goBgpServiceClient) ListPath(ctx context.Context, in *ListPathRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ListPathResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &GoBgpService_ServiceDesc.Streams[4], GoBgpService_ListPath_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[ListPathRequest, ListPathResponse]{ClientStream: stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type GoBgpService_ListPathClient = grpc.ServerStreamingClient[ListPathResponse]

func (c *goBgpServiceClient) AddPathStream(ctx context.Context, opts ...grpc.CallOption) (grpc.ClientStreamingClient[AddPathStreamRequest, AddPathStreamResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &GoBgpService_ServiceDesc.Streams[5], GoBgpService_AddPathStream_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[AddPathStreamRequest, AddPathStreamResponse]{ClientStream: stream}
	return x, nil
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type GoBgpService_AddPathStreamClient = grpc.ClientStreamingClient[AddPathStreamRequest, AddPathStreamResponse]

func (c *goBgpServiceClient) GetTable(ctx context.Context, in *GetTableRequest, opts ...grpc.CallOption) (*GetTableResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetTableResponse)
	err := c.cc.Invoke(ctx, GoBgpService_GetTable_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goBgpServiceClient) AddVrf(ctx context.Context, in *AddVrfRequest, opts ...grpc.CallOption) (*AddVrfResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(AddVrfResponse)
	err := c.cc.Invoke(ctx, GoBgpService_AddVrf_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goBgpServiceClient) DeleteVrf(ctx context.Context, in *DeleteVrfRequest, opts ...grpc.CallOption) (*DeleteVrfResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DeleteVrfResponse)
	err := c.cc.Invoke(ctx, GoBgpService_DeleteVrf_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goBgpServiceClient) ListVrf(ctx context.Context, in *ListVrfRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ListVrfResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &GoBgpService_ServiceDesc.Streams[6], GoBgpService_ListVrf_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[ListVrfRequest, ListVrfResponse]{ClientStream: stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type GoBgpService_ListVrfClient = grpc.ServerStreamingClient[ListVrfResponse]

func (c *goBgpServiceClient) AddPolicy(ctx context.Context, in *AddPolicyRequest, opts ...grpc.CallOption) (*AddPolicyResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(AddPolicyResponse)
	err := c.cc.Invoke(ctx, GoBgpService_AddPolicy_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goBgpServiceClient) DeletePolicy(ctx context.Context, in *DeletePolicyRequest, opts ...grpc.CallOption) (*DeletePolicyResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DeletePolicyResponse)
	err := c.cc.Invoke(ctx, GoBgpService_DeletePolicy_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goBgpServiceClient) ListPolicy(ctx context.Context, in *ListPolicyRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ListPolicyResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &GoBgpService_ServiceDesc.Streams[7], GoBgpService_ListPolicy_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[ListPolicyRequest, ListPolicyResponse]{ClientStream: stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type GoBgpService_ListPolicyClient = grpc.ServerStreamingClient[ListPolicyResponse]

func (c *goBgpServiceClient) SetPolicies(ctx context.Context, in *SetPoliciesRequest, opts ...grpc.CallOption) (*SetPoliciesResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(SetPoliciesResponse)
	err := c.cc.Invoke(ctx, GoBgpService_SetPolicies_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goBgpServiceClient) AddDefinedSet(ctx context.Context, in *AddDefinedSetRequest, opts ...grpc.CallOption) (*AddDefinedSetResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(AddDefinedSetResponse)
	err := c.cc.Invoke(ctx, GoBgpService_AddDefinedSet_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goBgpServiceClient) DeleteDefinedSet(ctx context.Context, in *DeleteDefinedSetRequest, opts ...grpc.CallOption) (*DeleteDefinedSetResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DeleteDefinedSetResponse)
	err := c.cc.Invoke(ctx, GoBgpService_DeleteDefinedSet_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goBgpServiceClient) ListDefinedSet(ctx context.Context, in *ListDefinedSetRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ListDefinedSetResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &GoBgpService_ServiceDesc.Streams[8], GoBgpService_ListDefinedSet_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[ListDefinedSetRequest, ListDefinedSetResponse]{ClientStream: stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type GoBgpService_ListDefinedSetClient = grpc.ServerStreamingClient[ListDefinedSetResponse]

func (c *goBgpServiceClient) AddStatement(ctx context.Context, in *AddStatementRequest, opts ...grpc.CallOption) (*AddStatementResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(AddStatementResponse)
	err := c.cc.Invoke(ctx, GoBgpService_AddStatement_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goBgpServiceClient) DeleteStatement(ctx context.Context, in *DeleteStatementRequest, opts ...grpc.CallOption) (*DeleteStatementResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DeleteStatementResponse)
	err := c.cc.Invoke(ctx, GoBgpService_DeleteStatement_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goBgpServiceClient) ListStatement(ctx context.Context, in *ListStatementRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ListStatementResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &GoBgpService_ServiceDesc.Streams[9], GoBgpService_ListStatement_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[ListStatementRequest, ListStatementResponse]{ClientStream: stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type GoBgpService_ListStatementClient = grpc.ServerStreamingClient[ListStatementResponse]

func (c *goBgpServiceClient) AddPolicyAssignment(ctx context.Context, in *AddPolicyAssignmentRequest, opts ...grpc.CallOption) (*AddPolicyAssignmentResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(AddPolicyAssignmentResponse)
	err := c.cc.Invoke(ctx, GoBgpService_AddPolicyAssignment_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goBgpServiceClient) DeletePolicyAssignment(ctx context.Context, in *DeletePolicyAssignmentRequest, opts ...grpc.CallOption) (*DeletePolicyAssignmentResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DeletePolicyAssignmentResponse)
	err := c.cc.Invoke(ctx, GoBgpService_DeletePolicyAssignment_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goBgpServiceClient) ListPolicyAssignment(ctx context.Context, in *ListPolicyAssignmentRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ListPolicyAssignmentResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &GoBgpService_ServiceDesc.Streams[10], GoBgpService_ListPolicyAssignment_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[ListPolicyAssignmentRequest, ListPolicyAssignmentResponse]{ClientStream: stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type GoBgpService_ListPolicyAssignmentClient = grpc.ServerStreamingClient[ListPolicyAssignmentResponse]

func (c *goBgpServiceClient) SetPolicyAssignment(ctx context.Context, in *SetPolicyAssignmentRequest, opts ...grpc.CallOption) (*SetPolicyAssignmentResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(SetPolicyAssignmentResponse)
	err := c.cc.Invoke(ctx, GoBgpService_SetPolicyAssignment_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goBgpServiceClient) AddRpki(ctx context.Context, in *AddRpkiRequest, opts ...grpc.CallOption) (*AddRpkiResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(AddRpkiResponse)
	err := c.cc.Invoke(ctx, GoBgpService_AddRpki_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goBgpServiceClient) DeleteRpki(ctx context.Context, in *DeleteRpkiRequest, opts ...grpc.CallOption) (*DeleteRpkiResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DeleteRpkiResponse)
	err := c.cc.Invoke(ctx, GoBgpService_DeleteRpki_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goBgpServiceClient) ListRpki(ctx context.Context, in *ListRpkiRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ListRpkiResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &GoBgpService_ServiceDesc.Streams[11], GoBgpService_ListRpki_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[ListRpkiRequest, ListRpkiResponse]{ClientStream: stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type GoBgpService_ListRpkiClient = grpc.ServerStreamingClient[ListRpkiResponse]

func (c *goBgpServiceClient) EnableRpki(ctx context.Context, in *EnableRpkiRequest, opts ...grpc.CallOption) (*EnableRpkiResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(EnableRpkiResponse)
	err := c.cc.Invoke(ctx, GoBgpService_EnableRpki_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goBgpServiceClient) DisableRpki(ctx context.Context, in *DisableRpkiRequest, opts ...grpc.CallOption) (*DisableRpkiResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DisableRpkiResponse)
	err := c.cc.Invoke(ctx, GoBgpService_DisableRpki_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goBgpServiceClient) ResetRpki(ctx context.Context, in *ResetRpkiRequest, opts ...grpc.CallOption) (*ResetRpkiResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ResetRpkiResponse)
	err := c.cc.Invoke(ctx, GoBgpService_ResetRpki_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goBgpServiceClient) ListRpkiTable(ctx context.Context, in *ListRpkiTableRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ListRpkiTableResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &GoBgpService_ServiceDesc.Streams[12], GoBgpService_ListRpkiTable_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[ListRpkiTableRequest, ListRpkiTableResponse]{ClientStream: stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type GoBgpService_ListRpkiTableClient = grpc.ServerStreamingClient[ListRpkiTableResponse]

func (c *goBgpServiceClient) EnableZebra(ctx context.Context, in *EnableZebraRequest, opts ...grpc.CallOption) (*EnableZebraResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(EnableZebraResponse)
	err := c.cc.Invoke(ctx, GoBgpService_EnableZebra_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goBgpServiceClient) EnableMrt(ctx context.Context, in *EnableMrtRequest, opts ...grpc.CallOption) (*EnableMrtResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(EnableMrtResponse)
	err := c.cc.Invoke(ctx, GoBgpService_EnableMrt_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goBgpServiceClient) DisableMrt(ctx context.Context, in *DisableMrtRequest, opts ...grpc.CallOption) (*DisableMrtResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DisableMrtResponse)
	err := c.cc.Invoke(ctx, GoBgpService_DisableMrt_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goBgpServiceClient) AddBmp(ctx context.Context, in *AddBmpRequest, opts ...grpc.CallOption) (*AddBmpResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(AddBmpResponse)
	err := c.cc.Invoke(ctx, GoBgpService_AddBmp_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goBgpServiceClient) DeleteBmp(ctx context.Context, in *DeleteBmpRequest, opts ...grpc.CallOption) (*DeleteBmpResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DeleteBmpResponse)
	err := c.cc.Invoke(ctx, GoBgpService_DeleteBmp_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *goBgpServiceClient) ListBmp(ctx context.Context, in *ListBmpRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ListBmpResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &GoBgpService_ServiceDesc.Streams[13], GoBgpService_ListBmp_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[ListBmpRequest, ListBmpResponse]{ClientStream: stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type GoBgpService_ListBmpClient = grpc.ServerStreamingClient[ListBmpResponse]

func (c *goBgpServiceClient) SetLogLevel(ctx context.Context, in *SetLogLevelRequest, opts ...grpc.CallOption) (*SetLogLevelResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(SetLogLevelResponse)
	err := c.cc.Invoke(ctx, GoBgpService_SetLogLevel_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// GoBgpServiceServer is the server API for GoBgpService service.
// All implementations must embed UnimplementedGoBgpServiceServer
// for forward compatibility.
//
// Interface exported by the server.
type GoBgpServiceServer interface {
	StartBgp(context.Context, *StartBgpRequest) (*StartBgpResponse, error)
	StopBgp(context.Context, *StopBgpRequest) (*StopBgpResponse, error)
	GetBgp(context.Context, *GetBgpRequest) (*GetBgpResponse, error)
	WatchEvent(*WatchEventRequest, grpc.ServerStreamingServer[WatchEventResponse]) error
	AddPeer(context.Context, *AddPeerRequest) (*AddPeerResponse, error)
	DeletePeer(context.Context, *DeletePeerRequest) (*DeletePeerResponse, error)
	ListPeer(*ListPeerRequest, grpc.ServerStreamingServer[ListPeerResponse]) error
	UpdatePeer(context.Context, *UpdatePeerRequest) (*UpdatePeerResponse, error)
	ResetPeer(context.Context, *ResetPeerRequest) (*ResetPeerResponse, error)
	ShutdownPeer(context.Context, *ShutdownPeerRequest) (*ShutdownPeerResponse, error)
	EnablePeer(context.Context, *EnablePeerRequest) (*EnablePeerResponse, error)
	DisablePeer(context.Context, *DisablePeerRequest) (*DisablePeerResponse, error)
	AddPeerGroup(context.Context, *AddPeerGroupRequest) (*AddPeerGroupResponse, error)
	DeletePeerGroup(context.Context, *DeletePeerGroupRequest) (*DeletePeerGroupResponse, error)
	ListPeerGroup(*ListPeerGroupRequest, grpc.ServerStreamingServer[ListPeerGroupResponse]) error
	UpdatePeerGroup(context.Context, *UpdatePeerGroupRequest) (*UpdatePeerGroupResponse, error)
	AddDynamicNeighbor(context.Context, *AddDynamicNeighborRequest) (*AddDynamicNeighborResponse, error)
	ListDynamicNeighbor(*ListDynamicNeighborRequest, grpc.ServerStreamingServer[ListDynamicNeighborResponse]) error
	DeleteDynamicNeighbor(context.Context, *DeleteDynamicNeighborRequest) (*DeleteDynamicNeighborResponse, error)
	AddPath(context.Context, *AddPathRequest) (*AddPathResponse, error)
	DeletePath(context.Context, *DeletePathRequest) (*DeletePathResponse, error)
	ListPath(*ListPathRequest, grpc.ServerStreamingServer[ListPathResponse]) error
	AddPathStream(grpc.ClientStreamingServer[AddPathStreamRequest, AddPathStreamResponse]) error
	GetTable(context.Context, *GetTableRequest) (*GetTableResponse, error)
	AddVrf(context.Context, *AddVrfRequest) (*AddVrfResponse, error)
	DeleteVrf(context.Context, *DeleteVrfRequest) (*DeleteVrfResponse, error)
	ListVrf(*ListVrfRequest, grpc.ServerStreamingServer[ListVrfResponse]) error
	AddPolicy(context.Context, *AddPolicyRequest) (*AddPolicyResponse, error)
	DeletePolicy(context.Context, *DeletePolicyRequest) (*DeletePolicyResponse, error)
	ListPolicy(*ListPolicyRequest, grpc.ServerStreamingServer[ListPolicyResponse]) error
	SetPolicies(context.Context, *SetPoliciesRequest) (*SetPoliciesResponse, error)
	AddDefinedSet(context.Context, *AddDefinedSetRequest) (*AddDefinedSetResponse, error)
	DeleteDefinedSet(context.Context, *DeleteDefinedSetRequest) (*DeleteDefinedSetResponse, error)
	ListDefinedSet(*ListDefinedSetRequest, grpc.ServerStreamingServer[ListDefinedSetResponse]) error
	AddStatement(context.Context, *AddStatementRequest) (*AddStatementResponse, error)
	DeleteStatement(context.Context, *DeleteStatementRequest) (*DeleteStatementResponse, error)
	ListStatement(*ListStatementRequest, grpc.ServerStreamingServer[ListStatementResponse]) error
	AddPolicyAssignment(context.Context, *AddPolicyAssignmentRequest) (*AddPolicyAssignmentResponse, error)
	DeletePolicyAssignment(context.Context, *DeletePolicyAssignmentRequest) (*DeletePolicyAssignmentResponse, error)
	ListPolicyAssignment(*ListPolicyAssignmentRequest, grpc.ServerStreamingServer[ListPolicyAssignmentResponse]) error
	SetPolicyAssignment(context.Context, *SetPolicyAssignmentRequest) (*SetPolicyAssignmentResponse, error)
	AddRpki(context.Context, *AddRpkiRequest) (*AddRpkiResponse, error)
	DeleteRpki(context.Context, *DeleteRpkiRequest) (*DeleteRpkiResponse, error)
	ListRpki(*ListRpkiRequest, grpc.ServerStreamingServer[ListRpkiResponse]) error
	EnableRpki(context.Context, *EnableRpkiRequest) (*EnableRpkiResponse, error)
	DisableRpki(context.Context, *DisableRpkiRequest) (*DisableRpkiResponse, error)
	ResetRpki(context.Context, *ResetRpkiRequest) (*ResetRpkiResponse, error)
	ListRpkiTable(*ListRpkiTableRequest, grpc.ServerStreamingServer[ListRpkiTableResponse]) error
	EnableZebra(context.Context, *EnableZebraRequest) (*EnableZebraResponse, error)
	EnableMrt(context.Context, *EnableMrtRequest) (*EnableMrtResponse, error)
	DisableMrt(context.Context, *DisableMrtRequest) (*DisableMrtResponse, error)
	AddBmp(context.Context, *AddBmpRequest) (*AddBmpResponse, error)
	DeleteBmp(context.Context, *DeleteBmpRequest) (*DeleteBmpResponse, error)
	ListBmp(*ListBmpRequest, grpc.ServerStreamingServer[ListBmpResponse]) error
	SetLogLevel(context.Context, *SetLogLevelRequest) (*SetLogLevelResponse, error)
	mustEmbedUnimplementedGoBgpServiceServer()
}

// UnimplementedGoBgpServiceServer 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 UnimplementedGoBgpServiceServer struct{}

func (UnimplementedGoBgpServiceServer) StartBgp(context.Context, *StartBgpRequest) (*StartBgpResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StartBgp not implemented")
}
func (UnimplementedGoBgpServiceServer) StopBgp(context.Context, *StopBgpRequest) (*StopBgpResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StopBgp not implemented")
}
func (UnimplementedGoBgpServiceServer) GetBgp(context.Context, *GetBgpRequest) (*GetBgpResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetBgp not implemented")
}
func (UnimplementedGoBgpServiceServer) WatchEvent(*WatchEventRequest, grpc.ServerStreamingServer[WatchEventResponse]) error {
	return status.Errorf(codes.Unimplemented, "method WatchEvent not implemented")
}
func (UnimplementedGoBgpServiceServer) AddPeer(context.Context, *AddPeerRequest) (*AddPeerResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddPeer not implemented")
}
func (UnimplementedGoBgpServiceServer) DeletePeer(context.Context, *DeletePeerRequest) (*DeletePeerResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeletePeer not implemented")
}
func (UnimplementedGoBgpServiceServer) ListPeer(*ListPeerRequest, grpc.ServerStreamingServer[ListPeerResponse]) error {
	return status.Errorf(codes.Unimplemented, "method ListPeer not implemented")
}
func (UnimplementedGoBgpServiceServer) UpdatePeer(context.Context, *UpdatePeerRequest) (*UpdatePeerResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdatePeer not implemented")
}
func (UnimplementedGoBgpServiceServer) ResetPeer(context.Context, *ResetPeerRequest) (*ResetPeerResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ResetPeer not implemented")
}
func (UnimplementedGoBgpServiceServer) ShutdownPeer(context.Context, *ShutdownPeerRequest) (*ShutdownPeerResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ShutdownPeer not implemented")
}
func (UnimplementedGoBgpServiceServer) EnablePeer(context.Context, *EnablePeerRequest) (*EnablePeerResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method EnablePeer not implemented")
}
func (UnimplementedGoBgpServiceServer) DisablePeer(context.Context, *DisablePeerRequest) (*DisablePeerResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DisablePeer not implemented")
}
func (UnimplementedGoBgpServiceServer) AddPeerGroup(context.Context, *AddPeerGroupRequest) (*AddPeerGroupResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddPeerGroup not implemented")
}
func (UnimplementedGoBgpServiceServer) DeletePeerGroup(context.Context, *DeletePeerGroupRequest) (*DeletePeerGroupResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeletePeerGroup not implemented")
}
func (UnimplementedGoBgpServiceServer) ListPeerGroup(*ListPeerGroupRequest, grpc.ServerStreamingServer[ListPeerGroupResponse]) error {
	return status.Errorf(codes.Unimplemented, "method ListPeerGroup not implemented")
}
func (UnimplementedGoBgpServiceServer) UpdatePeerGroup(context.Context, *UpdatePeerGroupRequest) (*UpdatePeerGroupResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdatePeerGroup not implemented")
}
func (UnimplementedGoBgpServiceServer) AddDynamicNeighbor(context.Context, *AddDynamicNeighborRequest) (*AddDynamicNeighborResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddDynamicNeighbor not implemented")
}
func (UnimplementedGoBgpServiceServer) ListDynamicNeighbor(*ListDynamicNeighborRequest, grpc.ServerStreamingServer[ListDynamicNeighborResponse]) error {
	return status.Errorf(codes.Unimplemented, "method ListDynamicNeighbor not implemented")
}
func (UnimplementedGoBgpServiceServer) DeleteDynamicNeighbor(context.Context, *DeleteDynamicNeighborRequest) (*DeleteDynamicNeighborResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteDynamicNeighbor not implemented")
}
func (UnimplementedGoBgpServiceServer) AddPath(context.Context, *AddPathRequest) (*AddPathResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddPath not implemented")
}
func (UnimplementedGoBgpServiceServer) DeletePath(context.Context, *DeletePathRequest) (*DeletePathResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeletePath not implemented")
}
func (UnimplementedGoBgpServiceServer) ListPath(*ListPathRequest, grpc.ServerStreamingServer[ListPathResponse]) error {
	return status.Errorf(codes.Unimplemented, "method ListPath not implemented")
}
func (UnimplementedGoBgpServiceServer) AddPathStream(grpc.ClientStreamingServer[AddPathStreamRequest, AddPathStreamResponse]) error {
	return status.Errorf(codes.Unimplemented, "method AddPathStream not implemented")
}
func (UnimplementedGoBgpServiceServer) GetTable(context.Context, *GetTableRequest) (*GetTableResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetTable not implemented")
}
func (UnimplementedGoBgpServiceServer) AddVrf(context.Context, *AddVrfRequest) (*AddVrfResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddVrf not implemented")
}
func (UnimplementedGoBgpServiceServer) DeleteVrf(context.Context, *DeleteVrfRequest) (*DeleteVrfResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteVrf not implemented")
}
func (UnimplementedGoBgpServiceServer) ListVrf(*ListVrfRequest, grpc.ServerStreamingServer[ListVrfResponse]) error {
	return status.Errorf(codes.Unimplemented, "method ListVrf not implemented")
}
func (UnimplementedGoBgpServiceServer) AddPolicy(context.Context, *AddPolicyRequest) (*AddPolicyResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddPolicy not implemented")
}
func (UnimplementedGoBgpServiceServer) DeletePolicy(context.Context, *DeletePolicyRequest) (*DeletePolicyResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeletePolicy not implemented")
}
func (UnimplementedGoBgpServiceServer) ListPolicy(*ListPolicyRequest, grpc.ServerStreamingServer[ListPolicyResponse]) error {
	return status.Errorf(codes.Unimplemented, "method ListPolicy not implemented")
}
func (UnimplementedGoBgpServiceServer) SetPolicies(context.Context, *SetPoliciesRequest) (*SetPoliciesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetPolicies not implemented")
}
func (UnimplementedGoBgpServiceServer) AddDefinedSet(context.Context, *AddDefinedSetRequest) (*AddDefinedSetResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddDefinedSet not implemented")
}
func (UnimplementedGoBgpServiceServer) DeleteDefinedSet(context.Context, *DeleteDefinedSetRequest) (*DeleteDefinedSetResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteDefinedSet not implemented")
}
func (UnimplementedGoBgpServiceServer) ListDefinedSet(*ListDefinedSetRequest, grpc.ServerStreamingServer[ListDefinedSetResponse]) error {
	return status.Errorf(codes.Unimplemented, "method ListDefinedSet not implemented")
}
func (UnimplementedGoBgpServiceServer) AddStatement(context.Context, *AddStatementRequest) (*AddStatementResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddStatement not implemented")
}
func (UnimplementedGoBgpServiceServer) DeleteStatement(context.Context, *DeleteStatementRequest) (*DeleteStatementResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteStatement not implemented")
}
func (UnimplementedGoBgpServiceServer) ListStatement(*ListStatementRequest, grpc.ServerStreamingServer[ListStatementResponse]) error {
	return status.Errorf(codes.Unimplemented, "method ListStatement not implemented")
}
func (UnimplementedGoBgpServiceServer) AddPolicyAssignment(context.Context, *AddPolicyAssignmentRequest) (*AddPolicyAssignmentResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddPolicyAssignment not implemented")
}
func (UnimplementedGoBgpServiceServer) DeletePolicyAssignment(context.Context, *DeletePolicyAssignmentRequest) (*DeletePolicyAssignmentResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeletePolicyAssignment not implemented")
}
func (UnimplementedGoBgpServiceServer) ListPolicyAssignment(*ListPolicyAssignmentRequest, grpc.ServerStreamingServer[ListPolicyAssignmentResponse]) error {
	return status.Errorf(codes.Unimplemented, "method ListPolicyAssignment not implemented")
}
func (UnimplementedGoBgpServiceServer) SetPolicyAssignment(context.Context, *SetPolicyAssignmentRequest) (*SetPolicyAssignmentResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetPolicyAssignment not implemented")
}
func (UnimplementedGoBgpServiceServer) AddRpki(context.Context, *AddRpkiRequest) (*AddRpkiResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddRpki not implemented")
}
func (UnimplementedGoBgpServiceServer) DeleteRpki(context.Context, *DeleteRpkiRequest) (*DeleteRpkiResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteRpki not implemented")
}
func (UnimplementedGoBgpServiceServer) ListRpki(*ListRpkiRequest, grpc.ServerStreamingServer[ListRpkiResponse]) error {
	return status.Errorf(codes.Unimplemented, "method ListRpki not implemented")
}
func (UnimplementedGoBgpServiceServer) EnableRpki(context.Context, *EnableRpkiRequest) (*EnableRpkiResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method EnableRpki not implemented")
}
func (UnimplementedGoBgpServiceServer) DisableRpki(context.Context, *DisableRpkiRequest) (*DisableRpkiResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DisableRpki not implemented")
}
func (UnimplementedGoBgpServiceServer) ResetRpki(context.Context, *ResetRpkiRequest) (*ResetRpkiResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ResetRpki not implemented")
}
func (UnimplementedGoBgpServiceServer) ListRpkiTable(*ListRpkiTableRequest, grpc.ServerStreamingServer[ListRpkiTableResponse]) error {
	return status.Errorf(codes.Unimplemented, "method ListRpkiTable not implemented")
}
func (UnimplementedGoBgpServiceServer) EnableZebra(context.Context, *EnableZebraRequest) (*EnableZebraResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method EnableZebra not implemented")
}
func (UnimplementedGoBgpServiceServer) EnableMrt(context.Context, *EnableMrtRequest) (*EnableMrtResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method EnableMrt not implemented")
}
func (UnimplementedGoBgpServiceServer) DisableMrt(context.Context, *DisableMrtRequest) (*DisableMrtResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DisableMrt not implemented")
}
func (UnimplementedGoBgpServiceServer) AddBmp(context.Context, *AddBmpRequest) (*AddBmpResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddBmp not implemented")
}
func (UnimplementedGoBgpServiceServer) DeleteBmp(context.Context, *DeleteBmpRequest) (*DeleteBmpResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteBmp not implemented")
}
func (UnimplementedGoBgpServiceServer) ListBmp(*ListBmpRequest, grpc.ServerStreamingServer[ListBmpResponse]) error {
	return status.Errorf(codes.Unimplemented, "method ListBmp not implemented")
}
func (UnimplementedGoBgpServiceServer) SetLogLevel(context.Context, *SetLogLevelRequest) (*SetLogLevelResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetLogLevel not implemented")
}
func (UnimplementedGoBgpServiceServer) mustEmbedUnimplementedGoBgpServiceServer() {}
func (UnimplementedGoBgpServiceServer) testEmbeddedByValue()                      {}

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

func RegisterGoBgpServiceServer(s grpc.ServiceRegistrar, srv GoBgpServiceServer) {
	// If the following call pancis, it indicates UnimplementedGoBgpServiceServer 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(&GoBgpService_ServiceDesc, srv)
}

func _GoBgpService_StartBgp_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StartBgpRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoBgpServiceServer).StartBgp(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoBgpService_StartBgp_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoBgpServiceServer).StartBgp(ctx, req.(*StartBgpRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoBgpService_StopBgp_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StopBgpRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoBgpServiceServer).StopBgp(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoBgpService_StopBgp_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoBgpServiceServer).StopBgp(ctx, req.(*StopBgpRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoBgpService_GetBgp_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetBgpRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoBgpServiceServer).GetBgp(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoBgpService_GetBgp_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoBgpServiceServer).GetBgp(ctx, req.(*GetBgpRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoBgpService_WatchEvent_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WatchEventRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(GoBgpServiceServer).WatchEvent(m, &grpc.GenericServerStream[WatchEventRequest, WatchEventResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type GoBgpService_WatchEventServer = grpc.ServerStreamingServer[WatchEventResponse]

func _GoBgpService_AddPeer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddPeerRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoBgpServiceServer).AddPeer(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoBgpService_AddPeer_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoBgpServiceServer).AddPeer(ctx, req.(*AddPeerRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoBgpService_DeletePeer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeletePeerRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoBgpServiceServer).DeletePeer(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoBgpService_DeletePeer_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoBgpServiceServer).DeletePeer(ctx, req.(*DeletePeerRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoBgpService_ListPeer_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ListPeerRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(GoBgpServiceServer).ListPeer(m, &grpc.GenericServerStream[ListPeerRequest, ListPeerResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type GoBgpService_ListPeerServer = grpc.ServerStreamingServer[ListPeerResponse]

func _GoBgpService_UpdatePeer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdatePeerRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoBgpServiceServer).UpdatePeer(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoBgpService_UpdatePeer_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoBgpServiceServer).UpdatePeer(ctx, req.(*UpdatePeerRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoBgpService_ResetPeer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ResetPeerRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoBgpServiceServer).ResetPeer(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoBgpService_ResetPeer_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoBgpServiceServer).ResetPeer(ctx, req.(*ResetPeerRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoBgpService_ShutdownPeer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ShutdownPeerRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoBgpServiceServer).ShutdownPeer(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoBgpService_ShutdownPeer_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoBgpServiceServer).ShutdownPeer(ctx, req.(*ShutdownPeerRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoBgpService_EnablePeer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EnablePeerRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoBgpServiceServer).EnablePeer(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoBgpService_EnablePeer_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoBgpServiceServer).EnablePeer(ctx, req.(*EnablePeerRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoBgpService_DisablePeer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DisablePeerRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoBgpServiceServer).DisablePeer(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoBgpService_DisablePeer_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoBgpServiceServer).DisablePeer(ctx, req.(*DisablePeerRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoBgpService_AddPeerGroup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddPeerGroupRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoBgpServiceServer).AddPeerGroup(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoBgpService_AddPeerGroup_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoBgpServiceServer).AddPeerGroup(ctx, req.(*AddPeerGroupRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoBgpService_DeletePeerGroup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeletePeerGroupRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoBgpServiceServer).DeletePeerGroup(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoBgpService_DeletePeerGroup_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoBgpServiceServer).DeletePeerGroup(ctx, req.(*DeletePeerGroupRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoBgpService_ListPeerGroup_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ListPeerGroupRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(GoBgpServiceServer).ListPeerGroup(m, &grpc.GenericServerStream[ListPeerGroupRequest, ListPeerGroupResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type GoBgpService_ListPeerGroupServer = grpc.ServerStreamingServer[ListPeerGroupResponse]

func _GoBgpService_UpdatePeerGroup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdatePeerGroupRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoBgpServiceServer).UpdatePeerGroup(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoBgpService_UpdatePeerGroup_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoBgpServiceServer).UpdatePeerGroup(ctx, req.(*UpdatePeerGroupRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoBgpService_AddDynamicNeighbor_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddDynamicNeighborRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoBgpServiceServer).AddDynamicNeighbor(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoBgpService_AddDynamicNeighbor_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoBgpServiceServer).AddDynamicNeighbor(ctx, req.(*AddDynamicNeighborRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoBgpService_ListDynamicNeighbor_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ListDynamicNeighborRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(GoBgpServiceServer).ListDynamicNeighbor(m, &grpc.GenericServerStream[ListDynamicNeighborRequest, ListDynamicNeighborResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type GoBgpService_ListDynamicNeighborServer = grpc.ServerStreamingServer[ListDynamicNeighborResponse]

func _GoBgpService_DeleteDynamicNeighbor_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteDynamicNeighborRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoBgpServiceServer).DeleteDynamicNeighbor(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoBgpService_DeleteDynamicNeighbor_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoBgpServiceServer).DeleteDynamicNeighbor(ctx, req.(*DeleteDynamicNeighborRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoBgpService_AddPath_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddPathRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoBgpServiceServer).AddPath(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoBgpService_AddPath_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoBgpServiceServer).AddPath(ctx, req.(*AddPathRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoBgpService_DeletePath_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeletePathRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoBgpServiceServer).DeletePath(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoBgpService_DeletePath_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoBgpServiceServer).DeletePath(ctx, req.(*DeletePathRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoBgpService_ListPath_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ListPathRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(GoBgpServiceServer).ListPath(m, &grpc.GenericServerStream[ListPathRequest, ListPathResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type GoBgpService_ListPathServer = grpc.ServerStreamingServer[ListPathResponse]

func _GoBgpService_AddPathStream_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(GoBgpServiceServer).AddPathStream(&grpc.GenericServerStream[AddPathStreamRequest, AddPathStreamResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type GoBgpService_AddPathStreamServer = grpc.ClientStreamingServer[AddPathStreamRequest, AddPathStreamResponse]

func _GoBgpService_GetTable_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetTableRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoBgpServiceServer).GetTable(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoBgpService_GetTable_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoBgpServiceServer).GetTable(ctx, req.(*GetTableRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoBgpService_AddVrf_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddVrfRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoBgpServiceServer).AddVrf(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoBgpService_AddVrf_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoBgpServiceServer).AddVrf(ctx, req.(*AddVrfRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoBgpService_DeleteVrf_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteVrfRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoBgpServiceServer).DeleteVrf(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoBgpService_DeleteVrf_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoBgpServiceServer).DeleteVrf(ctx, req.(*DeleteVrfRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoBgpService_ListVrf_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ListVrfRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(GoBgpServiceServer).ListVrf(m, &grpc.GenericServerStream[ListVrfRequest, ListVrfResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type GoBgpService_ListVrfServer = grpc.ServerStreamingServer[ListVrfResponse]

func _GoBgpService_AddPolicy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddPolicyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoBgpServiceServer).AddPolicy(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoBgpService_AddPolicy_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoBgpServiceServer).AddPolicy(ctx, req.(*AddPolicyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoBgpService_DeletePolicy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeletePolicyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoBgpServiceServer).DeletePolicy(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoBgpService_DeletePolicy_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoBgpServiceServer).DeletePolicy(ctx, req.(*DeletePolicyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoBgpService_ListPolicy_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ListPolicyRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(GoBgpServiceServer).ListPolicy(m, &grpc.GenericServerStream[ListPolicyRequest, ListPolicyResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type GoBgpService_ListPolicyServer = grpc.ServerStreamingServer[ListPolicyResponse]

func _GoBgpService_SetPolicies_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetPoliciesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoBgpServiceServer).SetPolicies(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoBgpService_SetPolicies_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoBgpServiceServer).SetPolicies(ctx, req.(*SetPoliciesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoBgpService_AddDefinedSet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddDefinedSetRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoBgpServiceServer).AddDefinedSet(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoBgpService_AddDefinedSet_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoBgpServiceServer).AddDefinedSet(ctx, req.(*AddDefinedSetRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoBgpService_DeleteDefinedSet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteDefinedSetRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoBgpServiceServer).DeleteDefinedSet(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoBgpService_DeleteDefinedSet_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoBgpServiceServer).DeleteDefinedSet(ctx, req.(*DeleteDefinedSetRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoBgpService_ListDefinedSet_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ListDefinedSetRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(GoBgpServiceServer).ListDefinedSet(m, &grpc.GenericServerStream[ListDefinedSetRequest, ListDefinedSetResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type GoBgpService_ListDefinedSetServer = grpc.ServerStreamingServer[ListDefinedSetResponse]

func _GoBgpService_AddStatement_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddStatementRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoBgpServiceServer).AddStatement(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoBgpService_AddStatement_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoBgpServiceServer).AddStatement(ctx, req.(*AddStatementRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoBgpService_DeleteStatement_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteStatementRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoBgpServiceServer).DeleteStatement(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoBgpService_DeleteStatement_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoBgpServiceServer).DeleteStatement(ctx, req.(*DeleteStatementRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoBgpService_ListStatement_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ListStatementRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(GoBgpServiceServer).ListStatement(m, &grpc.GenericServerStream[ListStatementRequest, ListStatementResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type GoBgpService_ListStatementServer = grpc.ServerStreamingServer[ListStatementResponse]

func _GoBgpService_AddPolicyAssignment_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddPolicyAssignmentRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoBgpServiceServer).AddPolicyAssignment(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoBgpService_AddPolicyAssignment_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoBgpServiceServer).AddPolicyAssignment(ctx, req.(*AddPolicyAssignmentRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoBgpService_DeletePolicyAssignment_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeletePolicyAssignmentRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoBgpServiceServer).DeletePolicyAssignment(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoBgpService_DeletePolicyAssignment_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoBgpServiceServer).DeletePolicyAssignment(ctx, req.(*DeletePolicyAssignmentRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoBgpService_ListPolicyAssignment_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ListPolicyAssignmentRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(GoBgpServiceServer).ListPolicyAssignment(m, &grpc.GenericServerStream[ListPolicyAssignmentRequest, ListPolicyAssignmentResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type GoBgpService_ListPolicyAssignmentServer = grpc.ServerStreamingServer[ListPolicyAssignmentResponse]

func _GoBgpService_SetPolicyAssignment_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetPolicyAssignmentRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoBgpServiceServer).SetPolicyAssignment(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoBgpService_SetPolicyAssignment_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoBgpServiceServer).SetPolicyAssignment(ctx, req.(*SetPolicyAssignmentRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoBgpService_AddRpki_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddRpkiRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoBgpServiceServer).AddRpki(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoBgpService_AddRpki_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoBgpServiceServer).AddRpki(ctx, req.(*AddRpkiRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoBgpService_DeleteRpki_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteRpkiRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoBgpServiceServer).DeleteRpki(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoBgpService_DeleteRpki_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoBgpServiceServer).DeleteRpki(ctx, req.(*DeleteRpkiRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoBgpService_ListRpki_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ListRpkiRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(GoBgpServiceServer).ListRpki(m, &grpc.GenericServerStream[ListRpkiRequest, ListRpkiResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type GoBgpService_ListRpkiServer = grpc.ServerStreamingServer[ListRpkiResponse]

func _GoBgpService_EnableRpki_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EnableRpkiRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoBgpServiceServer).EnableRpki(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoBgpService_EnableRpki_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoBgpServiceServer).EnableRpki(ctx, req.(*EnableRpkiRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoBgpService_DisableRpki_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DisableRpkiRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoBgpServiceServer).DisableRpki(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoBgpService_DisableRpki_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoBgpServiceServer).DisableRpki(ctx, req.(*DisableRpkiRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoBgpService_ResetRpki_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ResetRpkiRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoBgpServiceServer).ResetRpki(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoBgpService_ResetRpki_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoBgpServiceServer).ResetRpki(ctx, req.(*ResetRpkiRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoBgpService_ListRpkiTable_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ListRpkiTableRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(GoBgpServiceServer).ListRpkiTable(m, &grpc.GenericServerStream[ListRpkiTableRequest, ListRpkiTableResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type GoBgpService_ListRpkiTableServer = grpc.ServerStreamingServer[ListRpkiTableResponse]

func _GoBgpService_EnableZebra_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EnableZebraRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoBgpServiceServer).EnableZebra(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoBgpService_EnableZebra_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoBgpServiceServer).EnableZebra(ctx, req.(*EnableZebraRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoBgpService_EnableMrt_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EnableMrtRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoBgpServiceServer).EnableMrt(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoBgpService_EnableMrt_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoBgpServiceServer).EnableMrt(ctx, req.(*EnableMrtRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoBgpService_DisableMrt_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DisableMrtRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoBgpServiceServer).DisableMrt(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoBgpService_DisableMrt_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoBgpServiceServer).DisableMrt(ctx, req.(*DisableMrtRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoBgpService_AddBmp_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddBmpRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoBgpServiceServer).AddBmp(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoBgpService_AddBmp_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoBgpServiceServer).AddBmp(ctx, req.(*AddBmpRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoBgpService_DeleteBmp_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteBmpRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoBgpServiceServer).DeleteBmp(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoBgpService_DeleteBmp_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoBgpServiceServer).DeleteBmp(ctx, req.(*DeleteBmpRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoBgpService_ListBmp_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ListBmpRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(GoBgpServiceServer).ListBmp(m, &grpc.GenericServerStream[ListBmpRequest, ListBmpResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type GoBgpService_ListBmpServer = grpc.ServerStreamingServer[ListBmpResponse]

func _GoBgpService_SetLogLevel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetLogLevelRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoBgpServiceServer).SetLogLevel(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GoBgpService_SetLogLevel_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoBgpServiceServer).SetLogLevel(ctx, req.(*SetLogLevelRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// GoBgpService_ServiceDesc is the grpc.ServiceDesc for GoBgpService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var GoBgpService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "api.GoBgpService",
	HandlerType: (*GoBgpServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "StartBgp",
			Handler:    _GoBgpService_StartBgp_Handler,
		},
		{
			MethodName: "StopBgp",
			Handler:    _GoBgpService_StopBgp_Handler,
		},
		{
			MethodName: "GetBgp",
			Handler:    _GoBgpService_GetBgp_Handler,
		},
		{
			MethodName: "AddPeer",
			Handler:    _GoBgpService_AddPeer_Handler,
		},
		{
			MethodName: "DeletePeer",
			Handler:    _GoBgpService_DeletePeer_Handler,
		},
		{
			MethodName: "UpdatePeer",
			Handler:    _GoBgpService_UpdatePeer_Handler,
		},
		{
			MethodName: "ResetPeer",
			Handler:    _GoBgpService_ResetPeer_Handler,
		},
		{
			MethodName: "ShutdownPeer",
			Handler:    _GoBgpService_ShutdownPeer_Handler,
		},
		{
			MethodName: "EnablePeer",
			Handler:    _GoBgpService_EnablePeer_Handler,
		},
		{
			MethodName: "DisablePeer",
			Handler:    _GoBgpService_DisablePeer_Handler,
		},
		{
			MethodName: "AddPeerGroup",
			Handler:    _GoBgpService_AddPeerGroup_Handler,
		},
		{
			MethodName: "DeletePeerGroup",
			Handler:    _GoBgpService_DeletePeerGroup_Handler,
		},
		{
			MethodName: "UpdatePeerGroup",
			Handler:    _GoBgpService_UpdatePeerGroup_Handler,
		},
		{
			MethodName: "AddDynamicNeighbor",
			Handler:    _GoBgpService_AddDynamicNeighbor_Handler,
		},
		{
			MethodName: "DeleteDynamicNeighbor",
			Handler:    _GoBgpService_DeleteDynamicNeighbor_Handler,
		},
		{
			MethodName: "AddPath",
			Handler:    _GoBgpService_AddPath_Handler,
		},
		{
			MethodName: "DeletePath",
			Handler:    _GoBgpService_DeletePath_Handler,
		},
		{
			MethodName: "GetTable",
			Handler:    _GoBgpService_GetTable_Handler,
		},
		{
			MethodName: "AddVrf",
			Handler:    _GoBgpService_AddVrf_Handler,
		},
		{
			MethodName: "DeleteVrf",
			Handler:    _GoBgpService_DeleteVrf_Handler,
		},
		{
			MethodName: "AddPolicy",
			Handler:    _GoBgpService_AddPolicy_Handler,
		},
		{
			MethodName: "DeletePolicy",
			Handler:    _GoBgpService_DeletePolicy_Handler,
		},
		{
			MethodName: "SetPolicies",
			Handler:    _GoBgpService_SetPolicies_Handler,
		},
		{
			MethodName: "AddDefinedSet",
			Handler:    _GoBgpService_AddDefinedSet_Handler,
		},
		{
			MethodName: "DeleteDefinedSet",
			Handler:    _GoBgpService_DeleteDefinedSet_Handler,
		},
		{
			MethodName: "AddStatement",
			Handler:    _GoBgpService_AddStatement_Handler,
		},
		{
			MethodName: "DeleteStatement",
			Handler:    _GoBgpService_DeleteStatement_Handler,
		},
		{
			MethodName: "AddPolicyAssignment",
			Handler:    _GoBgpService_AddPolicyAssignment_Handler,
		},
		{
			MethodName: "DeletePolicyAssignment",
			Handler:    _GoBgpService_DeletePolicyAssignment_Handler,
		},
		{
			MethodName: "SetPolicyAssignment",
			Handler:    _GoBgpService_SetPolicyAssignment_Handler,
		},
		{
			MethodName: "AddRpki",
			Handler:    _GoBgpService_AddRpki_Handler,
		},
		{
			MethodName: "DeleteRpki",
			Handler:    _GoBgpService_DeleteRpki_Handler,
		},
		{
			MethodName: "EnableRpki",
			Handler:    _GoBgpService_EnableRpki_Handler,
		},
		{
			MethodName: "DisableRpki",
			Handler:    _GoBgpService_DisableRpki_Handler,
		},
		{
			MethodName: "ResetRpki",
			Handler:    _GoBgpService_ResetRpki_Handler,
		},
		{
			MethodName: "EnableZebra",
			Handler:    _GoBgpService_EnableZebra_Handler,
		},
		{
			MethodName: "EnableMrt",
			Handler:    _GoBgpService_EnableMrt_Handler,
		},
		{
			MethodName: "DisableMrt",
			Handler:    _GoBgpService_DisableMrt_Handler,
		},
		{
			MethodName: "AddBmp",
			Handler:    _GoBgpService_AddBmp_Handler,
		},
		{
			MethodName: "DeleteBmp",
			Handler:    _GoBgpService_DeleteBmp_Handler,
		},
		{
			MethodName: "SetLogLevel",
			Handler:    _GoBgpService_SetLogLevel_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "WatchEvent",
			Handler:       _GoBgpService_WatchEvent_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ListPeer",
			Handler:       _GoBgpService_ListPeer_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ListPeerGroup",
			Handler:       _GoBgpService_ListPeerGroup_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ListDynamicNeighbor",
			Handler:       _GoBgpService_ListDynamicNeighbor_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ListPath",
			Handler:       _GoBgpService_ListPath_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "AddPathStream",
			Handler:       _GoBgpService_AddPathStream_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "ListVrf",
			Handler:       _GoBgpService_ListVrf_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ListPolicy",
			Handler:       _GoBgpService_ListPolicy_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ListDefinedSet",
			Handler:       _GoBgpService_ListDefinedSet_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ListStatement",
			Handler:       _GoBgpService_ListStatement_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ListPolicyAssignment",
			Handler:       _GoBgpService_ListPolicyAssignment_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ListRpki",
			Handler:       _GoBgpService_ListRpki_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ListRpkiTable",
			Handler:       _GoBgpService_ListRpkiTable_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ListBmp",
			Handler:       _GoBgpService_ListBmp_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "api/gobgp.proto",
}
