Interface (sfc 0.7.0-SNAPSHOT API)

All Superinterfaces:: org.opendaylight.yangtools.yang.binding.Augmentable<Interface>, org.opendaylight.yangtools.yang.binding.ChildOf<Native>, org.opendaylight.yangtools.yang.binding.DataContainer, org.opendaylight.yangtools.yang.binding.DataObject

public interface Interface
extends org.opendaylight.yangtools.yang.binding.ChildOf<Native>, org.opendaylight.yangtools.yang.binding.Augmentable<Interface>

Configure interfaces

This class represents the following YANG schema fragment defined in module ned

 container interface {
     list AppNav-Compress {
         key "name"
         leaf name {
             type uint16;
         }
         container service-policy {
             leaf history {
                 type empty;
             }
             leaf input {
                 type string;
             }
             leaf output {
                 type string;
             }
             container type {
                 container performance-monitor {
                     leaf direction {
                         type enumeration;
                     }
                     leaf name {
                         type string;
                     }
                 }
                 container service-chain {
                     leaf direction {
                         type enumeration;
                     }
                     leaf name {
                         type string;
                     }
                 }
             }
         }
         uses interface-common-grouping;
     }
     list AppNav-UnCompress {
         key "name"
         leaf name {
             type uint16;
         }
         container service-policy {
             leaf history {
                 type empty;
             }
             leaf input {
                 type string;
             }
             leaf output {
                 type string;
             }
             container type {
                 container performance-monitor {
                     leaf direction {
                         type enumeration;
                     }
                     leaf name {
                         type string;
                     }
                 }
                 container service-chain {
                     leaf direction {
                         type enumeration;
                     }
                     leaf name {
                         type string;
                     }
                 }
             }
         }
         uses interface-common-grouping;
     }
     list ATM {
         key "name"
         leaf name {
             type string;
         }
         uses interface-atm-grouping;
     }
     container ATM-subinterface {
         list ATM {
             key "name"
             leaf name {
                 type string;
             }
             uses interface-atm-grouping;
         }
     }
     list ATM-ACR {
         key "name"
         leaf name {
             type string;
         }
         uses interface-atm-grouping;
     }
     container ATM-ACRsubinterface {
         list ATM-ACR {
             key "name"
             leaf name {
                 type string;
             }
             uses interface-atm-grouping;
         }
     }
     list BDI {
         key "name"
         leaf name {
             type string;
         }
         container service-policy {
             leaf history {
                 type empty;
             }
             leaf input {
                 type string;
             }
             leaf output {
                 type string;
             }
             container type {
                 container performance-monitor {
                     leaf direction {
                         type enumeration;
                     }
                     leaf name {
                         type string;
                     }
                 }
                 container service-chain {
                     leaf direction {
                         type enumeration;
                     }
                     leaf name {
                         type string;
                     }
                 }
             }
         }
         uses interface-common-grouping;
     }
     list CEM {
         key "name"
         leaf name {
             type string;
         }
         uses interface-atm-grouping;
     }
     list CEM-ACR {
         key "name"
         leaf name {
             type uint8;
         }
         uses interface-atm-grouping;
     }
     list Embedded-Service-Engine {
         key "name"
         leaf name {
             type string;
         }
         container service-policy {
             leaf history {
                 type empty;
             }
             leaf input {
                 type string;
             }
             leaf output {
                 type string;
             }
             container type {
                 container performance-monitor {
                     leaf direction {
                         type enumeration;
                     }
                     leaf name {
                         type string;
                     }
                 }
                 container service-chain {
                     leaf direction {
                         type enumeration;
                     }
                     leaf name {
                         type string;
                     }
                 }
             }
         }
         uses interface-common-grouping;
     }
     list FastEthernet {
         key "name"
         leaf name {
             type string;
         }
         container service-policy {
             leaf history {
                 type empty;
             }
             leaf input {
                 type string;
             }
             leaf output {
                 type string;
             }
             container type {
                 container performance-monitor {
                     leaf direction {
                         type enumeration;
                     }
                     leaf name {
                         type string;
                     }
                 }
                 container service-chain {
                     leaf direction {
                         type enumeration;
                     }
                     leaf name {
                         type string;
                     }
                 }
             }
         }
         container zone-member {
             leaf security {
                 type string;
             }
         }
         uses interface-zone-member-grouping;
         uses interface-switch-grouping;
         uses interface-ethernet-grouping;
         uses interface-common-grouping;
     }
     list GigabitEthernet {
         key "name"
         leaf name {
             type string;
         }
         leaf media-type {
             type enumeration;
         }
         leaf port-type {
             type enumeration;
         }
         container service-policy {
             leaf history {
                 type empty;
             }
             leaf input {
                 type string;
             }
             leaf output {
                 type string;
             }
             container type {
                 container performance-monitor {
                     leaf direction {
                         type enumeration;
                     }
                     leaf name {
                         type string;
                     }
                 }
                 container service-chain {
                     leaf direction {
                         type enumeration;
                     }
                     leaf name {
                         type string;
                     }
                 }
             }
         }
         container zone-member {
             leaf security {
                 type string;
             }
         }
         uses interface-zone-member-grouping;
         uses interface-switch-grouping;
         uses interface-ethernet-grouping;
         uses interface-common-grouping;
     }
     list TenGigabitEthernet {
         key "name"
         leaf name {
             type string;
         }
         leaf media-type {
             type enumeration;
         }
         leaf port-type {
             type enumeration;
         }
         container service-policy {
             leaf history {
                 type empty;
             }
             leaf input {
                 type string;
             }
             leaf output {
                 type string;
             }
             container type {
                 container performance-monitor {
                     leaf direction {
                         type enumeration;
                     }
                     leaf name {
                         type string;
                     }
                 }
                 container service-chain {
                     leaf direction {
                         type enumeration;
                     }
                     leaf name {
                         type string;
                     }
                 }
             }
         }
         container zone-member {
             leaf security {
                 type string;
             }
         }
         uses interface-zone-member-grouping;
         uses interface-switch-grouping;
         uses interface-ethernet-grouping;
         uses interface-common-grouping;
     }
     list Loopback {
         key "name"
         leaf name {
             type string;
         }
         container service-policy {
             leaf history {
                 type empty;
             }
             leaf input {
                 type string;
             }
             leaf output {
                 type string;
             }
             container type {
                 container performance-monitor {
                     leaf direction {
                         type enumeration;
                     }
                     leaf name {
                         type string;
                     }
                 }
                 container service-chain {
                     leaf direction {
                         type enumeration;
                     }
                     leaf name {
                         type string;
                     }
                 }
             }
         }
         uses interface-common-grouping;
     }
     list nve {
         key "name"
         leaf name {
             type uint16;
         }
         container source-interface {
             uses interface-grouping;
         }
         container member {
             list vni {
                 key "vni-range"
                 leaf vni-range {
                     type string;
                 }
                 container mcast-group {
                     leaf multicast-group-min {
                         type ipv4-address;
                     }
                     leaf multicast-group-max {
                         type ipv4-address;
                     }
                 }
             }
         }
     }
     list overlay {
         key "name"
         leaf name {
             type uint16;
         }
         container service-policy {
             leaf history {
                 type empty;
             }
             leaf input {
                 type string;
             }
             leaf output {
                 type string;
             }
             container type {
                 container performance-monitor {
                     leaf direction {
                         type enumeration;
                     }
                     leaf name {
                         type string;
                     }
                 }
                 container service-chain {
                     leaf direction {
                         type enumeration;
                     }
                     leaf name {
                         type string;
                     }
                 }
             }
         }
         uses interface-overlay-grouping;
         uses interface-ethernet-grouping;
         uses interface-common-grouping;
     }
     list Port-channel {
         key "name"
         leaf name {
             type uint32;
         }
         leaf pc-speed {
             type enumeration;
         }
         container service-policy {
             leaf history {
                 type empty;
             }
             leaf input {
                 type string;
             }
             leaf output {
                 type string;
             }
             container type {
                 container performance-monitor {
                     leaf direction {
                         type enumeration;
                     }
                     leaf name {
                         type string;
                     }
                 }
                 container service-chain {
                     leaf direction {
                         type enumeration;
                     }
                     leaf name {
                         type string;
                     }
                 }
             }
         }
         uses interface-switch-grouping;
         uses interface-ethernet-grouping;
         uses interface-common-grouping;
     }
     container Port-channel-subinterface {
         list Port-channel {
             key "name"
             leaf name {
                 type string;
             }
             container service-policy {
                 leaf history {
                     type empty;
                 }
                 leaf input {
                     type string;
                 }
                 leaf output {
                     type string;
                 }
                 container type {
                     container performance-monitor {
                         leaf direction {
                             type enumeration;
                         }
                         leaf name {
                             type string;
                         }
                     }
                     container service-chain {
                         leaf direction {
                             type enumeration;
                         }
                         leaf name {
                             type string;
                         }
                     }
                 }
             }
             uses interface-switch-grouping;
             uses interface-ethernet-grouping;
             uses interface-common-grouping;
         }
     }
     list pseudowire {
         key "name"
         leaf name {
             type uint32;
         }
         uses pseudowire-grouping;
     }
     list SM {
         key "name"
         leaf name {
             type string;
         }
         container service-policy {
             leaf history {
                 type empty;
             }
             leaf input {
                 type string;
             }
             leaf output {
                 type string;
             }
             container type {
                 container performance-monitor {
                     leaf direction {
                         type enumeration;
                     }
                     leaf name {
                         type string;
                     }
                 }
                 container service-chain {
                     leaf direction {
                         type enumeration;
                     }
                     leaf name {
                         type string;
                     }
                 }
             }
         }
         uses interface-common-grouping;
     }
     list Cellular {
         key "name"
         leaf name {
             type string;
         }
         container service-policy {
             leaf history {
                 type empty;
             }
             leaf input {
                 type string;
             }
             leaf output {
                 type string;
             }
             container type {
                 container performance-monitor {
                     leaf direction {
                         type enumeration;
                     }
                     leaf name {
                         type string;
                     }
                 }
                 container service-chain {
                     leaf direction {
                         type enumeration;
                     }
                     leaf name {
                         type string;
                     }
                 }
             }
         }
         container dialer {
             leaf in-band {
                 type empty;
             }
             leaf idle-timeout {
                 type uint32;
             }
             leaf string {
                 type string;
             }
             leaf watch-group {
                 type uint32;
             }
         }
         container async {
             leaf mode {
                 type enumeration;
             }
         }
         uses interface-cellular-grouping;
         uses interface-common-grouping;
     }
     list Vlan {
         key "name"
         leaf name {
             type uint16;
         }
         container service-policy {
             leaf history {
                 type empty;
             }
             leaf input {
                 type string;
             }
             leaf output {
                 type string;
             }
             container type {
                 container performance-monitor {
                     leaf direction {
                         type enumeration;
                     }
                     leaf name {
                         type string;
                     }
                 }
                 container service-chain {
                     leaf direction {
                         type enumeration;
                     }
                     leaf name {
                         type string;
                     }
                 }
             }
         }
         container zone-member {
             leaf security {
                 type string;
             }
         }
         uses interface-zone-member-grouping;
         uses interface-common-grouping;
     }
     list Group-Async {
         key "name"
         leaf name {
             type uint16;
         }
         leaf physical-layer {
             type enumeration;
         }
         container service-policy {
             leaf history {
                 type empty;
             }
             leaf input {
                 type string;
             }
             leaf output {
                 type string;
             }
             container type {
                 container performance-monitor {
                     leaf direction {
                         type enumeration;
                     }
                     leaf name {
                         type string;
                     }
                 }
                 container service-chain {
                     leaf direction {
                         type enumeration;
                     }
                     leaf name {
                         type string;
                     }
                 }
             }
         }
         uses interface-common-grouping;
     }
     list Multilink {
         key "name"
         leaf name {
             type uint16;
         }
         container service-policy {
             leaf history {
                 type empty;
             }
             leaf input {
                 type string;
             }
             leaf output {
                 type string;
             }
             container type {
                 container performance-monitor {
                     leaf direction {
                         type enumeration;
                     }
                     leaf name {
                         type string;
                     }
                 }
                 container service-chain {
                     leaf direction {
                         type enumeration;
                     }
                     leaf name {
                         type string;
                     }
                 }
             }
         }
         uses interface-pointtopoint-grouping;
         uses interface-common-grouping;
     }
     list Serial {
         key "name"
         leaf name {
             type string;
         }
         container service-policy {
             leaf history {
                 type empty;
             }
             leaf input {
                 type string;
             }
             leaf output {
                 type string;
             }
             container type {
                 container performance-monitor {
                     leaf direction {
                         type enumeration;
                     }
                     leaf name {
                         type string;
                     }
                 }
                 container service-chain {
                     leaf direction {
                         type enumeration;
                     }
                     leaf name {
                         type string;
                     }
                 }
             }
         }
         uses interface-pointtopoint-grouping;
         uses interface-common-grouping;
     }
     list Tunnel {
         key "name"
         leaf name {
             type uint32;
         }
         container service-policy {
             leaf history {
                 type empty;
             }
             leaf input {
                 type string;
             }
             leaf output {
                 type string;
             }
             container type {
                 container performance-monitor {
                     leaf direction {
                         type enumeration;
                     }
                     leaf name {
                         type string;
                     }
                 }
                 container service-chain {
                     leaf direction {
                         type enumeration;
                     }
                     leaf name {
                         type string;
                     }
                 }
             }
         }
         container qos {
             leaf pre-classify {
                 type empty;
             }
         }
         uses interface-common-grouping;
         uses interface-tunnel-grouping;
     }
     list Virtual-Template {
         key "name"
         leaf name {
             type uint16;
         }
         leaf type {
             type enumeration;
         }
         container service-policy {
             leaf history {
                 type empty;
             }
             leaf input {
                 type string;
             }
             leaf output {
                 type string;
             }
             container type {
                 container performance-monitor {
                     leaf direction {
                         type enumeration;
                     }
                     leaf name {
                         type string;
                     }
                 }
                 container service-chain {
                     leaf direction {
                         type enumeration;
                     }
                     leaf name {
                         type string;
                     }
                 }
             }
         }
         container zone-member {
             leaf security {
                 type string;
             }
         }
         uses interface-pointtopoint-grouping;
         uses interface-zone-member-grouping;
         uses interface-switch-grouping;
         uses interface-ethernet-grouping;
         uses interface-common-grouping;
         uses interface-tunnel-grouping;
     }
     list VirtualPortGroup {
         key "name"
         leaf name {
             type uint16;
         }
         container service-policy {
             leaf history {
                 type empty;
             }
             leaf input {
                 type string;
             }
             leaf output {
                 type string;
             }
             container type {
                 container performance-monitor {
                     leaf direction {
                         type enumeration;
                     }
                     leaf name {
                         type string;
                     }
                 }
                 container service-chain {
                     leaf direction {
                         type enumeration;
                     }
                     leaf name {
                         type string;
                     }
                 }
             }
         }
         uses interface-switch-grouping;
         uses interface-ethernet-grouping;
         uses interface-common-grouping;
     }
     list vasileft {
         key "name"
         leaf name {
             type uint16;
         }
         container service-policy {
             leaf history {
                 type empty;
             }
             leaf input {
                 type string;
             }
             leaf output {
                 type string;
             }
             container type {
                 container performance-monitor {
                     leaf direction {
                         type enumeration;
                     }
                     leaf name {
                         type string;
                     }
                 }
                 container service-chain {
                     leaf direction {
                         type enumeration;
                     }
                     leaf name {
                         type string;
                     }
                 }
             }
         }
         uses interface-switch-grouping;
         uses interface-ethernet-grouping;
         uses interface-common-grouping;
     }
     list vasiright {
         key "name"
         leaf name {
             type uint16;
         }
         container service-policy {
             leaf history {
                 type empty;
             }
             leaf input {
                 type string;
             }
             leaf output {
                 type string;
             }
             container type {
                 container performance-monitor {
                     leaf direction {
                         type enumeration;
                     }
                     leaf name {
                         type string;
                     }
                 }
                 container service-chain {
                     leaf direction {
                         type enumeration;
                     }
                     leaf name {
                         type string;
                     }
                 }
             }
         }
         uses interface-switch-grouping;
         uses interface-ethernet-grouping;
         uses interface-common-grouping;
     }
 }

