text: #ifndef _CISCO_IOS_XE_NATIVE_94_
  #define _CISCO_IOS_XE_NATIVE_94_
  
  #include <memory>
  #include <vector>
  #include <string>
  #include <ydk/types.hpp>
  #include <ydk/errors.hpp>
  
  #include "Cisco_IOS_XE_native_0.hpp"
  #include "Cisco_IOS_XE_native_20.hpp"
  #include "Cisco_IOS_XE_native_92.hpp"
  
  namespace cisco_ios_xe {
  namespace Cisco_IOS_XE_native {
  
  
  class Native::Interface::SM::PmPath : public ydk::Entity
  {
      public:
          PmPath();
          ~PmPath();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf name; //type: string
          ydk::YLeaf interface_id; //type: uint8
  
  }; // Native::Interface::SM::PmPath
  
  
  class Native::Interface::Cellular : public ydk::Entity
  {
      public:
          Cellular();
          ~Cellular();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
          std::string get_absolute_path() const override;
  
          ydk::YLeaf name; //type: string
          ydk::YLeaf description; //type: string
          ydk::YLeaf mac_address; //type: string
          ydk::YLeaf shutdown; //type: empty
          ydk::YLeaf keepalive; //type: boolean
          ydk::YLeaf if_state; //type: IfState
          ydk::YLeaf delay; //type: uint32
          ydk::YLeaf load_interval; //type: uint16
          ydk::YLeaf max_reserved_bandwidth; //type: uint8
          ydk::YLeaf mtu; //type: uint16
          ydk::YLeaf service_insertion; //type: ServiceInsertion
          ydk::YLeaf dialer_group; //type: uint8
          ydk::YLeaf pulse_time; //type: uint8
          class SwitchportConf; //type: Native::Interface::Cellular::SwitchportConf
          class Switchport; //type: Native::Interface::Cellular::Switchport
          class StackwiseVirtual; //type: Native::Interface::Cellular::StackwiseVirtual
          class Arp; //type: Native::Interface::Cellular::Arp
          class Backup; //type: Native::Interface::Cellular::Backup
          class Cemoudp; //type: Native::Interface::Cellular::Cemoudp
          class CwsTunnel; //type: Native::Interface::Cellular::CwsTunnel
          class L2protocolTunnel; //type: Native::Interface::Cellular::L2protocolTunnel
          class Encapsulation; //type: Native::Interface::Cellular::Encapsulation
          class FairQueueConf; //type: Native::Interface::Cellular::FairQueueConf
          class FairQueue; //type: Native::Interface::Cellular::FairQueue
          class Flowcontrol; //type: Native::Interface::Cellular::Flowcontrol
          class Isis; //type: Native::Interface::Cellular::Isis
          class KeepaliveSettings; //type: Native::Interface::Cellular::KeepaliveSettings
          class Bfd; //type: Native::Interface::Cellular::Bfd
          class Bandwidth; //type: Native::Interface::Cellular::Bandwidth
          class Dampening; //type: Native::Interface::Cellular::Dampening
          class Domain; //type: Native::Interface::Cellular::Domain
          class HoldQueue; //type: Native::Interface::Cellular::HoldQueue
          class Mpls; //type: Native::Interface::Cellular::Mpls
          class IpVrf; //type: Native::Interface::Cellular::IpVrf
          class Vrf; //type: Native::Interface::Cellular::Vrf
          class Ip; //type: Native::Interface::Cellular::Ip
          class Ipv6; //type: Native::Interface::Cellular::Ipv6
          class Logging; //type: Native::Interface::Cellular::Logging
          class Mdix; //type: Native::Interface::Cellular::Mdix
          class Mop; //type: Native::Interface::Cellular::Mop
          class InterfaceQos; //type: Native::Interface::Cellular::InterfaceQos
          class Source; //type: Native::Interface::Cellular::Source
          class Standby; //type: Native::Interface::Cellular::Standby
          class AccessSession; //type: Native::Interface::Cellular::AccessSession
          class StormControl; //type: Native::Interface::Cellular::StormControl
          class Trust; //type: Native::Interface::Cellular::Trust
          class PriorityQueue; //type: Native::Interface::Cellular::PriorityQueue
          class RcvQueue; //type: Native::Interface::Cellular::RcvQueue
          class Peer; //type: Native::Interface::Cellular::Peer
          class PmPath; //type: Native::Interface::Cellular::PmPath
          class Dialer; //type: Native::Interface::Cellular::Dialer
          class Async; //type: Native::Interface::Cellular::Async
          class ServicePolicy; //type: Native::Interface::Cellular::ServicePolicy
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::SwitchportConf> switchport_conf;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Switchport> switchport;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::StackwiseVirtual> stackwise_virtual;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Arp> arp;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Backup> backup;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Cemoudp> cemoudp;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::CwsTunnel> cws_tunnel;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::L2protocolTunnel> l2protocol_tunnel; // presence node
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Encapsulation> encapsulation;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::FairQueueConf> fair_queue_conf;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::FairQueue> fair_queue;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Flowcontrol> flowcontrol;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Isis> isis;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::KeepaliveSettings> keepalive_settings;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Bfd> bfd;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Bandwidth> bandwidth;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Dampening> dampening;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Domain> domain;
          ydk::YList hold_queue;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Mpls> mpls;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::IpVrf> ip_vrf;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Vrf> vrf;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ip> ip;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ipv6> ipv6;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Logging> logging;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Mdix> mdix;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Mop> mop;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::InterfaceQos> interface_qos;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Source> source;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Standby> standby;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::AccessSession> access_session;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::StormControl> storm_control;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Trust> trust;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::PriorityQueue> priority_queue;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::RcvQueue> rcv_queue;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Peer> peer;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::PmPath> pm_path;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Dialer> dialer;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Async> async;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::ServicePolicy> service_policy;
                  class IfState;
          class ServiceInsertion;
  
  }; // Native::Interface::Cellular
  
  
  class Native::Interface::Cellular::SwitchportConf : public ydk::Entity
  {
      public:
          SwitchportConf();
          ~SwitchportConf();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf switchport; //type: boolean
  
  }; // Native::Interface::Cellular::SwitchportConf
  
  
  class Native::Interface::Cellular::Switchport : public ydk::Entity
  {
      public:
          Switchport();
          ~Switchport();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
  
  }; // Native::Interface::Cellular::Switchport
  
  
  class Native::Interface::Cellular::StackwiseVirtual : public ydk::Entity
  {
      public:
          StackwiseVirtual();
          ~StackwiseVirtual();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf link; //type: uint8
          ydk::YLeaf dual_active_detection; //type: empty
  
  }; // Native::Interface::Cellular::StackwiseVirtual
  
  
  class Native::Interface::Cellular::Arp : public ydk::Entity
  {
      public:
          Arp();
          ~Arp();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf timeout; //type: uint32
  
  }; // Native::Interface::Cellular::Arp
  
  
  class Native::Interface::Cellular::Backup : public ydk::Entity
  {
      public:
          Backup();
          ~Backup();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          class Delay; //type: Native::Interface::Cellular::Backup::Delay
          class Interface_; //type: Native::Interface::Cellular::Backup::Interface_
          class Load; //type: Native::Interface::Cellular::Backup::Load
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Backup::Delay> delay;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Backup::Interface_> interface;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Backup::Load> load;
          
  }; // Native::Interface::Cellular::Backup
  
  
  class Native::Interface::Cellular::Backup::Delay : public ydk::Entity
  {
      public:
          Delay();
          ~Delay();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf failure; //type: one of uint32, enumeration
          ydk::YLeaf secondary_disable; //type: one of uint32, enumeration
          class Failure;
          class SecondaryDisable;
  
  }; // Native::Interface::Cellular::Backup::Delay
  
  
  class Native::Interface::Cellular::Backup::Interface_ : public ydk::Entity
  {
      public:
          Interface_();
          ~Interface_();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf appnav_compress; //type: uint16
          ydk::YLeaf appnav_uncompress; //type: uint16
          ydk::YLeaf atm; //type: string
          ydk::YLeaf atm_acr; //type: string
          ydk::YLeaf bdi; //type: string
          ydk::YLeaf cem; //type: string
          ydk::YLeaf cem_acr; //type: uint8
          ydk::YLeaf embedded_service_engine; //type: string
          ydk::YLeaf ethernet; //type: string
          ydk::YLeaf fastethernet; //type: string
          ydk::YLeaf gigabitethernet; //type: string
          ydk::YLeaf fivegigabitethernet; //type: string
          ydk::YLeaf twentyfivegige; //type: string
          ydk::YLeaf twogigabitethernet; //type: string
          ydk::YLeaf fortygigabitethernet; //type: string
          ydk::YLeaf hundredgige; //type: string
          ydk::YLeaf lisp; //type: string
          ydk::YLeaf loopback; //type: uint32
          ydk::YLeaf multilink; //type: uint16
          ydk::YLeaf nve; //type: uint16
          ydk::YLeaf overlay; //type: uint16
          ydk::YLeaf port_channel; //type: uint32
          ydk::YLeaf pseudowire; //type: uint32
          ydk::YLeaf sm; //type: string
          ydk::YLeaf cellular; //type: string
          ydk::YLeaf serial; //type: string
          ydk::YLeaf tengigabitethernet; //type: string
          ydk::YLeaf tunnel; //type: uint32
          ydk::YLeaf virtual_template; //type: uint16
          ydk::YLeaf vlan; //type: uint16
          ydk::YLeaf virtualportgroup; //type: uint16
          ydk::YLeaf vasileft; //type: uint16
          ydk::YLeaf vasiright; //type: uint16
          class ATMSubinterface; //type: Native::Interface::Cellular::Backup::Interface_::ATMSubinterface
          class ATMACRsubinterface; //type: Native::Interface::Cellular::Backup::Interface_::ATMACRsubinterface
          class LISPSubinterface; //type: Native::Interface::Cellular::Backup::Interface_::LISPSubinterface
          class PortChannelSubinterface; //type: Native::Interface::Cellular::Backup::Interface_::PortChannelSubinterface
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Backup::Interface_::ATMSubinterface> atm_subinterface;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Backup::Interface_::ATMACRsubinterface> atm_acrsubinterface;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Backup::Interface_::LISPSubinterface> lisp_subinterface;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Backup::Interface_::PortChannelSubinterface> port_channel_subinterface;
          
  }; // Native::Interface::Cellular::Backup::Interface_
  
  
  class Native::Interface::Cellular::Backup::Interface_::ATMSubinterface : public ydk::Entity
  {
      public:
          ATMSubinterface();
          ~ATMSubinterface();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf atm; //type: string
  
  }; // Native::Interface::Cellular::Backup::Interface_::ATMSubinterface
  
  
  class Native::Interface::Cellular::Backup::Interface_::ATMACRsubinterface : public ydk::Entity
  {
      public:
          ATMACRsubinterface();
          ~ATMACRsubinterface();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf atm_acr; //type: string
  
  }; // Native::Interface::Cellular::Backup::Interface_::ATMACRsubinterface
  
  
  class Native::Interface::Cellular::Backup::Interface_::LISPSubinterface : public ydk::Entity
  {
      public:
          LISPSubinterface();
          ~LISPSubinterface();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf lisp; //type: string
  
  }; // Native::Interface::Cellular::Backup::Interface_::LISPSubinterface
  
  
  class Native::Interface::Cellular::Backup::Interface_::PortChannelSubinterface : public ydk::Entity
  {
      public:
          PortChannelSubinterface();
          ~PortChannelSubinterface();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf port_channel; //type: string
  
  }; // Native::Interface::Cellular::Backup::Interface_::PortChannelSubinterface
  
  
  class Native::Interface::Cellular::Backup::Load : public ydk::Entity
  {
      public:
          Load();
          ~Load();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf kickin; //type: one of uint32, enumeration
          ydk::YLeaf kickout; //type: one of uint32, enumeration
          class Kickin;
          class Kickout;
  
  }; // Native::Interface::Cellular::Backup::Load
  
  
  class Native::Interface::Cellular::Cemoudp : public ydk::Entity
  {
      public:
          Cemoudp();
          ~Cemoudp();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          class Reserve; //type: Native::Interface::Cellular::Cemoudp::Reserve
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Cemoudp::Reserve> reserve;
          
  }; // Native::Interface::Cellular::Cemoudp
  
  
  class Native::Interface::Cellular::Cemoudp::Reserve : public ydk::Entity
  {
      public:
          Reserve();
          ~Reserve();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf acr; //type: uint8
  
  }; // Native::Interface::Cellular::Cemoudp::Reserve
  
  
  class Native::Interface::Cellular::CwsTunnel : public ydk::Entity
  {
      public:
          CwsTunnel();
          ~CwsTunnel();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf in; //type: empty
          class Out; //type: Native::Interface::Cellular::CwsTunnel::Out
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::CwsTunnel::Out> out;
          
  }; // Native::Interface::Cellular::CwsTunnel
  
  
  class Native::Interface::Cellular::CwsTunnel::Out : public ydk::Entity
  {
      public:
          Out();
          ~Out();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf tunnel_number; //type: uint16
  
  }; // Native::Interface::Cellular::CwsTunnel::Out
  
  
  class Native::Interface::Cellular::L2protocolTunnel : public ydk::Entity
  {
      public:
          L2protocolTunnel();
          ~L2protocolTunnel();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf cdp; //type: empty
          ydk::YLeaf stp; //type: empty
          ydk::YLeaf vtp; //type: empty
          class DropThreshold; //type: Native::Interface::Cellular::L2protocolTunnel::DropThreshold
          class ShutdownThreshold; //type: Native::Interface::Cellular::L2protocolTunnel::ShutdownThreshold
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::L2protocolTunnel::DropThreshold> drop_threshold;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::L2protocolTunnel::ShutdownThreshold> shutdown_threshold;
          
  }; // Native::Interface::Cellular::L2protocolTunnel
  
  
  class Native::Interface::Cellular::L2protocolTunnel::DropThreshold : public ydk::Entity
  {
      public:
          DropThreshold();
          ~DropThreshold();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf packet_rate; //type: uint16
          ydk::YLeaf cdp; //type: uint16
          ydk::YLeaf stp; //type: uint16
          ydk::YLeaf vtp; //type: uint16
  
  }; // Native::Interface::Cellular::L2protocolTunnel::DropThreshold
  
  
  class Native::Interface::Cellular::L2protocolTunnel::ShutdownThreshold : public ydk::Entity
  {
      public:
          ShutdownThreshold();
          ~ShutdownThreshold();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf packet_rate; //type: uint16
          ydk::YLeaf cdp; //type: uint16
          ydk::YLeaf stp; //type: uint16
          ydk::YLeaf vtp; //type: uint16
  
  }; // Native::Interface::Cellular::L2protocolTunnel::ShutdownThreshold
  
  
  class Native::Interface::Cellular::Encapsulation : public ydk::Entity
  {
      public:
          Encapsulation();
          ~Encapsulation();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          class Dot1Q; //type: Native::Interface::Cellular::Encapsulation::Dot1Q
          class Isl; //type: Native::Interface::Cellular::Encapsulation::Isl
          class Ppp; //type: Native::Interface::Cellular::Encapsulation::Ppp
          class Slip; //type: Native::Interface::Cellular::Encapsulation::Slip
          class FrameRelay; //type: Native::Interface::Cellular::Encapsulation::FrameRelay
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Encapsulation::Dot1Q> dot1q;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Encapsulation::Isl> isl;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Encapsulation::Ppp> ppp; // presence node
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Encapsulation::Slip> slip; // presence node
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Encapsulation::FrameRelay> frame_relay; // presence node
          
  }; // Native::Interface::Cellular::Encapsulation
  
  
  class Native::Interface::Cellular::Encapsulation::Dot1Q : public ydk::Entity
  {
      public:
          Dot1Q();
          ~Dot1Q();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf vlan_id; //type: uint16
          ydk::YLeaf native; //type: empty
  
  }; // Native::Interface::Cellular::Encapsulation::Dot1Q
  
  
  class Native::Interface::Cellular::Encapsulation::Isl : public ydk::Entity
  {
      public:
          Isl();
          ~Isl();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf vlan_id; //type: uint16
  
  }; // Native::Interface::Cellular::Encapsulation::Isl
  
  
  class Native::Interface::Cellular::Encapsulation::Ppp : public ydk::Entity
  {
      public:
          Ppp();
          ~Ppp();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
  
  }; // Native::Interface::Cellular::Encapsulation::Ppp
  
  
  class Native::Interface::Cellular::Encapsulation::Slip : public ydk::Entity
  {
      public:
          Slip();
          ~Slip();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
  
  }; // Native::Interface::Cellular::Encapsulation::Slip
  
  
  class Native::Interface::Cellular::Encapsulation::FrameRelay : public ydk::Entity
  {
      public:
          FrameRelay();
          ~FrameRelay();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf ietf; //type: empty
  
  }; // Native::Interface::Cellular::Encapsulation::FrameRelay
  
  
  class Native::Interface::Cellular::FairQueueConf : public ydk::Entity
  {
      public:
          FairQueueConf();
          ~FairQueueConf();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf fair_queue; //type: boolean
  
  }; // Native::Interface::Cellular::FairQueueConf
  
  
  class Native::Interface::Cellular::FairQueue : public ydk::Entity
  {
      public:
          FairQueue();
          ~FairQueue();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf incomplete; //type: empty
  
  }; // Native::Interface::Cellular::FairQueue
  
  
  class Native::Interface::Cellular::Flowcontrol : public ydk::Entity
  {
      public:
          Flowcontrol();
          ~Flowcontrol();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf receive; //type: Receive
          ydk::YLeaf send; //type: Send
          class Receive;
          class Send;
  
  }; // Native::Interface::Cellular::Flowcontrol
  
  
  class Native::Interface::Cellular::Isis : public ydk::Entity
  {
      public:
          Isis();
          ~Isis();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
  
  }; // Native::Interface::Cellular::Isis
  
  
  class Native::Interface::Cellular::KeepaliveSettings : public ydk::Entity
  {
      public:
          KeepaliveSettings();
          ~KeepaliveSettings();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          class Keepalive; //type: Native::Interface::Cellular::KeepaliveSettings::Keepalive
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::KeepaliveSettings::Keepalive> keepalive; // presence node
          
  }; // Native::Interface::Cellular::KeepaliveSettings
  
  
  class Native::Interface::Cellular::KeepaliveSettings::Keepalive : public ydk::Entity
  {
      public:
          Keepalive();
          ~Keepalive();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf period; //type: uint16
          ydk::YLeaf retries; //type: uint8
  
  }; // Native::Interface::Cellular::KeepaliveSettings::Keepalive
  
  
  class Native::Interface::Cellular::Bfd : public ydk::Entity
  {
      public:
          Bfd();
          ~Bfd();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
  
  }; // Native::Interface::Cellular::Bfd
  
  
  class Native::Interface::Cellular::Bandwidth : public ydk::Entity
  {
      public:
          Bandwidth();
          ~Bandwidth();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf qos_reference; //type: uint32
          ydk::YLeaf kilobits; //type: uint32
          class Receive; //type: Native::Interface::Cellular::Bandwidth::Receive
          class Inherit; //type: Native::Interface::Cellular::Bandwidth::Inherit
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Bandwidth::Receive> receive;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Bandwidth::Inherit> inherit; // presence node
          
  }; // Native::Interface::Cellular::Bandwidth
  
  
  class Native::Interface::Cellular::Bandwidth::Receive : public ydk::Entity
  {
      public:
          Receive();
          ~Receive();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf inherit; //type: empty
          ydk::YLeaf kilobits; //type: uint32
  
  }; // Native::Interface::Cellular::Bandwidth::Receive
  
  
  class Native::Interface::Cellular::Bandwidth::Inherit : public ydk::Entity
  {
      public:
          Inherit();
          ~Inherit();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf kilobits; //type: uint32
  
  }; // Native::Interface::Cellular::Bandwidth::Inherit
  
  
  class Native::Interface::Cellular::Dampening : public ydk::Entity
  {
      public:
          Dampening();
          ~Dampening();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf dampening_time; //type: uint16
          ydk::YLeaf start_reusing_time; //type: uint16
          ydk::YLeaf start_supressing_time; //type: uint16
          ydk::YLeaf maximum_supressing_time; //type: uint16
          class Restart; //type: Native::Interface::Cellular::Dampening::Restart
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Dampening::Restart> restart;
          
  }; // Native::Interface::Cellular::Dampening
  
  
  class Native::Interface::Cellular::Dampening::Restart : public ydk::Entity
  {
      public:
          Restart();
          ~Restart();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf restart; //type: empty
          ydk::YLeaf restart_penalty; //type: uint16
  
  }; // Native::Interface::Cellular::Dampening::Restart
  
  
  class Native::Interface::Cellular::Domain : public ydk::Entity
  {
      public:
          Domain();
          ~Domain();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf name; //type: string
          ydk::YLeaf path; //type: string
          ydk::YLeaf internet_bound; //type: empty
          ydk::YLeaf path_id; //type: uint8
          ydk::YLeaf path_last_resort; //type: empty
          ydk::YLeaf zero_sla; //type: empty
  
  }; // Native::Interface::Cellular::Domain
  
  
  class Native::Interface::Cellular::HoldQueue : public ydk::Entity
  {
      public:
          HoldQueue();
          ~HoldQueue();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf direction; //type: Direction
          ydk::YLeaf queue_length; //type: uint32
          class Direction;
  
  }; // Native::Interface::Cellular::HoldQueue
  
  
  class Native::Interface::Cellular::Mpls : public ydk::Entity
  {
      public:
          Mpls();
          ~Mpls();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
  
  }; // Native::Interface::Cellular::Mpls
  
  
  class Native::Interface::Cellular::IpVrf : public ydk::Entity
  {
      public:
          IpVrf();
          ~IpVrf();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          class Ip; //type: Native::Interface::Cellular::IpVrf::Ip
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::IpVrf::Ip> ip;
          
  }; // Native::Interface::Cellular::IpVrf
  
  
  class Native::Interface::Cellular::IpVrf::Ip : public ydk::Entity
  {
      public:
          Ip();
          ~Ip();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          class Vrf; //type: Native::Interface::Cellular::IpVrf::Ip::Vrf
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::IpVrf::Ip::Vrf> vrf;
          
  }; // Native::Interface::Cellular::IpVrf::Ip
  
  
  class Native::Interface::Cellular::IpVrf::Ip::Vrf : public ydk::Entity
  {
      public:
          Vrf();
          ~Vrf();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf forwarding; //type: string
  
  }; // Native::Interface::Cellular::IpVrf::Ip::Vrf
  
  
  class Native::Interface::Cellular::Vrf : public ydk::Entity
  {
      public:
          Vrf();
          ~Vrf();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf forwarding; //type: string
          ydk::YLeaf downstream; //type: string
  
  }; // Native::Interface::Cellular::Vrf
  
  
  class Native::Interface::Cellular::Ip : public ydk::Entity
  {
      public:
          Ip();
          ~Ip();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf admission; //type: string
          ydk::YLeaf unnumbered; //type: string
          ydk::YLeaf local_proxy_arp; //type: empty
          ydk::YLeaf proxy_arp; //type: boolean
          ydk::YLeaf redirects; //type: boolean
          ydk::YLeaf mtu; //type: uint16
          ydk::YLeaf mroute_cache; //type: boolean
          class AccessGroup; //type: Native::Interface::Cellular::Ip::AccessGroup
          class Arp; //type: Native::Interface::Cellular::Ip::Arp
          class Vrf; //type: Native::Interface::Cellular::Ip::Vrf
          class Address; //type: Native::Interface::Cellular::Ip::Address
          class DirectedBroadcast; //type: Native::Interface::Cellular::Ip::DirectedBroadcast
          class HelloInterval; //type: Native::Interface::Cellular::Ip::HelloInterval
          class Authentication; //type: Native::Interface::Cellular::Ip::Authentication
          class HoldTime; //type: Native::Interface::Cellular::Ip::HoldTime
          class HelperAddress; //type: Native::Interface::Cellular::Ip::HelperAddress
          class Pim; //type: Native::Interface::Cellular::Ip::Pim
          class Policy; //type: Native::Interface::Cellular::Ip::Policy
          class Rip; //type: Native::Interface::Cellular::Ip::Rip
          class RouteCacheConf; //type: Native::Interface::Cellular::Ip::RouteCacheConf
          class RouteCache; //type: Native::Interface::Cellular::Ip::RouteCache
          class Router; //type: Native::Interface::Cellular::Ip::Router
          class Tcp; //type: Native::Interface::Cellular::Ip::Tcp
          class VirtualReassembly; //type: Native::Interface::Cellular::Ip::VirtualReassembly
          class Dhcp; //type: Native::Interface::Cellular::Ip::Dhcp
          class SummaryAddress; //type: Native::Interface::Cellular::Ip::SummaryAddress
          class Verify; //type: Native::Interface::Cellular::Ip::Verify
          class Nat; //type: Native::Interface::Cellular::Ip::Nat
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ip::AccessGroup> access_group;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ip::Arp> arp;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ip::Vrf> vrf;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ip::Address> address;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ip::DirectedBroadcast> directed_broadcast; // presence node
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ip::HelloInterval> hello_interval;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ip::Authentication> authentication;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ip::HoldTime> hold_time;
          ydk::YList helper_address;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ip::Pim> pim;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ip::Policy> policy;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ip::Rip> rip;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ip::RouteCacheConf> route_cache_conf;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ip::RouteCache> route_cache; // presence node
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ip::Router> router;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ip::Tcp> tcp;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ip::VirtualReassembly> virtual_reassembly;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ip::Dhcp> dhcp;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ip::SummaryAddress> summary_address;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ip::Verify> verify;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ip::Nat> nat;
          
  }; // Native::Interface::Cellular::Ip
  
  
  class Native::Interface::Cellular::Ip::AccessGroup : public ydk::Entity
  {
      public:
          AccessGroup();
          ~AccessGroup();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          class In; //type: Native::Interface::Cellular::Ip::AccessGroup::In
          class Out; //type: Native::Interface::Cellular::Ip::AccessGroup::Out
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ip::AccessGroup::In> in;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ip::AccessGroup::Out> out;
          
  }; // Native::Interface::Cellular::Ip::AccessGroup
  
  
  class Native::Interface::Cellular::Ip::AccessGroup::In : public ydk::Entity
  {
      public:
          In();
          ~In();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          class CommonAcl; //type: Native::Interface::Cellular::Ip::AccessGroup::In::CommonAcl
          class Acl; //type: Native::Interface::Cellular::Ip::AccessGroup::In::Acl
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ip::AccessGroup::In::CommonAcl> common_acl;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ip::AccessGroup::In::Acl> acl;
          
  }; // Native::Interface::Cellular::Ip::AccessGroup::In
  
  
  class Native::Interface::Cellular::Ip::AccessGroup::In::CommonAcl : public ydk::Entity
  {
      public:
          CommonAcl();
          ~CommonAcl();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf common; //type: one of uint16, string
          ydk::YLeaf in; //type: empty
  
  }; // Native::Interface::Cellular::Ip::AccessGroup::In::CommonAcl
  
  
  class Native::Interface::Cellular::Ip::AccessGroup::In::Acl : public ydk::Entity
  {
      public:
          Acl();
          ~Acl();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf acl_name; //type: one of uint16, string
          ydk::YLeaf in; //type: empty
  
  }; // Native::Interface::Cellular::Ip::AccessGroup::In::Acl
  
  
  class Native::Interface::Cellular::Ip::AccessGroup::Out : public ydk::Entity
  {
      public:
          Out();
          ~Out();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          class CommonAcl; //type: Native::Interface::Cellular::Ip::AccessGroup::Out::CommonAcl
          class Acl; //type: Native::Interface::Cellular::Ip::AccessGroup::Out::Acl
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ip::AccessGroup::Out::CommonAcl> common_acl;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ip::AccessGroup::Out::Acl> acl;
          
  }; // Native::Interface::Cellular::Ip::AccessGroup::Out
  
  
  class Native::Interface::Cellular::Ip::AccessGroup::Out::CommonAcl : public ydk::Entity
  {
      public:
          CommonAcl();
          ~CommonAcl();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf common; //type: one of uint16, string
          ydk::YLeaf out; //type: empty
  
  }; // Native::Interface::Cellular::Ip::AccessGroup::Out::CommonAcl
  
  
  class Native::Interface::Cellular::Ip::AccessGroup::Out::Acl : public ydk::Entity
  {
      public:
          Acl();
          ~Acl();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf acl_name; //type: one of uint16, string
          ydk::YLeaf out; //type: empty
  
  }; // Native::Interface::Cellular::Ip::AccessGroup::Out::Acl
  
  
  class Native::Interface::Cellular::Ip::Arp : public ydk::Entity
  {
      public:
          Arp();
          ~Arp();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          class Inspection; //type: Native::Interface::Cellular::Ip::Arp::Inspection
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ip::Arp::Inspection> inspection;
          
  }; // Native::Interface::Cellular::Ip::Arp
  
  
  class Native::Interface::Cellular::Ip::Arp::Inspection : public ydk::Entity
  {
      public:
          Inspection();
          ~Inspection();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf trust; //type: empty
          class Limit; //type: Native::Interface::Cellular::Ip::Arp::Inspection::Limit
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ip::Arp::Inspection::Limit> limit;
          
  }; // Native::Interface::Cellular::Ip::Arp::Inspection
  
  
  class Native::Interface::Cellular::Ip::Arp::Inspection::Limit : public ydk::Entity
  {
      public:
          Limit();
          ~Limit();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf none; //type: empty
          ydk::YLeaf rate; //type: uint32
  
  }; // Native::Interface::Cellular::Ip::Arp::Inspection::Limit
  
  
  class Native::Interface::Cellular::Ip::Vrf : public ydk::Entity
  {
      public:
          Vrf();
          ~Vrf();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf receive; //type: string
          ydk::YLeaf sitemap; //type: string
          class Forwarding; //type: Native::Interface::Cellular::Ip::Vrf::Forwarding
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ip::Vrf::Forwarding> forwarding;
          
  }; // Native::Interface::Cellular::Ip::Vrf
  
  
  class Native::Interface::Cellular::Ip::Vrf::Forwarding : public ydk::Entity
  {
      public:
          Forwarding();
          ~Forwarding();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf liin_vrf; //type: empty
          ydk::YLeaf mgmtvrf; //type: empty
          ydk::YLeaf word; //type: string
  
  }; // Native::Interface::Cellular::Ip::Vrf::Forwarding
  
  
  class Native::Interface::Cellular::Ip::Address : public ydk::Entity
  {
      public:
          Address();
          ~Address();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf negotiated; //type: empty
          class Secondary; //type: Native::Interface::Cellular::Ip::Address::Secondary
          class Primary; //type: Native::Interface::Cellular::Ip::Address::Primary
          class Dhcp; //type: Native::Interface::Cellular::Ip::Address::Dhcp
  
          ydk::YList secondary;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ip::Address::Primary> primary;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ip::Address::Dhcp> dhcp; // presence node
          
  }; // Native::Interface::Cellular::Ip::Address
  
  
  class Native::Interface::Cellular::Ip::Address::Secondary : public ydk::Entity
  {
      public:
          Secondary();
          ~Secondary();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf address; //type: string
          ydk::YLeaf mask; //type: string
          ydk::YLeaf secondary; //type: empty
  
  }; // Native::Interface::Cellular::Ip::Address::Secondary
  
  
  class Native::Interface::Cellular::Ip::Address::Primary : public ydk::Entity
  {
      public:
          Primary();
          ~Primary();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf address; //type: string
          ydk::YLeaf mask; //type: string
  
  }; // Native::Interface::Cellular::Ip::Address::Primary
  
  
  class Native::Interface::Cellular::Ip::Address::Dhcp : public ydk::Entity
  {
      public:
          Dhcp();
          ~Dhcp();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf hostname; //type: string
          class ClientId; //type: Native::Interface::Cellular::Ip::Address::Dhcp::ClientId
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ip::Address::Dhcp::ClientId> client_id;
          
  }; // Native::Interface::Cellular::Ip::Address::Dhcp
  
  
  class Native::Interface::Cellular::Ip::Address::Dhcp::ClientId : public ydk::Entity
  {
      public:
          ClientId();
          ~ClientId();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf ethernet; //type: string
          ydk::YLeaf fastethernet; //type: string
          ydk::YLeaf gigabitethernet; //type: string
          ydk::YLeaf fivegigabitethernet; //type: string
          ydk::YLeaf port_channel; //type: uint32
          ydk::YLeaf tengigabitethernet; //type: string
          ydk::YLeaf twentyfivegige; //type: string
          ydk::YLeaf fortygigabitethernet; //type: string
          ydk::YLeaf twogigabitethernet; //type: string
          ydk::YLeaf hundredgige; //type: string
          ydk::YLeaf vlan; //type: uint16
  
  }; // Native::Interface::Cellular::Ip::Address::Dhcp::ClientId
  
  
  class Native::Interface::Cellular::Ip::DirectedBroadcast : public ydk::Entity
  {
      public:
          DirectedBroadcast();
          ~DirectedBroadcast();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf direct_broadcast; //type: one of uint16, string
  
  }; // Native::Interface::Cellular::Ip::DirectedBroadcast
  
  
  class Native::Interface::Cellular::Ip::HelloInterval : public ydk::Entity
  {
      public:
          HelloInterval();
          ~HelloInterval();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf eigrp; //type: uint16
          ydk::YLeaf seconds; //type: uint16
  
  }; // Native::Interface::Cellular::Ip::HelloInterval
  
  
  class Native::Interface::Cellular::Ip::Authentication : public ydk::Entity
  {
      public:
          Authentication();
          ~Authentication();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          class KeyChain; //type: Native::Interface::Cellular::Ip::Authentication::KeyChain
          class Mode; //type: Native::Interface::Cellular::Ip::Authentication::Mode
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ip::Authentication::KeyChain> key_chain;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ip::Authentication::Mode> mode;
          
  }; // Native::Interface::Cellular::Ip::Authentication
  
  
  class Native::Interface::Cellular::Ip::Authentication::KeyChain : public ydk::Entity
  {
      public:
          KeyChain();
          ~KeyChain();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf eigrp; //type: uint16
          ydk::YLeaf name; //type: string
  
  }; // Native::Interface::Cellular::Ip::Authentication::KeyChain
  
  
  class Native::Interface::Cellular::Ip::Authentication::Mode : public ydk::Entity
  {
      public:
          Mode();
          ~Mode();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf eigrp; //type: uint16
          ydk::YLeaf md5; //type: empty
  
  }; // Native::Interface::Cellular::Ip::Authentication::Mode
  
  
  class Native::Interface::Cellular::Ip::HoldTime : public ydk::Entity
  {
      public:
          HoldTime();
          ~HoldTime();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf eigrp; //type: uint16
          ydk::YLeaf seconds; //type: uint16
  
  }; // Native::Interface::Cellular::Ip::HoldTime
  
  
  class Native::Interface::Cellular::Ip::HelperAddress : public ydk::Entity
  {
      public:
          HelperAddress();
          ~HelperAddress();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf address; //type: string
          ydk::YLeaf global; //type: empty
          ydk::YLeaf vrf; //type: string
  
  }; // Native::Interface::Cellular::Ip::HelperAddress
  
  
  class Native::Interface::Cellular::Ip::Pim : public ydk::Entity
  {
      public:
          Pim();
          ~Pim();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
  
  }; // Native::Interface::Cellular::Ip::Pim
  
  
  class Native::Interface::Cellular::Ip::Policy : public ydk::Entity
  {
      public:
          Policy();
          ~Policy();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf route_map; //type: string
  
  }; // Native::Interface::Cellular::Ip::Policy
  
  
  class Native::Interface::Cellular::Ip::Rip : public ydk::Entity
  {
      public:
          Rip();
          ~Rip();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          class Authentication; //type: Native::Interface::Cellular::Ip::Rip::Authentication
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ip::Rip::Authentication> authentication;
          
  }; // Native::Interface::Cellular::Ip::Rip
  
  
  class Native::Interface::Cellular::Ip::Rip::Authentication : public ydk::Entity
  {
      public:
          Authentication();
          ~Authentication();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf key_chain; //type: string
          class Mode; //type: Native::Interface::Cellular::Ip::Rip::Authentication::Mode
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ip::Rip::Authentication::Mode> mode;
          
  }; // Native::Interface::Cellular::Ip::Rip::Authentication
  
  
  class Native::Interface::Cellular::Ip::Rip::Authentication::Mode : public ydk::Entity
  {
      public:
          Mode();
          ~Mode();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf md5; //type: empty
          ydk::YLeaf text; //type: empty
  
  }; // Native::Interface::Cellular::Ip::Rip::Authentication::Mode
  
  
  class Native::Interface::Cellular::Ip::RouteCacheConf : public ydk::Entity
  {
      public:
          RouteCacheConf();
          ~RouteCacheConf();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf route_cache; //type: boolean
  
  }; // Native::Interface::Cellular::Ip::RouteCacheConf
  
  
  class Native::Interface::Cellular::Ip::RouteCache : public ydk::Entity
  {
      public:
          RouteCache();
          ~RouteCache();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf cef; //type: boolean
          ydk::YLeaf flow; //type: boolean
          ydk::YLeaf policy; //type: boolean
          ydk::YLeaf same_interface; //type: boolean
  
  }; // Native::Interface::Cellular::Ip::RouteCache
  
  
  class Native::Interface::Cellular::Ip::Router : public ydk::Entity
  {
      public:
          Router();
          ~Router();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          class Isis; //type: Native::Interface::Cellular::Ip::Router::Isis
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ip::Router::Isis> isis; // presence node
          
  }; // Native::Interface::Cellular::Ip::Router
  
  
  class Native::Interface::Cellular::Ip::Router::Isis : public ydk::Entity
  {
      public:
          Isis();
          ~Isis();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf tag; //type: string
  
  }; // Native::Interface::Cellular::Ip::Router::Isis
  
  
  class Native::Interface::Cellular::Ip::Tcp : public ydk::Entity
  {
      public:
          Tcp();
          ~Tcp();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf adjust_mss; //type: uint16
  
  }; // Native::Interface::Cellular::Ip::Tcp
  
  
  class Native::Interface::Cellular::Ip::VirtualReassembly : public ydk::Entity
  {
      public:
          VirtualReassembly();
          ~VirtualReassembly();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf max_reassemblies; //type: uint32
          ydk::YLeaf max_fragments; //type: uint32
          ydk::YLeaf timeout; //type: uint32
          ydk::YLeaf drop_fragments; //type: empty
          ydk::YLeaf in; //type: empty
  
  }; // Native::Interface::Cellular::Ip::VirtualReassembly
  
  
  class Native::Interface::Cellular::Ip::Dhcp : public ydk::Entity
  {
      public:
          Dhcp();
          ~Dhcp();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
  
  }; // Native::Interface::Cellular::Ip::Dhcp
  
  
  class Native::Interface::Cellular::Ip::SummaryAddress : public ydk::Entity
  {
      public:
          SummaryAddress();
          ~SummaryAddress();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          class Eigrp; //type: Native::Interface::Cellular::Ip::SummaryAddress::Eigrp
  
          ydk::YList eigrp;
          
  }; // Native::Interface::Cellular::Ip::SummaryAddress
  
  
  class Native::Interface::Cellular::Ip::SummaryAddress::Eigrp : public ydk::Entity
  {
      public:
          Eigrp();
          ~Eigrp();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf id; //type: string
          ydk::YLeaf ip; //type: string
          ydk::YLeaf mask; //type: string
          ydk::YLeaf metric; //type: uint32
  
  }; // Native::Interface::Cellular::Ip::SummaryAddress::Eigrp
  
  
  class Native::Interface::Cellular::Ip::Verify : public ydk::Entity
  {
      public:
          Verify();
          ~Verify();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          class Source; //type: Native::Interface::Cellular::Ip::Verify::Source
          class Unicast; //type: Native::Interface::Cellular::Ip::Verify::Unicast
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ip::Verify::Source> source; // presence node
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ip::Verify::Unicast> unicast;
          
  }; // Native::Interface::Cellular::Ip::Verify
  
  
  class Native::Interface::Cellular::Ip::Verify::Source : public ydk::Entity
  {
      public:
          Source();
          ~Source();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          class Vlan; //type: Native::Interface::Cellular::Ip::Verify::Source::Vlan
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ip::Verify::Source::Vlan> vlan;
          
  }; // Native::Interface::Cellular::Ip::Verify::Source
  
  
  class Native::Interface::Cellular::Ip::Verify::Source::Vlan : public ydk::Entity
  {
      public:
          Vlan();
          ~Vlan();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          class DhcpSnooping; //type: Native::Interface::Cellular::Ip::Verify::Source::Vlan::DhcpSnooping
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ip::Verify::Source::Vlan::DhcpSnooping> dhcp_snooping; // presence node
          
  }; // Native::Interface::Cellular::Ip::Verify::Source::Vlan
  
  
  class Native::Interface::Cellular::Ip::Verify::Source::Vlan::DhcpSnooping : public ydk::Entity
  {
      public:
          DhcpSnooping();
          ~DhcpSnooping();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf port_security; //type: empty
  
  }; // Native::Interface::Cellular::Ip::Verify::Source::Vlan::DhcpSnooping
  
  
  class Native::Interface::Cellular::Ip::Verify::Unicast : public ydk::Entity
  {
      public:
          Unicast();
          ~Unicast();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          class ReversePath; //type: Native::Interface::Cellular::Ip::Verify::Unicast::ReversePath
          class Source; //type: Native::Interface::Cellular::Ip::Verify::Unicast::Source
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ip::Verify::Unicast::ReversePath> reverse_path; // presence node
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ip::Verify::Unicast::Source> source;
          
  }; // Native::Interface::Cellular::Ip::Verify::Unicast
  
  
  class Native::Interface::Cellular::Ip::Verify::Unicast::ReversePath : public ydk::Entity
  {
      public:
          ReversePath();
          ~ReversePath();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
  
  }; // Native::Interface::Cellular::Ip::Verify::Unicast::ReversePath
  
  
  class Native::Interface::Cellular::Ip::Verify::Unicast::Source : public ydk::Entity
  {
      public:
          Source();
          ~Source();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf reachable_via; //type: ReachableVia
          ydk::YLeaf allow_self_ping; //type: empty
          ydk::YLeaf allow_default; //type: empty
          class ReachableVia;
  
  }; // Native::Interface::Cellular::Ip::Verify::Unicast::Source
  
  
  class Native::Interface::Cellular::Ip::Nat : public ydk::Entity
  {
      public:
          Nat();
          ~Nat();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf allow_static_host; //type: empty
          ydk::YLeaf enable; //type: empty
          ydk::YLeaf inside; //type: empty
          ydk::YLeaf outside; //type: empty
  
  }; // Native::Interface::Cellular::Ip::Nat
  
  
  class Native::Interface::Cellular::Ipv6 : public ydk::Entity
  {
      public:
          Ipv6();
          ~Ipv6();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf unnumbered; //type: string
          ydk::YLeaf enable; //type: empty
          ydk::YLeaf mtu; //type: uint16
          ydk::YLeaf redirects; //type: boolean
          class DestinationGuard; //type: Native::Interface::Cellular::Ipv6::DestinationGuard
          class SourceGuard; //type: Native::Interface::Cellular::Ipv6::SourceGuard
          class Dhcp; //type: Native::Interface::Cellular::Ipv6::Dhcp
          class Address; //type: Native::Interface::Cellular::Ipv6::Address
          class Nd; //type: Native::Interface::Cellular::Ipv6::Nd
          class Tcp; //type: Native::Interface::Cellular::Ipv6::Tcp
          class TrafficFilter; //type: Native::Interface::Cellular::Ipv6::TrafficFilter
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ipv6::DestinationGuard> destination_guard; // presence node
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ipv6::SourceGuard> source_guard; // presence node
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ipv6::Dhcp> dhcp;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ipv6::Address> address;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ipv6::Nd> nd;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ipv6::Tcp> tcp;
          ydk::YList traffic_filter;
          
  }; // Native::Interface::Cellular::Ipv6
  
  
  class Native::Interface::Cellular::Ipv6::DestinationGuard : public ydk::Entity
  {
      public:
          DestinationGuard();
          ~DestinationGuard();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf attach_policy; //type: string
  
  }; // Native::Interface::Cellular::Ipv6::DestinationGuard
  
  
  class Native::Interface::Cellular::Ipv6::SourceGuard : public ydk::Entity
  {
      public:
          SourceGuard();
          ~SourceGuard();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf attach_policy; //type: string
  
  }; // Native::Interface::Cellular::Ipv6::SourceGuard
  
  
  class Native::Interface::Cellular::Ipv6::Dhcp : public ydk::Entity
  {
      public:
          Dhcp();
          ~Dhcp();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
  
  }; // Native::Interface::Cellular::Ipv6::Dhcp
  
  
  class Native::Interface::Cellular::Ipv6::Address : public ydk::Entity
  {
      public:
          Address();
          ~Address();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          class Dhcp; //type: Native::Interface::Cellular::Ipv6::Address::Dhcp
          class Autoconfig; //type: Native::Interface::Cellular::Ipv6::Address::Autoconfig
          class PrefixList; //type: Native::Interface::Cellular::Ipv6::Address::PrefixList
          class LinkLocalAddress; //type: Native::Interface::Cellular::Ipv6::Address::LinkLocalAddress
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ipv6::Address::Dhcp> dhcp; // presence node
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Ipv6::Address::Autoconfig> autoconfig; // presence node
          ydk::YList prefix_list;
          ydk::YList link_local_address;
          
  }; // Native::Interface::Cellular::Ipv6::Address
  
  
  class Native::Interface::Cellular::Ipv6::Address::Dhcp : public ydk::Entity
  {
      public:
          Dhcp();
          ~Dhcp();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf rapid_commit; //type: empty
  
  }; // Native::Interface::Cellular::Ipv6::Address::Dhcp
  
  
  class Native::Interface::Cellular::Ipv6::Address::Autoconfig : public ydk::Entity
  {
      public:
          Autoconfig();
          ~Autoconfig();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf default_; //type: empty
  
  }; // Native::Interface::Cellular::Ipv6::Address::Autoconfig
  
  
  class Native::Interface::Cellular::Ipv6::Address::PrefixList : public ydk::Entity
  {
      public:
          PrefixList();
          ~PrefixList();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf prefix; //type: string
          ydk::YLeaf anycast; //type: empty
          ydk::YLeaf eui_64; //type: empty
  
  }; // Native::Interface::Cellular::Ipv6::Address::PrefixList
  
  
  class Native::Interface::Cellular::Ipv6::Address::LinkLocalAddress : public ydk::Entity
  {
      public:
          LinkLocalAddress();
          ~LinkLocalAddress();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf address; //type: string
          ydk::YLeaf link_local; //type: empty
  
  }; // Native::Interface::Cellular::Ipv6::Address::LinkLocalAddress
  
  
  class Native::Interface::Cellular::Ipv6::Nd : public ydk::Entity
  {
      public:
          Nd();
          ~Nd();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
  
  }; // Native::Interface::Cellular::Ipv6::Nd
  
  
  class Native::Interface::Cellular::Ipv6::Tcp : public ydk::Entity
  {
      public:
          Tcp();
          ~Tcp();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf adjust_mss; //type: uint16
  
  }; // Native::Interface::Cellular::Ipv6::Tcp
  
  
  class Native::Interface::Cellular::Ipv6::TrafficFilter : public ydk::Entity
  {
      public:
          TrafficFilter();
          ~TrafficFilter();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf direction; //type: Direction
          ydk::YLeaf access_list; //type: string
          class Direction;
  
  }; // Native::Interface::Cellular::Ipv6::TrafficFilter
  
  
  class Native::Interface::Cellular::Logging : public ydk::Entity
  {
      public:
          Logging();
          ~Logging();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          class Event; //type: Native::Interface::Cellular::Logging::Event
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Logging::Event> event;
          
  }; // Native::Interface::Cellular::Logging
  
  
  class Native::Interface::Cellular::Logging::Event : public ydk::Entity
  {
      public:
          Event();
          ~Event();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf bundle_status; //type: empty
          ydk::YLeaf link_status; //type: empty
          ydk::YLeaf trunk_status; //type: empty
          ydk::YLeaf nfas_status; //type: empty
          ydk::YLeaf power_inline_status; //type: empty
          ydk::YLeaf status; //type: empty
          class SpanningTree; //type: Native::Interface::Cellular::Logging::Event::SpanningTree
          class SubifLinkStatus; //type: Native::Interface::Cellular::Logging::Event::SubifLinkStatus
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Logging::Event::SpanningTree> spanning_tree; // presence node
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Logging::Event::SubifLinkStatus> subif_link_status; // presence node
          
  }; // Native::Interface::Cellular::Logging::Event
  
  
  class Native::Interface::Cellular::Logging::Event::SpanningTree : public ydk::Entity
  {
      public:
          SpanningTree();
          ~SpanningTree();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf status; //type: empty
  
  }; // Native::Interface::Cellular::Logging::Event::SpanningTree
  
  
  class Native::Interface::Cellular::Logging::Event::SubifLinkStatus : public ydk::Entity
  {
      public:
          SubifLinkStatus();
          ~SubifLinkStatus();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf ignore_bulk; //type: empty
  
  }; // Native::Interface::Cellular::Logging::Event::SubifLinkStatus
  
  
  class Native::Interface::Cellular::Mdix : public ydk::Entity
  {
      public:
          Mdix();
          ~Mdix();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf auto_; //type: boolean
  
  }; // Native::Interface::Cellular::Mdix
  
  
  class Native::Interface::Cellular::Mop : public ydk::Entity
  {
      public:
          Mop();
          ~Mop();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf enabled; //type: boolean
          ydk::YLeaf sysid; //type: boolean
  
  }; // Native::Interface::Cellular::Mop
  
  
  class Native::Interface::Cellular::InterfaceQos : public ydk::Entity
  {
      public:
          InterfaceQos();
          ~InterfaceQos();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          class Trust; //type: Native::Interface::Cellular::InterfaceQos::Trust
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::InterfaceQos::Trust> trust;
          
  }; // Native::Interface::Cellular::InterfaceQos
  
  
  class Native::Interface::Cellular::InterfaceQos::Trust : public ydk::Entity
  {
      public:
          Trust();
          ~Trust();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf device; //type: Device
          class Device;
  
  }; // Native::Interface::Cellular::InterfaceQos::Trust
  
  
  class Native::Interface::Cellular::Source : public ydk::Entity
  {
      public:
          Source();
          ~Source();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          class Template; //type: Native::Interface::Cellular::Source::Template
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Source::Template> template_;
          
  }; // Native::Interface::Cellular::Source
  
  
  class Native::Interface::Cellular::Source::Template : public ydk::Entity
  {
      public:
          Template();
          ~Template();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          class TemplateName; //type: Native::Interface::Cellular::Source::Template::TemplateName
  
          ydk::YList template_name;
          
  }; // Native::Interface::Cellular::Source::Template
  
  
  class Native::Interface::Cellular::Source::Template::TemplateName : public ydk::Entity
  {
      public:
          TemplateName();
          ~TemplateName();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf template_name; //type: string
          ydk::YLeaf merge; //type: empty
  
  }; // Native::Interface::Cellular::Source::Template::TemplateName
  
  
  class Native::Interface::Cellular::Standby : public ydk::Entity
  {
      public:
          Standby();
          ~Standby();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf version; //type: Version
          ydk::YLeaf bfd; //type: empty
          ydk::YLeaf mac_refresh; //type: uint8
          class Delay; //type: Native::Interface::Cellular::Standby::Delay
          class UseBia; //type: Native::Interface::Cellular::Standby::UseBia
          class StandbyList; //type: Native::Interface::Cellular::Standby::StandbyList
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Standby::Delay> delay;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Standby::UseBia> use_bia; // presence node
          ydk::YList standby_list;
                  class Version;
  
  }; // Native::Interface::Cellular::Standby
  
  
  class Native::Interface::Cellular::Standby::Delay : public ydk::Entity
  {
      public:
          Delay();
          ~Delay();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf minimum; //type: uint16
          ydk::YLeaf reload; //type: uint16
  
  }; // Native::Interface::Cellular::Standby::Delay
  
  
  class Native::Interface::Cellular::Standby::UseBia : public ydk::Entity
  {
      public:
          UseBia();
          ~UseBia();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          class Scope; //type: Native::Interface::Cellular::Standby::UseBia::Scope
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Standby::UseBia::Scope> scope;
          
  }; // Native::Interface::Cellular::Standby::UseBia
  
  
  class Native::Interface::Cellular::Standby::UseBia::Scope : public ydk::Entity
  {
      public:
          Scope();
          ~Scope();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf interface; //type: empty
  
  }; // Native::Interface::Cellular::Standby::UseBia::Scope
  
  
  class Native::Interface::Cellular::Standby::StandbyList : public ydk::Entity
  {
      public:
          StandbyList();
          ~StandbyList();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf group_number; //type: uint16
          ydk::YLeaf follow; //type: string
          ydk::YLeaf ipv6; //type: one of string, enumeration
          ydk::YLeaf mac_address; //type: string
          ydk::YLeaf name; //type: string
          ydk::YLeaf priority; //type: uint8
          class Authentication; //type: Native::Interface::Cellular::Standby::StandbyList::Authentication
          class Ip; //type: Native::Interface::Cellular::Standby::StandbyList::Ip
          class Preempt; //type: Native::Interface::Cellular::Standby::StandbyList::Preempt
          class Redirect; //type: Native::Interface::Cellular::Standby::StandbyList::Redirect
          class Timers; //type: Native::Interface::Cellular::Standby::StandbyList::Timers
          class Track; //type: Native::Interface::Cellular::Standby::StandbyList::Track
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Standby::StandbyList::Authentication> authentication;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Standby::StandbyList::Ip> ip; // presence node
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Standby::StandbyList::Preempt> preempt; // presence node
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Standby::StandbyList::Redirect> redirect;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Standby::StandbyList::Timers> timers;
          ydk::YList track;
                  class Ipv6;
  
  }; // Native::Interface::Cellular::Standby::StandbyList
  
  
  class Native::Interface::Cellular::Standby::StandbyList::Authentication : public ydk::Entity
  {
      public:
          Authentication();
          ~Authentication();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf word; //type: string
          ydk::YLeaf text; //type: string
          class Md5; //type: Native::Interface::Cellular::Standby::StandbyList::Authentication::Md5
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Standby::StandbyList::Authentication::Md5> md5;
          
  }; // Native::Interface::Cellular::Standby::StandbyList::Authentication
  
  
  class Native::Interface::Cellular::Standby::StandbyList::Authentication::Md5 : public ydk::Entity
  {
      public:
          Md5();
          ~Md5();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf key_chain; //type: string
          class KeyString; //type: Native::Interface::Cellular::Standby::StandbyList::Authentication::Md5::KeyString
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Standby::StandbyList::Authentication::Md5::KeyString> key_string;
          
  }; // Native::Interface::Cellular::Standby::StandbyList::Authentication::Md5
  
  
  class Native::Interface::Cellular::Standby::StandbyList::Authentication::Md5::KeyString : public ydk::Entity
  {
      public:
          KeyString();
          ~KeyString();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf encrypt; //type: Encrypt
          ydk::YLeaf string; //type: string
          ydk::YLeaf timeout; //type: uint16
          class Encrypt;
  
  }; // Native::Interface::Cellular::Standby::StandbyList::Authentication::Md5::KeyString
  
  
  class Native::Interface::Cellular::Standby::StandbyList::Ip : public ydk::Entity
  {
      public:
          Ip();
          ~Ip();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf address; //type: string
          ydk::YLeaf secondary; //type: empty
  
  }; // Native::Interface::Cellular::Standby::StandbyList::Ip
  
  
  class Native::Interface::Cellular::Standby::StandbyList::Preempt : public ydk::Entity
  {
      public:
          Preempt();
          ~Preempt();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          class Delay; //type: Native::Interface::Cellular::Standby::StandbyList::Preempt::Delay
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Standby::StandbyList::Preempt::Delay> delay;
          
  }; // Native::Interface::Cellular::Standby::StandbyList::Preempt
  
  
  class Native::Interface::Cellular::Standby::StandbyList::Preempt::Delay : public ydk::Entity
  {
      public:
          Delay();
          ~Delay();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf minimum; //type: uint16
          ydk::YLeaf reload; //type: uint16
          ydk::YLeaf sync; //type: uint16
  
  }; // Native::Interface::Cellular::Standby::StandbyList::Preempt::Delay
  
  
  class Native::Interface::Cellular::Standby::StandbyList::Redirect : public ydk::Entity
  {
      public:
          Redirect();
          ~Redirect();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf unknown; //type: empty
          class Advertisement; //type: Native::Interface::Cellular::Standby::StandbyList::Redirect::Advertisement
          class Timers; //type: Native::Interface::Cellular::Standby::StandbyList::Redirect::Timers
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Standby::StandbyList::Redirect::Advertisement> advertisement;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Standby::StandbyList::Redirect::Timers> timers;
          
  }; // Native::Interface::Cellular::Standby::StandbyList::Redirect
  
  
  class Native::Interface::Cellular::Standby::StandbyList::Redirect::Advertisement : public ydk::Entity
  {
      public:
          Advertisement();
          ~Advertisement();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          class Authentication; //type: Native::Interface::Cellular::Standby::StandbyList::Redirect::Advertisement::Authentication
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Standby::StandbyList::Redirect::Advertisement::Authentication> authentication;
          
  }; // Native::Interface::Cellular::Standby::StandbyList::Redirect::Advertisement
  
  
  class Native::Interface::Cellular::Standby::StandbyList::Redirect::Advertisement::Authentication : public ydk::Entity
  {
      public:
          Authentication();
          ~Authentication();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          class Md5; //type: Native::Interface::Cellular::Standby::StandbyList::Redirect::Advertisement::Authentication::Md5
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Standby::StandbyList::Redirect::Advertisement::Authentication::Md5> md5;
          
  }; // Native::Interface::Cellular::Standby::StandbyList::Redirect::Advertisement::Authentication
  
  
  class Native::Interface::Cellular::Standby::StandbyList::Redirect::Advertisement::Authentication::Md5 : public ydk::Entity
  {
      public:
          Md5();
          ~Md5();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf key_chain; //type: string
          class KeyString; //type: Native::Interface::Cellular::Standby::StandbyList::Redirect::Advertisement::Authentication::Md5::KeyString
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Standby::StandbyList::Redirect::Advertisement::Authentication::Md5::KeyString> key_string;
          
  }; // Native::Interface::Cellular::Standby::StandbyList::Redirect::Advertisement::Authentication::Md5
  
  
  class Native::Interface::Cellular::Standby::StandbyList::Redirect::Advertisement::Authentication::Md5::KeyString : public ydk::Entity
  {
      public:
          KeyString();
          ~KeyString();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf encrypt; //type: Encrypt
          ydk::YLeaf string; //type: string
          ydk::YLeaf timeout; //type: uint16
          class Encrypt;
  
  }; // Native::Interface::Cellular::Standby::StandbyList::Redirect::Advertisement::Authentication::Md5::KeyString
  
  
  class Native::Interface::Cellular::Standby::StandbyList::Redirect::Timers : public ydk::Entity
  {
      public:
          Timers();
          ~Timers();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf advertisement; //type: uint16
          ydk::YLeaf holddown; //type: uint16
  
  }; // Native::Interface::Cellular::Standby::StandbyList::Redirect::Timers
  
  
  class Native::Interface::Cellular::Standby::StandbyList::Timers : public ydk::Entity
  {
      public:
          Timers();
          ~Timers();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          class HelloInterval; //type: Native::Interface::Cellular::Standby::StandbyList::Timers::HelloInterval
          class HoldTime; //type: Native::Interface::Cellular::Standby::StandbyList::Timers::HoldTime
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Standby::StandbyList::Timers::HelloInterval> hello_interval;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::Standby::StandbyList::Timers::HoldTime> hold_time;
          
  }; // Native::Interface::Cellular::Standby::StandbyList::Timers
  
  
  class Native::Interface::Cellular::Standby::StandbyList::Timers::HelloInterval : public ydk::Entity
  {
      public:
          HelloInterval();
          ~HelloInterval();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf seconds; //type: uint8
          ydk::YLeaf msec; //type: uint16
  
  }; // Native::Interface::Cellular::Standby::StandbyList::Timers::HelloInterval
  
  
  class Native::Interface::Cellular::Standby::StandbyList::Timers::HoldTime : public ydk::Entity
  {
      public:
          HoldTime();
          ~HoldTime();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf seconds; //type: uint8
          ydk::YLeaf msec; //type: uint16
  
  }; // Native::Interface::Cellular::Standby::StandbyList::Timers::HoldTime
  
  
  class Native::Interface::Cellular::Standby::StandbyList::Track : public ydk::Entity
  {
      public:
          Track();
          ~Track();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf number; //type: uint16
          ydk::YLeaf decrement; //type: uint8
          ydk::YLeaf shutdown; //type: empty
  
  }; // Native::Interface::Cellular::Standby::StandbyList::Track
  
  
  class Native::Interface::Cellular::AccessSession : public ydk::Entity
  {
      public:
          AccessSession();
          ~AccessSession();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf closed; //type: empty
          ydk::YLeaf host_mode; //type: HostMode
          class PortControl; //type: Native::Interface::Cellular::AccessSession::PortControl
          class ControlDirection; //type: Native::Interface::Cellular::AccessSession::ControlDirection
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::AccessSession::PortControl> port_control;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::AccessSession::ControlDirection> control_direction;
                  class HostMode;
  
  }; // Native::Interface::Cellular::AccessSession
  
  
  class Native::Interface::Cellular::AccessSession::PortControl : public ydk::Entity
  {
      public:
          PortControl();
          ~PortControl();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf auto_; //type: empty
  
  }; // Native::Interface::Cellular::AccessSession::PortControl
  
  
  class Native::Interface::Cellular::AccessSession::ControlDirection : public ydk::Entity
  {
      public:
          ControlDirection();
          ~ControlDirection();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf in; //type: empty
  
  }; // Native::Interface::Cellular::AccessSession::ControlDirection
  
  
  class Native::Interface::Cellular::StormControl : public ydk::Entity
  {
      public:
          StormControl();
          ~StormControl();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          class Action; //type: Native::Interface::Cellular::StormControl::Action
          class Broadcast; //type: Native::Interface::Cellular::StormControl::Broadcast
          class Multicast; //type: Native::Interface::Cellular::StormControl::Multicast
          class Unicast; //type: Native::Interface::Cellular::StormControl::Unicast
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::StormControl::Action> action;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::StormControl::Broadcast> broadcast;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::StormControl::Multicast> multicast;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::StormControl::Unicast> unicast;
          
  }; // Native::Interface::Cellular::StormControl
  
  
  class Native::Interface::Cellular::StormControl::Action : public ydk::Entity
  {
      public:
          Action();
          ~Action();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf level; //type: decimal64
          ydk::YLeaf shutdown; //type: empty
          ydk::YLeaf trap; //type: empty
  
  }; // Native::Interface::Cellular::StormControl::Action
  
  
  class Native::Interface::Cellular::StormControl::Broadcast : public ydk::Entity
  {
      public:
          Broadcast();
          ~Broadcast();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          class Include; //type: Native::Interface::Cellular::StormControl::Broadcast::Include
          class Level; //type: Native::Interface::Cellular::StormControl::Broadcast::Level
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::StormControl::Broadcast::Include> include;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::StormControl::Broadcast::Level> level;
          
  }; // Native::Interface::Cellular::StormControl::Broadcast
  
  
  class Native::Interface::Cellular::StormControl::Broadcast::Include : public ydk::Entity
  {
      public:
          Include();
          ~Include();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf multicast; //type: empty
  
  }; // Native::Interface::Cellular::StormControl::Broadcast::Include
  
  
  class Native::Interface::Cellular::StormControl::Broadcast::Level : public ydk::Entity
  {
      public:
          Level();
          ~Level();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          class Threshold; //type: Native::Interface::Cellular::StormControl::Broadcast::Level::Threshold
          class Bps; //type: Native::Interface::Cellular::StormControl::Broadcast::Level::Bps
          class Pps; //type: Native::Interface::Cellular::StormControl::Broadcast::Level::Pps
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::StormControl::Broadcast::Level::Threshold> threshold;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::StormControl::Broadcast::Level::Bps> bps;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::StormControl::Broadcast::Level::Pps> pps;
          
  }; // Native::Interface::Cellular::StormControl::Broadcast::Level
  
  
  class Native::Interface::Cellular::StormControl::Broadcast::Level::Threshold : public ydk::Entity
  {
      public:
          Threshold();
          ~Threshold();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf rising_threshold; //type: decimal64
          ydk::YLeaf falling_threshold; //type: decimal64
  
  }; // Native::Interface::Cellular::StormControl::Broadcast::Level::Threshold
  
  
  class Native::Interface::Cellular::StormControl::Broadcast::Level::Bps : public ydk::Entity
  {
      public:
          Bps();
          ~Bps();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf rising_threshold; //type: string
          ydk::YLeaf falling_threshold; //type: string
  
  }; // Native::Interface::Cellular::StormControl::Broadcast::Level::Bps
  
  
  class Native::Interface::Cellular::StormControl::Broadcast::Level::Pps : public ydk::Entity
  {
      public:
          Pps();
          ~Pps();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          ydk::YLeaf rising_threshold; //type: string
          ydk::YLeaf falling_threshold; //type: string
  
  }; // Native::Interface::Cellular::StormControl::Broadcast::Level::Pps
  
  
  class Native::Interface::Cellular::StormControl::Multicast : public ydk::Entity
  {
      public:
          Multicast();
          ~Multicast();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          class Level; //type: Native::Interface::Cellular::StormControl::Multicast::Level
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::StormControl::Multicast::Level> level;
          
  }; // Native::Interface::Cellular::StormControl::Multicast
  
  
  class Native::Interface::Cellular::StormControl::Multicast::Level : public ydk::Entity
  {
      public:
          Level();
          ~Level();
  
          bool has_data() const override;
          bool has_operation() const override;
          std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
          std::string get_segment_path() const override;
          std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
          void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
          void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
          std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
          bool has_leaf_or_child_of_name(const std::string & name) const override;
  
          class Threshold; //type: Native::Interface::Cellular::StormControl::Multicast::Level::Threshold
          class Bps; //type: Native::Interface::Cellular::StormControl::Multicast::Level::Bps
          class Pps; //type: Native::Interface::Cellular::StormControl::Multicast::Level::Pps
  
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::StormControl::Multicast::Level::Threshold> threshold;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::StormControl::Multicast::Level::Bps> bps;
          std::shared_ptr<cisco_ios_xe::Cisco_IOS_XE_native::Native::Interface::Cellular::StormControl::Multicast::Level::Pps> pps;
          
  }; // Native::Interface::Cellular::StormControl::Multicast::Level
  
  class Native::Interface::Cellular::IfState : public ydk::Enum
  {
      public:
          static const ydk::Enum::YLeaf nhrp;
  
          static int get_enum_value(const std::string & name) {
              if (name == "nhrp") return 0;
              return -1;
          }
  };
  
  class Native::Interface::Cellular::ServiceInsertion : public ydk::Enum
  {
      public:
          static const ydk::Enum::YLeaf waas;
  
          static int get_enum_value(const std::string & name) {
              if (name == "waas") return 0;
              return -1;
          }
  };
  
  class Native::Interface::Cellular::Backup::Delay::Failure : public ydk::Enum
  {
      public:
          static const ydk::Enum::YLeaf never;
  
          static int get_enum_value(const std::string & name) {
              if (name == "never") return 0;
              return -1;
          }
  };
  
  class Native::Interface::Cellular::Backup::Delay::SecondaryDisable : public ydk::Enum
  {
      public:
          static const ydk::Enum::YLeaf never;
  
          static int get_enum_value(const std::string & name) {
              if (name == "never") return 0;
              return -1;
          }
  };
  
  class Native::Interface::Cellular::Backup::Load::Kickin : public ydk::Enum
  {
      public:
          static const ydk::Enum::YLeaf never;
  
          static int get_enum_value(const std::string & name) {
              if (name == "never") return 0;
              return -1;
          }
  };
  
  class Native::Interface::Cellular::Backup::Load::Kickout : public ydk::Enum
  {
      public:
          static const ydk::Enum::YLeaf never;
  
          static int get_enum_value(const std::string & name) {
              if (name == "never") return 0;
              return -1;
          }
  };
  
  class Native::Interface::Cellular::Flowcontrol::Receive : public ydk::Enum
  {
      public:
          static const ydk::Enum::YLeaf desired;
          static const ydk::Enum::YLeaf off;
          static const ydk::Enum::YLeaf on;
  
          static int get_enum_value(const std::string & name) {
              if (name == "desired") return 0;
              if (name == "off") return 1;
              if (name == "on") return 2;
              return -1;
          }
  };
  
  class Native::Interface::Cellular::Flowcontrol::Send : public ydk::Enum
  {
      public:
          static const ydk::Enum::YLeaf desired;
          static const ydk::Enum::YLeaf off;
          static const ydk::Enum::YLeaf on;
  
          static int get_enum_value(const std::string & name) {
              if (name == "desired") return 0;
              if (name == "off") return 1;
              if (name == "on") return 2;
              return -1;
          }
  };
  
  class Native::Interface::Cellular::HoldQueue::Direction : public ydk::Enum
  {
      public:
          static const ydk::Enum::YLeaf in;
          static const ydk::Enum::YLeaf out;
  
          static int get_enum_value(const std::string & name) {
              if (name == "in") return 0;
              if (name == "out") return 1;
              return -1;
          }
  };
  
  class Native::Interface::Cellular::Ip::Verify::Unicast::Source::ReachableVia : public ydk::Enum
  {
      public:
          static const ydk::Enum::YLeaf any;
          static const ydk::Enum::YLeaf rx;
  
          static int get_enum_value(const std::string & name) {
              if (name == "any") return 0;
              if (name == "rx") return 1;
              return -1;
          }
  };
  
  class Native::Interface::Cellular::Ipv6::TrafficFilter::Direction : public ydk::Enum
  {
      public:
          static const ydk::Enum::YLeaf in;
          static const ydk::Enum::YLeaf out;
  
          static int get_enum_value(const std::string & name) {
              if (name == "in") return 0;
              if (name == "out") return 1;
              return -1;
          }
  };
  
  class Native::Interface::Cellular::InterfaceQos::Trust::Device : public ydk::Enum
  {
      public:
          static const ydk::Enum::YLeaf cisco_phone;
  
          static int get_enum_value(const std::string & name) {
              if (name == "cisco-phone") return 0;
              return -1;
          }
  };
  
  class Native::Interface::Cellular::Standby::Version : public ydk::Enum
  {
      public:
          static const ydk::Enum::YLeaf Y_1;
          static const ydk::Enum::YLeaf Y_2;
  
          static int get_enum_value(const std::string & name) {
              if (name == "1") return 0;
              if (name == "2") return 1;
              return -1;
          }
  };
  
  class Native::Interface::Cellular::Standby::StandbyList::Ipv6 : public ydk::Enum
  {
      public:
          static const ydk::Enum::YLeaf autoconfig;
  
          static int get_enum_value(const std::string & name) {
              if (name == "autoconfig") return 0;
              return -1;
          }
  };
  
  class Native::Interface::Cellular::Standby::StandbyList::Authentication::Md5::KeyString::Encrypt : public ydk::Enum
  {
      public:
          static const ydk::Enum::YLeaf Y_0;
          static const ydk::Enum::YLeaf Y_7;
  
          static int get_enum_value(const std::string & name) {
              if (name == "0") return 0;
              if (name == "7") return 1;
              return -1;
          }
  };
  
  class Native::Interface::Cellular::Standby::StandbyList::Redirect::Advertisement::Authentication::Md5::KeyString::Encrypt : public ydk::Enum
  {
      public:
          static const ydk::Enum::YLeaf Y_0;
          static const ydk::Enum::YLeaf Y_7;
  
          static int get_enum_value(const std::string & name) {
              if (name == "0") return 0;
              if (name == "7") return 1;
              return -1;
          }
  };
  
  class Native::Interface::Cellular::AccessSession::HostMode : public ydk::Enum
  {
      public:
          static const ydk::Enum::YLeaf multi_auth;
          static const ydk::Enum::YLeaf multi_domain;
          static const ydk::Enum::YLeaf multi_host;
          static const ydk::Enum::YLeaf single_host;
  
          static int get_enum_value(const std::string & name) {
              if (name == "multi-auth") return 0;
              if (name == "multi-domain") return 1;
              if (name == "multi-host") return 2;
              if (name == "single-host") return 3;
              return -1;
          }
  };
  
  
  }
  }
  
  #endif /* _CISCO_IOS_XE_NATIVE_94_ */
  
  