binapi/nat/nat_rpc.ba.go

   1 // Code generated by GoVPP's binapi-generator. DO NOT EDIT.
   2
   3 package nat
   4
   5 import (
   6         "context"
   7         "fmt"
   8         api "git.fd.io/govpp.git/api"
   9         vpe "git.fd.io/govpp.git/binapi/vpe"
  10         "io"
  11 )
  12
  13 // RPCService defines RPC service  nat.
  14 type RPCService interface {
  15         Nat44AddDelAddressRange(ctx context.Context, in *Nat44AddDelAddressRange) (*Nat44AddDelAddressRangeReply, error)
  16         Nat44AddDelIdentityMapping(ctx context.Context, in *Nat44AddDelIdentityMapping) (*Nat44AddDelIdentityMappingReply, error)
  17         Nat44AddDelInterfaceAddr(ctx context.Context, in *Nat44AddDelInterfaceAddr) (*Nat44AddDelInterfaceAddrReply, error)
  18         Nat44AddDelLbStaticMapping(ctx context.Context, in *Nat44AddDelLbStaticMapping) (*Nat44AddDelLbStaticMappingReply, error)
  19         Nat44AddDelStaticMapping(ctx context.Context, in *Nat44AddDelStaticMapping) (*Nat44AddDelStaticMappingReply, error)
  20         Nat44AddressDump(ctx context.Context, in *Nat44AddressDump) (RPCService_Nat44AddressDumpClient, error)
  21         Nat44DelSession(ctx context.Context, in *Nat44DelSession) (*Nat44DelSessionReply, error)
  22         Nat44DelUser(ctx context.Context, in *Nat44DelUser) (*Nat44DelUserReply, error)
  23         Nat44ForwardingEnableDisable(ctx context.Context, in *Nat44ForwardingEnableDisable) (*Nat44ForwardingEnableDisableReply, error)
  24         Nat44ForwardingIsEnabled(ctx context.Context, in *Nat44ForwardingIsEnabled) (*Nat44ForwardingIsEnabledReply, error)
  25         Nat44IdentityMappingDump(ctx context.Context, in *Nat44IdentityMappingDump) (RPCService_Nat44IdentityMappingDumpClient, error)
  26         Nat44InterfaceAddDelFeature(ctx context.Context, in *Nat44InterfaceAddDelFeature) (*Nat44InterfaceAddDelFeatureReply, error)
  27         Nat44InterfaceAddDelOutputFeature(ctx context.Context, in *Nat44InterfaceAddDelOutputFeature) (*Nat44InterfaceAddDelOutputFeatureReply, error)
  28         Nat44InterfaceAddrDump(ctx context.Context, in *Nat44InterfaceAddrDump) (RPCService_Nat44InterfaceAddrDumpClient, error)
  29         Nat44InterfaceDump(ctx context.Context, in *Nat44InterfaceDump) (RPCService_Nat44InterfaceDumpClient, error)
  30         Nat44InterfaceOutputFeatureDump(ctx context.Context, in *Nat44InterfaceOutputFeatureDump) (RPCService_Nat44InterfaceOutputFeatureDumpClient, error)
  31         Nat44LbStaticMappingAddDelLocal(ctx context.Context, in *Nat44LbStaticMappingAddDelLocal) (*Nat44LbStaticMappingAddDelLocalReply, error)
  32         Nat44LbStaticMappingDump(ctx context.Context, in *Nat44LbStaticMappingDump) (RPCService_Nat44LbStaticMappingDumpClient, error)
  33         Nat44SessionCleanup(ctx context.Context, in *Nat44SessionCleanup) (*Nat44SessionCleanupReply, error)
  34         Nat44SetSessionLimit(ctx context.Context, in *Nat44SetSessionLimit) (*Nat44SetSessionLimitReply, error)
  35         Nat44StaticMappingDump(ctx context.Context, in *Nat44StaticMappingDump) (RPCService_Nat44StaticMappingDumpClient, error)
  36         Nat44UserDump(ctx context.Context, in *Nat44UserDump) (RPCService_Nat44UserDumpClient, error)
  37         Nat44UserSessionDump(ctx context.Context, in *Nat44UserSessionDump) (RPCService_Nat44UserSessionDumpClient, error)
  38         Nat64AddDelInterface(ctx context.Context, in *Nat64AddDelInterface) (*Nat64AddDelInterfaceReply, error)
  39         Nat64AddDelInterfaceAddr(ctx context.Context, in *Nat64AddDelInterfaceAddr) (*Nat64AddDelInterfaceAddrReply, error)
  40         Nat64AddDelPoolAddrRange(ctx context.Context, in *Nat64AddDelPoolAddrRange) (*Nat64AddDelPoolAddrRangeReply, error)
  41         Nat64AddDelPrefix(ctx context.Context, in *Nat64AddDelPrefix) (*Nat64AddDelPrefixReply, error)
  42         Nat64AddDelStaticBib(ctx context.Context, in *Nat64AddDelStaticBib) (*Nat64AddDelStaticBibReply, error)
  43         Nat64BibDump(ctx context.Context, in *Nat64BibDump) (RPCService_Nat64BibDumpClient, error)
  44         Nat64InterfaceDump(ctx context.Context, in *Nat64InterfaceDump) (RPCService_Nat64InterfaceDumpClient, error)
  45         Nat64PoolAddrDump(ctx context.Context, in *Nat64PoolAddrDump) (RPCService_Nat64PoolAddrDumpClient, error)
  46         Nat64PrefixDump(ctx context.Context, in *Nat64PrefixDump) (RPCService_Nat64PrefixDumpClient, error)
  47         Nat64StDump(ctx context.Context, in *Nat64StDump) (RPCService_Nat64StDumpClient, error)
  48         Nat66AddDelInterface(ctx context.Context, in *Nat66AddDelInterface) (*Nat66AddDelInterfaceReply, error)
  49         Nat66AddDelStaticMapping(ctx context.Context, in *Nat66AddDelStaticMapping) (*Nat66AddDelStaticMappingReply, error)
  50         Nat66InterfaceDump(ctx context.Context, in *Nat66InterfaceDump) (RPCService_Nat66InterfaceDumpClient, error)
  51         Nat66StaticMappingDump(ctx context.Context, in *Nat66StaticMappingDump) (RPCService_Nat66StaticMappingDumpClient, error)
  52         NatControlPing(ctx context.Context, in *NatControlPing) (*NatControlPingReply, error)
  53         NatDetAddDelMap(ctx context.Context, in *NatDetAddDelMap) (*NatDetAddDelMapReply, error)
  54         NatDetCloseSessionIn(ctx context.Context, in *NatDetCloseSessionIn) (*NatDetCloseSessionInReply, error)
  55         NatDetCloseSessionOut(ctx context.Context, in *NatDetCloseSessionOut) (*NatDetCloseSessionOutReply, error)
  56         NatDetForward(ctx context.Context, in *NatDetForward) (*NatDetForwardReply, error)
  57         NatDetMapDump(ctx context.Context, in *NatDetMapDump) (RPCService_NatDetMapDumpClient, error)
  58         NatDetReverse(ctx context.Context, in *NatDetReverse) (*NatDetReverseReply, error)
  59         NatDetSessionDump(ctx context.Context, in *NatDetSessionDump) (RPCService_NatDetSessionDumpClient, error)
  60         NatGetAddrAndPortAllocAlg(ctx context.Context, in *NatGetAddrAndPortAllocAlg) (*NatGetAddrAndPortAllocAlgReply, error)
  61         NatGetMssClamping(ctx context.Context, in *NatGetMssClamping) (*NatGetMssClampingReply, error)
  62         NatGetTimeouts(ctx context.Context, in *NatGetTimeouts) (*NatGetTimeoutsReply, error)
  63         NatHaFlush(ctx context.Context, in *NatHaFlush) (*NatHaFlushReply, error)
  64         NatHaGetFailover(ctx context.Context, in *NatHaGetFailover) (*NatHaGetFailoverReply, error)
  65         NatHaGetListener(ctx context.Context, in *NatHaGetListener) (*NatHaGetListenerReply, error)
  66         NatHaResync(ctx context.Context, in *NatHaResync) (*NatHaResyncReply, error)
  67         NatHaSetFailover(ctx context.Context, in *NatHaSetFailover) (*NatHaSetFailoverReply, error)
  68         NatHaSetListener(ctx context.Context, in *NatHaSetListener) (*NatHaSetListenerReply, error)
  69         NatIpfixEnableDisable(ctx context.Context, in *NatIpfixEnableDisable) (*NatIpfixEnableDisableReply, error)
  70         NatSetAddrAndPortAllocAlg(ctx context.Context, in *NatSetAddrAndPortAllocAlg) (*NatSetAddrAndPortAllocAlgReply, error)
  71         NatSetLogLevel(ctx context.Context, in *NatSetLogLevel) (*NatSetLogLevelReply, error)
  72         NatSetMssClamping(ctx context.Context, in *NatSetMssClamping) (*NatSetMssClampingReply, error)
  73         NatSetTimeouts(ctx context.Context, in *NatSetTimeouts) (*NatSetTimeoutsReply, error)
  74         NatSetWorkers(ctx context.Context, in *NatSetWorkers) (*NatSetWorkersReply, error)
  75         NatShowConfig(ctx context.Context, in *NatShowConfig) (*NatShowConfigReply, error)
  76         NatWorkerDump(ctx context.Context, in *NatWorkerDump) (RPCService_NatWorkerDumpClient, error)
  77 }
  78
  79 type serviceClient struct {
  80         conn api.Connection
  81 }
  82
  83 func NewServiceClient(conn api.Connection) RPCService {
  84         return &serviceClient{conn}
  85 }
  86
  87 func (c *serviceClient) Nat44AddDelAddressRange(ctx context.Context, in *Nat44AddDelAddressRange) (*Nat44AddDelAddressRangeReply, error) {
  88         out := new(Nat44AddDelAddressRangeReply)
  89         err := c.conn.Invoke(ctx, in, out)
  90         if err != nil {
  91                 return nil, err
  92         }
  93         return out, nil
  94 }
  95
  96 func (c *serviceClient) Nat44AddDelIdentityMapping(ctx context.Context, in *Nat44AddDelIdentityMapping) (*Nat44AddDelIdentityMappingReply, error) {
  97         out := new(Nat44AddDelIdentityMappingReply)
  98         err := c.conn.Invoke(ctx, in, out)
  99         if err != nil {
 100                 return nil, err
 101         }
 102         return out, nil
 103 }
 104
 105 func (c *serviceClient) Nat44AddDelInterfaceAddr(ctx context.Context, in *Nat44AddDelInterfaceAddr) (*Nat44AddDelInterfaceAddrReply, error) {
 106         out := new(Nat44AddDelInterfaceAddrReply)
 107         err := c.conn.Invoke(ctx, in, out)
 108         if err != nil {
 109                 return nil, err
 110         }
 111         return out, nil
 112 }
 113
 114 func (c *serviceClient) Nat44AddDelLbStaticMapping(ctx context.Context, in *Nat44AddDelLbStaticMapping) (*Nat44AddDelLbStaticMappingReply, error) {
 115         out := new(Nat44AddDelLbStaticMappingReply)
 116         err := c.conn.Invoke(ctx, in, out)
 117         if err != nil {
 118                 return nil, err
 119         }
 120         return out, nil
 121 }
 122
 123 func (c *serviceClient) Nat44AddDelStaticMapping(ctx context.Context, in *Nat44AddDelStaticMapping) (*Nat44AddDelStaticMappingReply, error) {
 124         out := new(Nat44AddDelStaticMappingReply)
 125         err := c.conn.Invoke(ctx, in, out)
 126         if err != nil {
 127                 return nil, err
 128         }
 129         return out, nil
 130 }
 131
 132 func (c *serviceClient) Nat44AddressDump(ctx context.Context, in *Nat44AddressDump) (RPCService_Nat44AddressDumpClient, error) {
 133         stream, err := c.conn.NewStream(ctx)
 134         if err != nil {
 135                 return nil, err
 136         }
 137         x := &serviceClient_Nat44AddressDumpClient{stream}
 138         if err := x.Stream.SendMsg(in); err != nil {
 139                 return nil, err
 140         }
 141         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 142                 return nil, err
 143         }
 144         return x, nil
 145 }
 146
 147 type RPCService_Nat44AddressDumpClient interface {
 148         Recv() (*Nat44AddressDetails, error)
 149         api.Stream
 150 }
 151
 152 type serviceClient_Nat44AddressDumpClient struct {
 153         api.Stream
 154 }
 155
 156 func (c *serviceClient_Nat44AddressDumpClient) Recv() (*Nat44AddressDetails, error) {
 157         msg, err := c.Stream.RecvMsg()
 158         if err != nil {
 159                 return nil, err
 160         }
 161         switch m := msg.(type) {
 162         case *Nat44AddressDetails:
 163                 return m, nil
 164         case *vpe.ControlPingReply:
 165                 return nil, io.EOF
 166         default:
 167                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 168         }
 169 }
 170
 171 func (c *serviceClient) Nat44DelSession(ctx context.Context, in *Nat44DelSession) (*Nat44DelSessionReply, error) {
 172         out := new(Nat44DelSessionReply)
 173         err := c.conn.Invoke(ctx, in, out)
 174         if err != nil {
 175                 return nil, err
 176         }
 177         return out, nil
 178 }
 179
 180 func (c *serviceClient) Nat44DelUser(ctx context.Context, in *Nat44DelUser) (*Nat44DelUserReply, error) {
 181         out := new(Nat44DelUserReply)
 182         err := c.conn.Invoke(ctx, in, out)
 183         if err != nil {
 184                 return nil, err
 185         }
 186         return out, nil
 187 }
 188
 189 func (c *serviceClient) Nat44ForwardingEnableDisable(ctx context.Context, in *Nat44ForwardingEnableDisable) (*Nat44ForwardingEnableDisableReply, error) {
 190         out := new(Nat44ForwardingEnableDisableReply)
 191         err := c.conn.Invoke(ctx, in, out)
 192         if err != nil {
 193                 return nil, err
 194         }
 195         return out, nil
 196 }
 197
 198 func (c *serviceClient) Nat44ForwardingIsEnabled(ctx context.Context, in *Nat44ForwardingIsEnabled) (*Nat44ForwardingIsEnabledReply, error) {
 199         out := new(Nat44ForwardingIsEnabledReply)
 200         err := c.conn.Invoke(ctx, in, out)
 201         if err != nil {
 202                 return nil, err
 203         }
 204         return out, nil
 205 }
 206
 207 func (c *serviceClient) Nat44IdentityMappingDump(ctx context.Context, in *Nat44IdentityMappingDump) (RPCService_Nat44IdentityMappingDumpClient, error) {
 208         stream, err := c.conn.NewStream(ctx)
 209         if err != nil {
 210                 return nil, err
 211         }
 212         x := &serviceClient_Nat44IdentityMappingDumpClient{stream}
 213         if err := x.Stream.SendMsg(in); err != nil {
 214                 return nil, err
 215         }
 216         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 217                 return nil, err
 218         }
 219         return x, nil
 220 }
 221
 222 type RPCService_Nat44IdentityMappingDumpClient interface {
 223         Recv() (*Nat44IdentityMappingDetails, error)
 224         api.Stream
 225 }
 226
 227 type serviceClient_Nat44IdentityMappingDumpClient struct {
 228         api.Stream
 229 }
 230
 231 func (c *serviceClient_Nat44IdentityMappingDumpClient) Recv() (*Nat44IdentityMappingDetails, error) {
 232         msg, err := c.Stream.RecvMsg()
 233         if err != nil {
 234                 return nil, err
 235         }
 236         switch m := msg.(type) {
 237         case *Nat44IdentityMappingDetails:
 238                 return m, nil
 239         case *vpe.ControlPingReply:
 240                 return nil, io.EOF
 241         default:
 242                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 243         }
 244 }
 245
 246 func (c *serviceClient) Nat44InterfaceAddDelFeature(ctx context.Context, in *Nat44InterfaceAddDelFeature) (*Nat44InterfaceAddDelFeatureReply, error) {
 247         out := new(Nat44InterfaceAddDelFeatureReply)
 248         err := c.conn.Invoke(ctx, in, out)
 249         if err != nil {
 250                 return nil, err
 251         }
 252         return out, nil
 253 }
 254
 255 func (c *serviceClient) Nat44InterfaceAddDelOutputFeature(ctx context.Context, in *Nat44InterfaceAddDelOutputFeature) (*Nat44InterfaceAddDelOutputFeatureReply, error) {
 256         out := new(Nat44InterfaceAddDelOutputFeatureReply)
 257         err := c.conn.Invoke(ctx, in, out)
 258         if err != nil {
 259                 return nil, err
 260         }
 261         return out, nil
 262 }
 263
 264 func (c *serviceClient) Nat44InterfaceAddrDump(ctx context.Context, in *Nat44InterfaceAddrDump) (RPCService_Nat44InterfaceAddrDumpClient, error) {
 265         stream, err := c.conn.NewStream(ctx)
 266         if err != nil {
 267                 return nil, err
 268         }
 269         x := &serviceClient_Nat44InterfaceAddrDumpClient{stream}
 270         if err := x.Stream.SendMsg(in); err != nil {
 271                 return nil, err
 272         }
 273         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 274                 return nil, err
 275         }
 276         return x, nil
 277 }
 278
 279 type RPCService_Nat44InterfaceAddrDumpClient interface {
 280         Recv() (*Nat44InterfaceAddrDetails, error)
 281         api.Stream
 282 }
 283
 284 type serviceClient_Nat44InterfaceAddrDumpClient struct {
 285         api.Stream
 286 }
 287
 288 func (c *serviceClient_Nat44InterfaceAddrDumpClient) Recv() (*Nat44InterfaceAddrDetails, error) {
 289         msg, err := c.Stream.RecvMsg()
 290         if err != nil {
 291                 return nil, err
 292         }
 293         switch m := msg.(type) {
 294         case *Nat44InterfaceAddrDetails:
 295                 return m, nil
 296         case *vpe.ControlPingReply:
 297                 return nil, io.EOF
 298         default:
 299                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 300         }
 301 }
 302
 303 func (c *serviceClient) Nat44InterfaceDump(ctx context.Context, in *Nat44InterfaceDump) (RPCService_Nat44InterfaceDumpClient, error) {
 304         stream, err := c.conn.NewStream(ctx)
 305         if err != nil {
 306                 return nil, err
 307         }
 308         x := &serviceClient_Nat44InterfaceDumpClient{stream}
 309         if err := x.Stream.SendMsg(in); err != nil {
 310                 return nil, err
 311         }
 312         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 313                 return nil, err
 314         }
 315         return x, nil
 316 }
 317
 318 type RPCService_Nat44InterfaceDumpClient interface {
 319         Recv() (*Nat44InterfaceDetails, error)
 320         api.Stream
 321 }
 322
 323 type serviceClient_Nat44InterfaceDumpClient struct {
 324         api.Stream
 325 }
 326
 327 func (c *serviceClient_Nat44InterfaceDumpClient) Recv() (*Nat44InterfaceDetails, error) {
 328         msg, err := c.Stream.RecvMsg()
 329         if err != nil {
 330                 return nil, err
 331         }
 332         switch m := msg.(type) {
 333         case *Nat44InterfaceDetails:
 334                 return m, nil
 335         case *vpe.ControlPingReply:
 336                 return nil, io.EOF
 337         default:
 338                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 339         }
 340 }
 341
 342 func (c *serviceClient) Nat44InterfaceOutputFeatureDump(ctx context.Context, in *Nat44InterfaceOutputFeatureDump) (RPCService_Nat44InterfaceOutputFeatureDumpClient, error) {
 343         stream, err := c.conn.NewStream(ctx)
 344         if err != nil {
 345                 return nil, err
 346         }
 347         x := &serviceClient_Nat44InterfaceOutputFeatureDumpClient{stream}
 348         if err := x.Stream.SendMsg(in); err != nil {
 349                 return nil, err
 350         }
 351         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 352                 return nil, err
 353         }
 354         return x, nil
 355 }
 356
 357 type RPCService_Nat44InterfaceOutputFeatureDumpClient interface {
 358         Recv() (*Nat44InterfaceOutputFeatureDetails, error)
 359         api.Stream
 360 }
 361
 362 type serviceClient_Nat44InterfaceOutputFeatureDumpClient struct {
 363         api.Stream
 364 }
 365
 366 func (c *serviceClient_Nat44InterfaceOutputFeatureDumpClient) Recv() (*Nat44InterfaceOutputFeatureDetails, error) {
 367         msg, err := c.Stream.RecvMsg()
 368         if err != nil {
 369                 return nil, err
 370         }
 371         switch m := msg.(type) {
 372         case *Nat44InterfaceOutputFeatureDetails:
 373                 return m, nil
 374         case *vpe.ControlPingReply:
 375                 return nil, io.EOF
 376         default:
 377                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 378         }
 379 }
 380
 381 func (c *serviceClient) Nat44LbStaticMappingAddDelLocal(ctx context.Context, in *Nat44LbStaticMappingAddDelLocal) (*Nat44LbStaticMappingAddDelLocalReply, error) {
 382         out := new(Nat44LbStaticMappingAddDelLocalReply)
 383         err := c.conn.Invoke(ctx, in, out)
 384         if err != nil {
 385                 return nil, err
 386         }
 387         return out, nil
 388 }
 389
 390 func (c *serviceClient) Nat44LbStaticMappingDump(ctx context.Context, in *Nat44LbStaticMappingDump) (RPCService_Nat44LbStaticMappingDumpClient, error) {
 391         stream, err := c.conn.NewStream(ctx)
 392         if err != nil {
 393                 return nil, err
 394         }
 395         x := &serviceClient_Nat44LbStaticMappingDumpClient{stream}
 396         if err := x.Stream.SendMsg(in); err != nil {
 397                 return nil, err
 398         }
 399         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 400                 return nil, err
 401         }
 402         return x, nil
 403 }
 404
 405 type RPCService_Nat44LbStaticMappingDumpClient interface {
 406         Recv() (*Nat44LbStaticMappingDetails, error)
 407         api.Stream
 408 }
 409
 410 type serviceClient_Nat44LbStaticMappingDumpClient struct {
 411         api.Stream
 412 }
 413
 414 func (c *serviceClient_Nat44LbStaticMappingDumpClient) Recv() (*Nat44LbStaticMappingDetails, error) {
 415         msg, err := c.Stream.RecvMsg()
 416         if err != nil {
 417                 return nil, err
 418         }
 419         switch m := msg.(type) {
 420         case *Nat44LbStaticMappingDetails:
 421                 return m, nil
 422         case *vpe.ControlPingReply:
 423                 return nil, io.EOF
 424         default:
 425                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 426         }
 427 }
 428
 429 func (c *serviceClient) Nat44SessionCleanup(ctx context.Context, in *Nat44SessionCleanup) (*Nat44SessionCleanupReply, error) {
 430         out := new(Nat44SessionCleanupReply)
 431         err := c.conn.Invoke(ctx, in, out)
 432         if err != nil {
 433                 return nil, err
 434         }
 435         return out, nil
 436 }
 437
 438 func (c *serviceClient) Nat44SetSessionLimit(ctx context.Context, in *Nat44SetSessionLimit) (*Nat44SetSessionLimitReply, error) {
 439         out := new(Nat44SetSessionLimitReply)
 440         err := c.conn.Invoke(ctx, in, out)
 441         if err != nil {
 442                 return nil, err
 443         }
 444         return out, nil
 445 }
 446
 447 func (c *serviceClient) Nat44StaticMappingDump(ctx context.Context, in *Nat44StaticMappingDump) (RPCService_Nat44StaticMappingDumpClient, error) {
 448         stream, err := c.conn.NewStream(ctx)
 449         if err != nil {
 450                 return nil, err
 451         }
 452         x := &serviceClient_Nat44StaticMappingDumpClient{stream}
 453         if err := x.Stream.SendMsg(in); err != nil {
 454                 return nil, err
 455         }
 456         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 457                 return nil, err
 458         }
 459         return x, nil
 460 }
 461
 462 type RPCService_Nat44StaticMappingDumpClient interface {
 463         Recv() (*Nat44StaticMappingDetails, error)
 464         api.Stream
 465 }
 466
 467 type serviceClient_Nat44StaticMappingDumpClient struct {
 468         api.Stream
 469 }
 470
 471 func (c *serviceClient_Nat44StaticMappingDumpClient) Recv() (*Nat44StaticMappingDetails, error) {
 472         msg, err := c.Stream.RecvMsg()
 473         if err != nil {
 474                 return nil, err
 475         }
 476         switch m := msg.(type) {
 477         case *Nat44StaticMappingDetails:
 478                 return m, nil
 479         case *vpe.ControlPingReply:
 480                 return nil, io.EOF
 481         default:
 482                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 483         }
 484 }
 485
 486 func (c *serviceClient) Nat44UserDump(ctx context.Context, in *Nat44UserDump) (RPCService_Nat44UserDumpClient, error) {
 487         stream, err := c.conn.NewStream(ctx)
 488         if err != nil {
 489                 return nil, err
 490         }
 491         x := &serviceClient_Nat44UserDumpClient{stream}
 492         if err := x.Stream.SendMsg(in); err != nil {
 493                 return nil, err
 494         }
 495         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 496                 return nil, err
 497         }
 498         return x, nil
 499 }
 500
 501 type RPCService_Nat44UserDumpClient interface {
 502         Recv() (*Nat44UserDetails, error)
 503         api.Stream
 504 }
 505
 506 type serviceClient_Nat44UserDumpClient struct {
 507         api.Stream
 508 }
 509
 510 func (c *serviceClient_Nat44UserDumpClient) Recv() (*Nat44UserDetails, error) {
 511         msg, err := c.Stream.RecvMsg()
 512         if err != nil {
 513                 return nil, err
 514         }
 515         switch m := msg.(type) {
 516         case *Nat44UserDetails:
 517                 return m, nil
 518         case *vpe.ControlPingReply:
 519                 return nil, io.EOF
 520         default:
 521                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 522         }
 523 }
 524
 525 func (c *serviceClient) Nat44UserSessionDump(ctx context.Context, in *Nat44UserSessionDump) (RPCService_Nat44UserSessionDumpClient, error) {
 526         stream, err := c.conn.NewStream(ctx)
 527         if err != nil {
 528                 return nil, err
 529         }
 530         x := &serviceClient_Nat44UserSessionDumpClient{stream}
 531         if err := x.Stream.SendMsg(in); err != nil {
 532                 return nil, err
 533         }
 534         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 535                 return nil, err
 536         }
 537         return x, nil
 538 }
 539
 540 type RPCService_Nat44UserSessionDumpClient interface {
 541         Recv() (*Nat44UserSessionDetails, error)
 542         api.Stream
 543 }
 544
 545 type serviceClient_Nat44UserSessionDumpClient struct {
 546         api.Stream
 547 }
 548
 549 func (c *serviceClient_Nat44UserSessionDumpClient) Recv() (*Nat44UserSessionDetails, error) {
 550         msg, err := c.Stream.RecvMsg()
 551         if err != nil {
 552                 return nil, err
 553         }
 554         switch m := msg.(type) {
 555         case *Nat44UserSessionDetails:
 556                 return m, nil
 557         case *vpe.ControlPingReply:
 558                 return nil, io.EOF
 559         default:
 560                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 561         }
 562 }
 563
 564 func (c *serviceClient) Nat64AddDelInterface(ctx context.Context, in *Nat64AddDelInterface) (*Nat64AddDelInterfaceReply, error) {
 565         out := new(Nat64AddDelInterfaceReply)
 566         err := c.conn.Invoke(ctx, in, out)
 567         if err != nil {
 568                 return nil, err
 569         }
 570         return out, nil
 571 }
 572
 573 func (c *serviceClient) Nat64AddDelInterfaceAddr(ctx context.Context, in *Nat64AddDelInterfaceAddr) (*Nat64AddDelInterfaceAddrReply, error) {
 574         out := new(Nat64AddDelInterfaceAddrReply)
 575         err := c.conn.Invoke(ctx, in, out)
 576         if err != nil {
 577                 return nil, err
 578         }
 579         return out, nil
 580 }
 581
 582 func (c *serviceClient) Nat64AddDelPoolAddrRange(ctx context.Context, in *Nat64AddDelPoolAddrRange) (*Nat64AddDelPoolAddrRangeReply, error) {
 583         out := new(Nat64AddDelPoolAddrRangeReply)
 584         err := c.conn.Invoke(ctx, in, out)
 585         if err != nil {
 586                 return nil, err
 587         }
 588         return out, nil
 589 }
 590
 591 func (c *serviceClient) Nat64AddDelPrefix(ctx context.Context, in *Nat64AddDelPrefix) (*Nat64AddDelPrefixReply, error) {
 592         out := new(Nat64AddDelPrefixReply)
 593         err := c.conn.Invoke(ctx, in, out)
 594         if err != nil {
 595                 return nil, err
 596         }
 597         return out, nil
 598 }
 599
 600 func (c *serviceClient) Nat64AddDelStaticBib(ctx context.Context, in *Nat64AddDelStaticBib) (*Nat64AddDelStaticBibReply, error) {
 601         out := new(Nat64AddDelStaticBibReply)
 602         err := c.conn.Invoke(ctx, in, out)
 603         if err != nil {
 604                 return nil, err
 605         }
 606         return out, nil
 607 }
 608
 609 func (c *serviceClient) Nat64BibDump(ctx context.Context, in *Nat64BibDump) (RPCService_Nat64BibDumpClient, error) {
 610         stream, err := c.conn.NewStream(ctx)
 611         if err != nil {
 612                 return nil, err
 613         }
 614         x := &serviceClient_Nat64BibDumpClient{stream}
 615         if err := x.Stream.SendMsg(in); err != nil {
 616                 return nil, err
 617         }
 618         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 619                 return nil, err
 620         }
 621         return x, nil
 622 }
 623
 624 type RPCService_Nat64BibDumpClient interface {
 625         Recv() (*Nat64BibDetails, error)
 626         api.Stream
 627 }
 628
 629 type serviceClient_Nat64BibDumpClient struct {
 630         api.Stream
 631 }
 632
 633 func (c *serviceClient_Nat64BibDumpClient) Recv() (*Nat64BibDetails, error) {
 634         msg, err := c.Stream.RecvMsg()
 635         if err != nil {
 636                 return nil, err
 637         }
 638         switch m := msg.(type) {
 639         case *Nat64BibDetails:
 640                 return m, nil
 641         case *vpe.ControlPingReply:
 642                 return nil, io.EOF
 643         default:
 644                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 645         }
 646 }
 647
 648 func (c *serviceClient) Nat64InterfaceDump(ctx context.Context, in *Nat64InterfaceDump) (RPCService_Nat64InterfaceDumpClient, error) {
 649         stream, err := c.conn.NewStream(ctx)
 650         if err != nil {
 651                 return nil, err
 652         }
 653         x := &serviceClient_Nat64InterfaceDumpClient{stream}
 654         if err := x.Stream.SendMsg(in); err != nil {
 655                 return nil, err
 656         }
 657         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 658                 return nil, err
 659         }
 660         return x, nil
 661 }
 662
 663 type RPCService_Nat64InterfaceDumpClient interface {
 664         Recv() (*Nat64InterfaceDetails, error)
 665         api.Stream
 666 }
 667
 668 type serviceClient_Nat64InterfaceDumpClient struct {
 669         api.Stream
 670 }
 671
 672 func (c *serviceClient_Nat64InterfaceDumpClient) Recv() (*Nat64InterfaceDetails, error) {
 673         msg, err := c.Stream.RecvMsg()
 674         if err != nil {
 675                 return nil, err
 676         }
 677         switch m := msg.(type) {
 678         case *Nat64InterfaceDetails:
 679                 return m, nil
 680         case *vpe.ControlPingReply:
 681                 return nil, io.EOF
 682         default:
 683                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 684         }
 685 }
 686
 687 func (c *serviceClient) Nat64PoolAddrDump(ctx context.Context, in *Nat64PoolAddrDump) (RPCService_Nat64PoolAddrDumpClient, error) {
 688         stream, err := c.conn.NewStream(ctx)
 689         if err != nil {
 690                 return nil, err
 691         }
 692         x := &serviceClient_Nat64PoolAddrDumpClient{stream}
 693         if err := x.Stream.SendMsg(in); err != nil {
 694                 return nil, err
 695         }
 696         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 697                 return nil, err
 698         }
 699         return x, nil
 700 }
 701
 702 type RPCService_Nat64PoolAddrDumpClient interface {
 703         Recv() (*Nat64PoolAddrDetails, error)
 704         api.Stream
 705 }
 706
 707 type serviceClient_Nat64PoolAddrDumpClient struct {
 708         api.Stream
 709 }
 710
 711 func (c *serviceClient_Nat64PoolAddrDumpClient) Recv() (*Nat64PoolAddrDetails, error) {
 712         msg, err := c.Stream.RecvMsg()
 713         if err != nil {
 714                 return nil, err
 715         }
 716         switch m := msg.(type) {
 717         case *Nat64PoolAddrDetails:
 718                 return m, nil
 719         case *vpe.ControlPingReply:
 720                 return nil, io.EOF
 721         default:
 722                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 723         }
 724 }
 725
 726 func (c *serviceClient) Nat64PrefixDump(ctx context.Context, in *Nat64PrefixDump) (RPCService_Nat64PrefixDumpClient, error) {
 727         stream, err := c.conn.NewStream(ctx)
 728         if err != nil {
 729                 return nil, err
 730         }
 731         x := &serviceClient_Nat64PrefixDumpClient{stream}
 732         if err := x.Stream.SendMsg(in); err != nil {
 733                 return nil, err
 734         }
 735         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 736                 return nil, err
 737         }
 738         return x, nil
 739 }
 740
 741 type RPCService_Nat64PrefixDumpClient interface {
 742         Recv() (*Nat64PrefixDetails, error)
 743         api.Stream
 744 }
 745
 746 type serviceClient_Nat64PrefixDumpClient struct {
 747         api.Stream
 748 }
 749
 750 func (c *serviceClient_Nat64PrefixDumpClient) Recv() (*Nat64PrefixDetails, error) {
 751         msg, err := c.Stream.RecvMsg()
 752         if err != nil {
 753                 return nil, err
 754         }
 755         switch m := msg.(type) {
 756         case *Nat64PrefixDetails:
 757                 return m, nil
 758         case *vpe.ControlPingReply:
 759                 return nil, io.EOF
 760         default:
 761                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 762         }
 763 }
 764
 765 func (c *serviceClient) Nat64StDump(ctx context.Context, in *Nat64StDump) (RPCService_Nat64StDumpClient, error) {
 766         stream, err := c.conn.NewStream(ctx)
 767         if err != nil {
 768                 return nil, err
 769         }
 770         x := &serviceClient_Nat64StDumpClient{stream}
 771         if err := x.Stream.SendMsg(in); err != nil {
 772                 return nil, err
 773         }
 774         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 775                 return nil, err
 776         }
 777         return x, nil
 778 }
 779
 780 type RPCService_Nat64StDumpClient interface {
 781         Recv() (*Nat64StDetails, error)
 782         api.Stream
 783 }
 784
 785 type serviceClient_Nat64StDumpClient struct {
 786         api.Stream
 787 }
 788
 789 func (c *serviceClient_Nat64StDumpClient) Recv() (*Nat64StDetails, error) {
 790         msg, err := c.Stream.RecvMsg()
 791         if err != nil {
 792                 return nil, err
 793         }
 794         switch m := msg.(type) {
 795         case *Nat64StDetails:
 796                 return m, nil
 797         case *vpe.ControlPingReply:
 798                 return nil, io.EOF
 799         default:
 800                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 801         }
 802 }
 803
 804 func (c *serviceClient) Nat66AddDelInterface(ctx context.Context, in *Nat66AddDelInterface) (*Nat66AddDelInterfaceReply, error) {
 805         out := new(Nat66AddDelInterfaceReply)
 806         err := c.conn.Invoke(ctx, in, out)
 807         if err != nil {
 808                 return nil, err
 809         }
 810         return out, nil
 811 }
 812
 813 func (c *serviceClient) Nat66AddDelStaticMapping(ctx context.Context, in *Nat66AddDelStaticMapping) (*Nat66AddDelStaticMappingReply, error) {
 814         out := new(Nat66AddDelStaticMappingReply)
 815         err := c.conn.Invoke(ctx, in, out)
 816         if err != nil {
 817                 return nil, err
 818         }
 819         return out, nil
 820 }
 821
 822 func (c *serviceClient) Nat66InterfaceDump(ctx context.Context, in *Nat66InterfaceDump) (RPCService_Nat66InterfaceDumpClient, error) {
 823         stream, err := c.conn.NewStream(ctx)
 824         if err != nil {
 825                 return nil, err
 826         }
 827         x := &serviceClient_Nat66InterfaceDumpClient{stream}
 828         if err := x.Stream.SendMsg(in); err != nil {
 829                 return nil, err
 830         }
 831         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 832                 return nil, err
 833         }
 834         return x, nil
 835 }
 836
 837 type RPCService_Nat66InterfaceDumpClient interface {
 838         Recv() (*Nat66InterfaceDetails, error)
 839         api.Stream
 840 }
 841
 842 type serviceClient_Nat66InterfaceDumpClient struct {
 843         api.Stream
 844 }
 845
 846 func (c *serviceClient_Nat66InterfaceDumpClient) Recv() (*Nat66InterfaceDetails, error) {
 847         msg, err := c.Stream.RecvMsg()
 848         if err != nil {
 849                 return nil, err
 850         }
 851         switch m := msg.(type) {
 852         case *Nat66InterfaceDetails:
 853                 return m, nil
 854         case *vpe.ControlPingReply:
 855                 return nil, io.EOF
 856         default:
 857                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 858         }
 859 }
 860
 861 func (c *serviceClient) Nat66StaticMappingDump(ctx context.Context, in *Nat66StaticMappingDump) (RPCService_Nat66StaticMappingDumpClient, error) {
 862         stream, err := c.conn.NewStream(ctx)
 863         if err != nil {
 864                 return nil, err
 865         }
 866         x := &serviceClient_Nat66StaticMappingDumpClient{stream}
 867         if err := x.Stream.SendMsg(in); err != nil {
 868                 return nil, err
 869         }
 870         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 871                 return nil, err
 872         }
 873         return x, nil
 874 }
 875
 876 type RPCService_Nat66StaticMappingDumpClient interface {
 877         Recv() (*Nat66StaticMappingDetails, error)
 878         api.Stream
 879 }
 880
 881 type serviceClient_Nat66StaticMappingDumpClient struct {
 882         api.Stream
 883 }
 884
 885 func (c *serviceClient_Nat66StaticMappingDumpClient) Recv() (*Nat66StaticMappingDetails, error) {
 886         msg, err := c.Stream.RecvMsg()
 887         if err != nil {
 888                 return nil, err
 889         }
 890         switch m := msg.(type) {
 891         case *Nat66StaticMappingDetails:
 892                 return m, nil
 893         case *vpe.ControlPingReply:
 894                 return nil, io.EOF
 895         default:
 896                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 897         }
 898 }
 899
 900 func (c *serviceClient) NatControlPing(ctx context.Context, in *NatControlPing) (*NatControlPingReply, error) {
 901         out := new(NatControlPingReply)
 902         err := c.conn.Invoke(ctx, in, out)
 903         if err != nil {
 904                 return nil, err
 905         }
 906         return out, nil
 907 }
 908
 909 func (c *serviceClient) NatDetAddDelMap(ctx context.Context, in *NatDetAddDelMap) (*NatDetAddDelMapReply, error) {
 910         out := new(NatDetAddDelMapReply)
 911         err := c.conn.Invoke(ctx, in, out)
 912         if err != nil {
 913                 return nil, err
 914         }
 915         return out, nil
 916 }
 917
 918 func (c *serviceClient) NatDetCloseSessionIn(ctx context.Context, in *NatDetCloseSessionIn) (*NatDetCloseSessionInReply, error) {
 919         out := new(NatDetCloseSessionInReply)
 920         err := c.conn.Invoke(ctx, in, out)
 921         if err != nil {
 922                 return nil, err
 923         }
 924         return out, nil
 925 }
 926
 927 func (c *serviceClient) NatDetCloseSessionOut(ctx context.Context, in *NatDetCloseSessionOut) (*NatDetCloseSessionOutReply, error) {
 928         out := new(NatDetCloseSessionOutReply)
 929         err := c.conn.Invoke(ctx, in, out)
 930         if err != nil {
 931                 return nil, err
 932         }
 933         return out, nil
 934 }
 935
 936 func (c *serviceClient) NatDetForward(ctx context.Context, in *NatDetForward) (*NatDetForwardReply, error) {
 937         out := new(NatDetForwardReply)
 938         err := c.conn.Invoke(ctx, in, out)
 939         if err != nil {
 940                 return nil, err
 941         }
 942         return out, nil
 943 }
 944
 945 func (c *serviceClient) NatDetMapDump(ctx context.Context, in *NatDetMapDump) (RPCService_NatDetMapDumpClient, error) {
 946         stream, err := c.conn.NewStream(ctx)
 947         if err != nil {
 948                 return nil, err
 949         }
 950         x := &serviceClient_NatDetMapDumpClient{stream}
 951         if err := x.Stream.SendMsg(in); err != nil {
 952                 return nil, err
 953         }
 954         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 955                 return nil, err
 956         }
 957         return x, nil
 958 }
 959
 960 type RPCService_NatDetMapDumpClient interface {
 961         Recv() (*NatDetMapDetails, error)
 962         api.Stream
 963 }
 964
 965 type serviceClient_NatDetMapDumpClient struct {
 966         api.Stream
 967 }
 968
 969 func (c *serviceClient_NatDetMapDumpClient) Recv() (*NatDetMapDetails, error) {
 970         msg, err := c.Stream.RecvMsg()
 971         if err != nil {
 972                 return nil, err
 973         }
 974         switch m := msg.(type) {
 975         case *NatDetMapDetails:
 976                 return m, nil
 977         case *vpe.ControlPingReply:
 978                 return nil, io.EOF
 979         default:
 980                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 981         }
 982 }
 983
 984 func (c *serviceClient) NatDetReverse(ctx context.Context, in *NatDetReverse) (*NatDetReverseReply, error) {
 985         out := new(NatDetReverseReply)
 986         err := c.conn.Invoke(ctx, in, out)
 987         if err != nil {
 988                 return nil, err
 989         }
 990         return out, nil
 991 }
 992
 993 func (c *serviceClient) NatDetSessionDump(ctx context.Context, in *NatDetSessionDump) (RPCService_NatDetSessionDumpClient, error) {
 994         stream, err := c.conn.NewStream(ctx)
 995         if err != nil {
 996                 return nil, err
 997         }
 998         x := &serviceClient_NatDetSessionDumpClient{stream}
 999         if err := x.Stream.SendMsg(in); err != nil {
1000                 return nil, err
1001         }
1002         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
1003                 return nil, err
1004         }
1005         return x, nil
1006 }
1007
1008 type RPCService_NatDetSessionDumpClient interface {
1009         Recv() (*NatDetSessionDetails, error)
1010         api.Stream
1011 }
1012
1013 type serviceClient_NatDetSessionDumpClient struct {
1014         api.Stream
1015 }
1016
1017 func (c *serviceClient_NatDetSessionDumpClient) Recv() (*NatDetSessionDetails, error) {
1018         msg, err := c.Stream.RecvMsg()
1019         if err != nil {
1020                 return nil, err
1021         }
1022         switch m := msg.(type) {
1023         case *NatDetSessionDetails:
1024                 return m, nil
1025         case *vpe.ControlPingReply:
1026                 return nil, io.EOF
1027         default:
1028                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
1029         }
1030 }
1031
1032 func (c *serviceClient) NatGetAddrAndPortAllocAlg(ctx context.Context, in *NatGetAddrAndPortAllocAlg) (*NatGetAddrAndPortAllocAlgReply, error) {
1033         out := new(NatGetAddrAndPortAllocAlgReply)
1034         err := c.conn.Invoke(ctx, in, out)
1035         if err != nil {
1036                 return nil, err
1037         }
1038         return out, nil
1039 }
1040
1041 func (c *serviceClient) NatGetMssClamping(ctx context.Context, in *NatGetMssClamping) (*NatGetMssClampingReply, error) {
1042         out := new(NatGetMssClampingReply)
1043         err := c.conn.Invoke(ctx, in, out)
1044         if err != nil {
1045                 return nil, err
1046         }
1047         return out, nil
1048 }
1049
1050 func (c *serviceClient) NatGetTimeouts(ctx context.Context, in *NatGetTimeouts) (*NatGetTimeoutsReply, error) {
1051         out := new(NatGetTimeoutsReply)
1052         err := c.conn.Invoke(ctx, in, out)
1053         if err != nil {
1054                 return nil, err
1055         }
1056         return out, nil
1057 }
1058
1059 func (c *serviceClient) NatHaFlush(ctx context.Context, in *NatHaFlush) (*NatHaFlushReply, error) {
1060         out := new(NatHaFlushReply)
1061         err := c.conn.Invoke(ctx, in, out)
1062         if err != nil {
1063                 return nil, err
1064         }
1065         return out, nil
1066 }
1067
1068 func (c *serviceClient) NatHaGetFailover(ctx context.Context, in *NatHaGetFailover) (*NatHaGetFailoverReply, error) {
1069         out := new(NatHaGetFailoverReply)
1070         err := c.conn.Invoke(ctx, in, out)
1071         if err != nil {
1072                 return nil, err
1073         }
1074         return out, nil
1075 }
1076
1077 func (c *serviceClient) NatHaGetListener(ctx context.Context, in *NatHaGetListener) (*NatHaGetListenerReply, error) {
1078         out := new(NatHaGetListenerReply)
1079         err := c.conn.Invoke(ctx, in, out)
1080         if err != nil {
1081                 return nil, err
1082         }
1083         return out, nil
1084 }
1085
1086 func (c *serviceClient) NatHaResync(ctx context.Context, in *NatHaResync) (*NatHaResyncReply, error) {
1087         out := new(NatHaResyncReply)
1088         err := c.conn.Invoke(ctx, in, out)
1089         if err != nil {
1090                 return nil, err
1091         }
1092         return out, nil
1093 }
1094
1095 func (c *serviceClient) NatHaSetFailover(ctx context.Context, in *NatHaSetFailover) (*NatHaSetFailoverReply, error) {
1096         out := new(NatHaSetFailoverReply)
1097         err := c.conn.Invoke(ctx, in, out)
1098         if err != nil {
1099                 return nil, err
1100         }
1101         return out, nil
1102 }
1103
1104 func (c *serviceClient) NatHaSetListener(ctx context.Context, in *NatHaSetListener) (*NatHaSetListenerReply, error) {
1105         out := new(NatHaSetListenerReply)
1106         err := c.conn.Invoke(ctx, in, out)
1107         if err != nil {
1108                 return nil, err
1109         }
1110         return out, nil
1111 }
1112
1113 func (c *serviceClient) NatIpfixEnableDisable(ctx context.Context, in *NatIpfixEnableDisable) (*NatIpfixEnableDisableReply, error) {
1114         out := new(NatIpfixEnableDisableReply)
1115         err := c.conn.Invoke(ctx, in, out)
1116         if err != nil {
1117                 return nil, err
1118         }
1119         return out, nil
1120 }
1121
1122 func (c *serviceClient) NatSetAddrAndPortAllocAlg(ctx context.Context, in *NatSetAddrAndPortAllocAlg) (*NatSetAddrAndPortAllocAlgReply, error) {
1123         out := new(NatSetAddrAndPortAllocAlgReply)
1124         err := c.conn.Invoke(ctx, in, out)
1125         if err != nil {
1126                 return nil, err
1127         }
1128         return out, nil
1129 }
1130
1131 func (c *serviceClient) NatSetLogLevel(ctx context.Context, in *NatSetLogLevel) (*NatSetLogLevelReply, error) {
1132         out := new(NatSetLogLevelReply)
1133         err := c.conn.Invoke(ctx, in, out)
1134         if err != nil {
1135                 return nil, err
1136         }
1137         return out, nil
1138 }
1139
1140 func (c *serviceClient) NatSetMssClamping(ctx context.Context, in *NatSetMssClamping) (*NatSetMssClampingReply, error) {
1141         out := new(NatSetMssClampingReply)
1142         err := c.conn.Invoke(ctx, in, out)
1143         if err != nil {
1144                 return nil, err
1145         }
1146         return out, nil
1147 }
1148
1149 func (c *serviceClient) NatSetTimeouts(ctx context.Context, in *NatSetTimeouts) (*NatSetTimeoutsReply, error) {
1150         out := new(NatSetTimeoutsReply)
1151         err := c.conn.Invoke(ctx, in, out)
1152         if err != nil {
1153                 return nil, err
1154         }
1155         return out, nil
1156 }
1157
1158 func (c *serviceClient) NatSetWorkers(ctx context.Context, in *NatSetWorkers) (*NatSetWorkersReply, error) {
1159         out := new(NatSetWorkersReply)
1160         err := c.conn.Invoke(ctx, in, out)
1161         if err != nil {
1162                 return nil, err
1163         }
1164         return out, nil
1165 }
1166
1167 func (c *serviceClient) NatShowConfig(ctx context.Context, in *NatShowConfig) (*NatShowConfigReply, error) {
1168         out := new(NatShowConfigReply)
1169         err := c.conn.Invoke(ctx, in, out)
1170         if err != nil {
1171                 return nil, err
1172         }
1173         return out, nil
1174 }
1175
1176 func (c *serviceClient) NatWorkerDump(ctx context.Context, in *NatWorkerDump) (RPCService_NatWorkerDumpClient, error) {
1177         stream, err := c.conn.NewStream(ctx)
1178         if err != nil {
1179                 return nil, err
1180         }
1181         x := &serviceClient_NatWorkerDumpClient{stream}
1182         if err := x.Stream.SendMsg(in); err != nil {
1183                 return nil, err
1184         }
1185         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
1186                 return nil, err
1187         }
1188         return x, nil
1189 }
1190
1191 type RPCService_NatWorkerDumpClient interface {
1192         Recv() (*NatWorkerDetails, error)
1193         api.Stream
1194 }
1195
1196 type serviceClient_NatWorkerDumpClient struct {
1197         api.Stream
1198 }
1199
1200 func (c *serviceClient_NatWorkerDumpClient) Recv() (*NatWorkerDetails, error) {
1201         msg, err := c.Stream.RecvMsg()
1202         if err != nil {
1203                 return nil, err
1204         }
1205         switch m := msg.(type) {
1206         case *NatWorkerDetails:
1207                 return m, nil
1208         case *vpe.ControlPingReply:
1209                 return nil, io.EOF
1210         default:
1211                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
1212         }
1213 }