The schema path to identify an instance is ned/native/interface

To create instances of this class use InterfaceBuilder.

See Also:: InterfaceBuilder

Field Summary

Fields
Modifier and Type Field and Description

static org.opendaylight.yangtools.yang.common.QName QNAME

Fields
Modifier and Type	Field and Description
`static org.opendaylight.yangtools.yang.common.QName`	`QNAME`

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`List<AppNavCompress>`	`getAppNavCompress()` Service-Context Virtual Interface Compress
`List<AppNavUnCompress>`	`getAppNavUnCompress()` Service-Context Virtual Interface UnCompress
`List<ATM>`	`getATM()` ATM interface
`List<ATMACR>`	`getATMACR()` ATM-ACR interface
`ATMACRsubinterface`	`getATMACRsubinterface()`
`ATMSubinterface`	`getATMSubinterface()`
`List<BDI>`	`getBDI()` Bridge-Domain interface
`List<Cellular>`	`getCellular()` Cellular Interface
`List<CEM>`	`getCEM()` Circuit Emulation interface
`List<CEMACR>`	`getCEMACR()` Circuit Emulation interface
`List<EmbeddedServiceEngine>`	`getEmbeddedServiceEngine()` cisco embedded service engine module
`List<FastEthernet>`	`getFastEthernet()` FastEthernet IEEE 802.3
`List<GigabitEthernet>`	`getGigabitEthernet()` GigabitEthernet IEEE 802.3z
`List<GroupAsync>`	`getGroupAsync()` Async Group interface
`List<Loopback>`	`getLoopback()` Loopback interface
`List<Multilink>`	`getMultilink()` Multilink-group interface
`List<Nve>`	`getNve()` Network virtualization endpoint interface
`List<Overlay>`	`getOverlay()` Overlay interface
`List<PortChannel>`	`getPortChannel()` Ethernet Channel of interfaces
`PortChannelSubinterface`	`getPortChannelSubinterface()`
`List<Pseudowire>`	`getPseudowire()` Pseudowire Interface
`List<Serial>`	`getSerial()` Serial interface
`List<SM>`	`getSM()` SM Interface
`List<TenGigabitEthernet>`	`getTenGigabitEthernet()` Ten Gigabit Ethernet
`List<Tunnel>`	`getTunnel()` Tunnel interface
`List<Vasileft>`	`getVasileft()` vasileft
`List<Vasiright>`	`getVasiright()` vasiright
`List<VirtualPortGroup>`	`getVirtualPortGroup()` Virtual Port Group
`List<VirtualTemplate>`	`getVirtualTemplate()` Virtual Template interface
`List<Vlan>`	`getVlan()` Catalyst Vlans

