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