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