Methods inherited from interface org.opendaylight.yangtools.yang.binding.DataContainer
getImplementedInterface

Methods inherited from interface org.opendaylight.yangtools.yang.binding.Augmentable
getAugmentation

- Field Detail
  - QNAME
```
static final org.opendaylight.yangtools.yang.common.QName QNAME
```
- Method Detail
  - getAppNavCompress
```
List<AppNavCompress> getAppNavCompress()
```
    Service-Context Virtual Interface Compress
    
    Returns:
    
    java.util.List appNavCompress, or null if not present
  - getAppNavUnCompress
```
List<AppNavUnCompress> getAppNavUnCompress()
```
    Service-Context Virtual Interface UnCompress
    
    Returns:
    
    java.util.List appNavUnCompress, or null if not present
  - getATM
```
List<ATM> getATM()
```
    ATM interface
    
    Returns:
    
    java.util.List aTM, or null if not present
  - getATMSubinterface
```
ATMSubinterface getATMSubinterface()
```
    Returns:
    
    org.opendaylight.yang.gen.v1.urn.ios.rev160308._native._interface.ATMSubinterface aTMSubinterface, or null if not present
  - getATMACR
```
List<ATMACR> getATMACR()
```
    ATM-ACR interface
    
    Returns:
    
    java.util.List aTMACR, or null if not present
  - getATMACRsubinterface
```
ATMACRsubinterface getATMACRsubinterface()
```
    Returns:
    
    org.opendaylight.yang.gen.v1.urn.ios.rev160308._native._interface.ATMACRsubinterface aTMACRsubinterface, or null if not present
  - getBDI
```
List<BDI> getBDI()
```
    Bridge-Domain interface
    
    Returns:
    
    java.util.List bDI, or null if not present
  - getCEM
```
List<CEM> getCEM()
```
    Circuit Emulation interface
    
    Returns:
    
    java.util.List cEM, or null if not present
  - getCEMACR
```
List<CEMACR> getCEMACR()
```
    Circuit Emulation interface
    
    Returns:
    
    java.util.List cEMACR, or null if not present
  - getEmbeddedServiceEngine
```
List<EmbeddedServiceEngine> getEmbeddedServiceEngine()
```
    cisco embedded service engine module
    
    Returns:
    
    java.util.List embeddedServiceEngine, or null if not present
  - getFastEthernet
```
List<FastEthernet> getFastEthernet()
```
    FastEthernet IEEE 802.3
    
    Returns:
    
    java.util.List fastEthernet, or null if not present
  - getGigabitEthernet
```
List<GigabitEthernet> getGigabitEthernet()
```
    GigabitEthernet IEEE 802.3z
    
    Returns:
    
    java.util.List gigabitEthernet, or null if not present
  - getTenGigabitEthernet
```
List<TenGigabitEthernet> getTenGigabitEthernet()
```
    Ten Gigabit Ethernet
    
    Returns:
    
    java.util.List tenGigabitEthernet, or null if not present
  - getLoopback
```
List<Loopback> getLoopback()
```
    Loopback interface
    
    Returns:
    
    java.util.List loopback, or null if not present
  - getNve
```
List<Nve> getNve()
```
    Network virtualization endpoint interface
    
    Returns:
    
    java.util.List nve, or null if not present
  - getOverlay
```
List<Overlay> getOverlay()
```
    Overlay interface
    
    Returns:
    
    java.util.List overlay, or null if not present
  - getPortChannel
```
List<PortChannel> getPortChannel()
```
    Ethernet Channel of interfaces
    
    Returns:
    
    java.util.List portChannel, or null if not present
  - getPortChannelSubinterface
```
PortChannelSubinterface getPortChannelSubinterface()
```
    Returns:
    
    org.opendaylight.yang.gen.v1.urn.ios.rev160308._native._interface.PortChannelSubinterface portChannelSubinterface, or null if not present
  - getPseudowire
```
List<Pseudowire> getPseudowire()
```
    Pseudowire Interface
    
    Returns:
    
    java.util.List pseudowire, or null if not present
  - getSM
```
List<SM> getSM()
```
    SM Interface
    
    Returns:
    
    java.util.List sM, or null if not present
  - getCellular
```
List<Cellular> getCellular()
```
    Cellular Interface
    
    Returns:
    
    java.util.List cellular, or null if not present
  - getVlan
```
List<Vlan> getVlan()
```
    Catalyst Vlans
    
    Returns:
    
    java.util.List vlan, or null if not present
  - getGroupAsync
```
List<GroupAsync> getGroupAsync()
```
    Async Group interface
    
    Returns:
    
    java.util.List groupAsync, or null if not present
  - getMultilink
```
List<Multilink> getMultilink()
```
    Multilink-group interface
    
    Returns:
    
    java.util.List multilink, or null if not present
  - getSerial
```
List<Serial> getSerial()
```
    Serial interface
    
    Returns:
    
    java.util.List serial, or null if not present
  - getTunnel
```
List<Tunnel> getTunnel()
```
    Tunnel interface
    
    Returns:
    
    java.util.List tunnel, or null if not present
  - getVirtualTemplate
```
List<VirtualTemplate> getVirtualTemplate()
```
    Virtual Template interface
    
    Returns:
    
    java.util.List virtualTemplate, or null if not present
  - getVirtualPortGroup
```
List<VirtualPortGroup> getVirtualPortGroup()
```
    Virtual Port Group
    
    Returns:
    
    java.util.List virtualPortGroup, or null if not present
  - getVasileft
```
List<Vasileft> getVasileft()
```
    vasileft
    
    Returns:
    
    java.util.List vasileft, or null if not present
  - getVasiright
```
List<Vasiright> getVasiright()
```
    vasiright
    
    Returns:
    
    java.util.List vasiright, or null if not present

Interface Interface

Field Summary

Method Summary

Methods inherited from interface org.opendaylight.yangtools.yang.binding.DataContainer

Methods inherited from interface org.opendaylight.yangtools.yang.binding.Augmentable

Field Detail

QNAME

Method Detail

getAppNavCompress

getAppNavUnCompress

getATM

getATMSubinterface

getATMACR

getATMACRsubinterface

getBDI

getCEM

getCEMACR

getEmbeddedServiceEngine

getFastEthernet

getGigabitEthernet

getTenGigabitEthernet

getLoopback

getNve

getOverlay

getPortChannel

getPortChannelSubinterface

getPseudowire

getSM

getCellular

getVlan

getGroupAsync

getMultilink

getSerial

getTunnel

getVirtualTemplate

getVirtualPortGroup

getVasileft

getVasiright