cisco_tap2_mib.go

// This module manages Cisco's intercept feature.
// This MIB replaces CISCO-TAP-MIB. This MIB defines
// a generic stream table that contains fields common to
// all intercept types. Specific intercept filters are
// defined in extension MIBs. They are CISCO-IP-TAP-MIB
// for IP intercepts, CISCO-802-TAP-MIB for IEEE 802
// intercepts and CISCO-USER-CONNECTION-TAP-MIB for
// RADIUS-based user connection intercepts.
package cisco_tap2_mib

import (
    "fmt"
    "github.com/CiscoDevNet/ydk-go/ydk"
    "github.com/CiscoDevNet/ydk-go/ydk/types"
    "github.com/CiscoDevNet/ydk-go/ydk/types/yfilter"
    "github.com/CiscoDevNet/ydk-go/ydk/models/cisco_ios_xe"
    "reflect"
)

func init() {
    ydk.YLogDebug(fmt.Sprintf("Registering top level entities for package cisco_tap2_mib"))
    ydk.RegisterEntity("{urn:ietf:params:xml:ns:yang:smiv2:CISCO-TAP2-MIB CISCO-TAP2-MIB}", reflect.TypeOf(CISCOTAP2MIB{}))
    ydk.RegisterEntity("CISCO-TAP2-MIB:CISCO-TAP2-MIB", reflect.TypeOf(CISCOTAP2MIB{}))
}

// CISCOTAP2MIB
type CISCOTAP2MIB struct {
    EntityData types.CommonEntityData
    YFilter yfilter.YFilter

    
    CTap2MediationGroup CISCOTAP2MIB_CTap2MediationGroup

    
    CTap2DebugGroup CISCOTAP2MIB_CTap2DebugGroup

    // This table lists the Mediation Devices with which the intercepting device
    // communicates. These may be on the same or different Mediation Devices.  
    // This table is written by the Mediation Device, and is always volatile. This
    // is because intercepts may disappear during a restart of the intercepting
    // equipment.  Entries are added to this table via cTap2MediationStatus in 
    // accordance with the RowStatus convention.
    CTap2MediationTable CISCOTAP2MIB_CTap2MediationTable

    // The Intercept Stream Table lists the traffic streams to be intercepted. The
    // same data stream may be required by multiple  taps, and one might assume
    // that often the intercepted stream  is a small subset of the traffic that
    // could be intercepted.   The Table consists of generic fields that are
    // independent of the type of intercept. It contains type of the specific 
    // filter which is defined in an extension MIB and counters to  account for
    // packets intercepted or dropped by the attached filter specification.  Note
    // that the Mediation Device must make sure there is  only one type of
    // specific filter created with the same  indices as that of a row in this
    // table, otherwise the  later creations will fail. For example, if there is a
    // row in this table with index 1.2, there can be a  corresponding row with
    // the same index either in  citapStreamTable, c8tapStreamTable or
    // cuctTapStreamTable, but not all.    The first index indicates which
    // Mediation Device the intercepted traffic will be diverted to. The second
    // index permits multiple classifiers to be used together.   Entries are added
    // to this table via cTap2StreamStatus in accordance with the RowStatus
    // convention.
    CTap2StreamTable CISCOTAP2MIB_CTap2StreamTable

    // A table that contains Lawful Intercept debug messages generated by the
    // implementing device. This table is used  by ciscoTap2MediationDebug and
    // ciscoTap2StreamDebug  notifications.  An entry in this table contains a
    // debug message which is regarding either a Mediation Device or a intercept
    // stream  created by a Mediation Device. The Mediation device is  identified
    // by cTap2DebugMediationId whose value is that of cTap2MediationContentId of
    // cTapMediationEntry. The stream is identified by cTap2DebugMediationId and
    // cTap2DebugStreamId whose values are that of  cTap2MediationContentId and
    // cTap2StreamIndex of  the corresponding cTap2StreamEntry.  Note that
    // cTap2DebugStreamId may be zero for an entry, in which case the debug
    // message is regarding a Medation Device.  Entries are added to this table
    // via cTap2DebugStatus in accordance with the RowStatus convention.
    CTap2DebugTable CISCOTAP2MIB_CTap2DebugTable

    // The User Table lists information of all the users configured in the system
    // who are given permission by different Mediation Devices to access Lawful
    // Intercept CLIs.  This table will have dependancy on cTap2MediationTable.
    // When entry in cTap2MediationTable is deleted or moved to 'notInService',
    // entries corresponding cTap2MediationContentId in this table will be
    // deleted.
    CTap2DebugUserTable CISCOTAP2MIB_CTap2DebugUserTable
}

func (cISCOTAP2MIB *CISCOTAP2MIB) GetEntityData() *types.CommonEntityData {
    cISCOTAP2MIB.EntityData.YFilter = cISCOTAP2MIB.YFilter
    cISCOTAP2MIB.EntityData.YangName = "CISCO-TAP2-MIB"
    cISCOTAP2MIB.EntityData.BundleName = "cisco_ios_xe"
    cISCOTAP2MIB.EntityData.ParentYangName = "CISCO-TAP2-MIB"
    cISCOTAP2MIB.EntityData.SegmentPath = "CISCO-TAP2-MIB:CISCO-TAP2-MIB"
    cISCOTAP2MIB.EntityData.AbsolutePath = cISCOTAP2MIB.EntityData.SegmentPath
    cISCOTAP2MIB.EntityData.CapabilitiesTable = cisco_ios_xe.GetCapabilities()
    cISCOTAP2MIB.EntityData.NamespaceTable = cisco_ios_xe.GetNamespaces()
    cISCOTAP2MIB.EntityData.BundleYangModelsLocation = cisco_ios_xe.GetModelsPath()

    cISCOTAP2MIB.EntityData.Children = types.NewOrderedMap()
    cISCOTAP2MIB.EntityData.Children.Append("cTap2MediationGroup", types.YChild{"CTap2MediationGroup", &cISCOTAP2MIB.CTap2MediationGroup})
    cISCOTAP2MIB.EntityData.Children.Append("cTap2DebugGroup", types.YChild{"CTap2DebugGroup", &cISCOTAP2MIB.CTap2DebugGroup})
    cISCOTAP2MIB.EntityData.Children.Append("cTap2MediationTable", types.YChild{"CTap2MediationTable", &cISCOTAP2MIB.CTap2MediationTable})
    cISCOTAP2MIB.EntityData.Children.Append("cTap2StreamTable", types.YChild{"CTap2StreamTable", &cISCOTAP2MIB.CTap2StreamTable})
    cISCOTAP2MIB.EntityData.Children.Append("cTap2DebugTable", types.YChild{"CTap2DebugTable", &cISCOTAP2MIB.CTap2DebugTable})
    cISCOTAP2MIB.EntityData.Children.Append("cTap2DebugUserTable", types.YChild{"CTap2DebugUserTable", &cISCOTAP2MIB.CTap2DebugUserTable})
    cISCOTAP2MIB.EntityData.Leafs = types.NewOrderedMap()

    cISCOTAP2MIB.EntityData.YListKeys = []string {}

    return &(cISCOTAP2MIB.EntityData)
}

// CISCOTAP2MIB_CTap2MediationGroup
type CISCOTAP2MIB_CTap2MediationGroup struct {
    EntityData types.CommonEntityData
    YFilter yfilter.YFilter

    // This object contains a value which may be used as an index value for a new
    // cTap2MediationEntry. Whenever read, the agent will change the value to a
    // new non-conflicting value.  This is to reduce the probability of errors
    // during creation of new cTap2MediationTable entries. The type is interface{}
    // with range: 1..2147483647.
    CTap2MediationNewIndex interface{}

    // This object displays the device capabilities with respect to certain fields
    // in Mediation Device table. This may be dependent on hardware capabilities,
    // software capabilities. The following values may be supported:    
    // ipV4SrcInterface:  SNMP ifIndex Value may be used to select                
    // the interface (denoted by                       
    // cTap2MediationSrcInterface) on the                        intercepting
    // device from which to                        transmit intercepted data to an
    // IPv4                        address Mediation Device.      
    // ipV6SrcInterface:  SNMP ifIndex Value may be used to select                
    // the interface (denoted by                       
    // cTap2MediationSrcInterface) on the                        intercepting
    // device from which to                        transmit intercepted data to an
    // IPv6                        address Mediation Device.       udp:           
    // UDP may be used as transport protocol                        (denoted by
    // cTap2MediationTransport) in                        transferring intercepted
    // data to the                        Mediation Device.       rtcpNack:       
    // RTP with Nack resilience may be used                        as transport
    // protocol (denoted by                        cTap2MediationTransport) in
    // transferring                        intercepted data to the Mediation      
    // Device.      tcp:               TCP may be used as transport protocol      
    // (denoted by cTap2MediationTransport) in                        transferring
    // intercepted data to the                        Mediation Device.      
    // sctp:              SCTP may be used as transport protocol                  
    // (denoted by cTap2MediationTransport) in                        transferring
    // intercepted data to the                        Mediation Device.      rtp: 
    // RTP may be used as transport protocol                        (denoted by
    // cTap2MediationTransport) in                        transferring intercepted
    // data to the                        Mediation Device.       radius:         
    // Radius may be used as transport protocol                        (denoted by
    // cTap2MediationTransport) in                        transferring intercepted
    // information to                         the Mediation Device. The type is
    // map[string]bool.
    CTap2MediationCapabilities interface{}
}

func (cTap2MediationGroup *CISCOTAP2MIB_CTap2MediationGroup) GetEntityData() *types.CommonEntityData {
    cTap2MediationGroup.EntityData.YFilter = cTap2MediationGroup.YFilter
    cTap2MediationGroup.EntityData.YangName = "cTap2MediationGroup"
    cTap2MediationGroup.EntityData.BundleName = "cisco_ios_xe"
    cTap2MediationGroup.EntityData.ParentYangName = "CISCO-TAP2-MIB"
    cTap2MediationGroup.EntityData.SegmentPath = "cTap2MediationGroup"
    cTap2MediationGroup.EntityData.AbsolutePath = "CISCO-TAP2-MIB:CISCO-TAP2-MIB/" + cTap2MediationGroup.EntityData.SegmentPath
    cTap2MediationGroup.EntityData.CapabilitiesTable = cisco_ios_xe.GetCapabilities()
    cTap2MediationGroup.EntityData.NamespaceTable = cisco_ios_xe.GetNamespaces()
    cTap2MediationGroup.EntityData.BundleYangModelsLocation = cisco_ios_xe.GetModelsPath()

    cTap2MediationGroup.EntityData.Children = types.NewOrderedMap()
    cTap2MediationGroup.EntityData.Leafs = types.NewOrderedMap()
    cTap2MediationGroup.EntityData.Leafs.Append("cTap2MediationNewIndex", types.YLeaf{"CTap2MediationNewIndex", cTap2MediationGroup.CTap2MediationNewIndex})
    cTap2MediationGroup.EntityData.Leafs.Append("cTap2MediationCapabilities", types.YLeaf{"CTap2MediationCapabilities", cTap2MediationGroup.CTap2MediationCapabilities})

    cTap2MediationGroup.EntityData.YListKeys = []string {}

    return &(cTap2MediationGroup.EntityData)
}

// CISCOTAP2MIB_CTap2DebugGroup
type CISCOTAP2MIB_CTap2DebugGroup struct {
    EntityData types.CommonEntityData
    YFilter yfilter.YFilter

    // This object contains the duration in minutes for which an entry in
    // cTap2DebugTable is maintained by the implementing device after which the
    // entry is deleted. The management station also has the option of deleting
    // the entry itself by setting cTap2DebugStatus. The type is interface{} with
    // range: 1..2147483647.
    CTap2DebugAge interface{}

    // This object contains the maximum number of debug messages maintained by the
    // implementing device at a time. If this  limit is crossed, most recent
    // message will replace the least recent message. The type is interface{} with
    // range: 1..2147483647.
    CTap2DebugMaxEntries interface{}
}

func (cTap2DebugGroup *CISCOTAP2MIB_CTap2DebugGroup) GetEntityData() *types.CommonEntityData {
    cTap2DebugGroup.EntityData.YFilter = cTap2DebugGroup.YFilter
    cTap2DebugGroup.EntityData.YangName = "cTap2DebugGroup"
    cTap2DebugGroup.EntityData.BundleName = "cisco_ios_xe"
    cTap2DebugGroup.EntityData.ParentYangName = "CISCO-TAP2-MIB"
    cTap2DebugGroup.EntityData.SegmentPath = "cTap2DebugGroup"
    cTap2DebugGroup.EntityData.AbsolutePath = "CISCO-TAP2-MIB:CISCO-TAP2-MIB/" + cTap2DebugGroup.EntityData.SegmentPath
    cTap2DebugGroup.EntityData.CapabilitiesTable = cisco_ios_xe.GetCapabilities()
    cTap2DebugGroup.EntityData.NamespaceTable = cisco_ios_xe.GetNamespaces()
    cTap2DebugGroup.EntityData.BundleYangModelsLocation = cisco_ios_xe.GetModelsPath()

    cTap2DebugGroup.EntityData.Children = types.NewOrderedMap()
    cTap2DebugGroup.EntityData.Leafs = types.NewOrderedMap()
    cTap2DebugGroup.EntityData.Leafs.Append("cTap2DebugAge", types.YLeaf{"CTap2DebugAge", cTap2DebugGroup.CTap2DebugAge})
    cTap2DebugGroup.EntityData.Leafs.Append("cTap2DebugMaxEntries", types.YLeaf{"CTap2DebugMaxEntries", cTap2DebugGroup.CTap2DebugMaxEntries})

    cTap2DebugGroup.EntityData.YListKeys = []string {}

    return &(cTap2DebugGroup.EntityData)
}

// CISCOTAP2MIB_CTap2MediationTable
// This table lists the Mediation Devices with which the
// intercepting device communicates. These may be on the same or
// different Mediation Devices.
// 
// 
// This table is written by the Mediation Device, and is always
// volatile. This is because intercepts may disappear during a
// restart of the intercepting equipment.
// 
// Entries are added to this table via cTap2MediationStatus in 
// accordance with the RowStatus convention.
type CISCOTAP2MIB_CTap2MediationTable struct {
    EntityData types.CommonEntityData
    YFilter yfilter.YFilter

    // The entry describes a single session maintained with an application on a
    // Mediation Device. The type is slice of
    // CISCOTAP2MIB_CTap2MediationTable_CTap2MediationEntry.
    CTap2MediationEntry []*CISCOTAP2MIB_CTap2MediationTable_CTap2MediationEntry
}

func (cTap2MediationTable *CISCOTAP2MIB_CTap2MediationTable) GetEntityData() *types.CommonEntityData {
    cTap2MediationTable.EntityData.YFilter = cTap2MediationTable.YFilter
    cTap2MediationTable.EntityData.YangName = "cTap2MediationTable"
    cTap2MediationTable.EntityData.BundleName = "cisco_ios_xe"
    cTap2MediationTable.EntityData.ParentYangName = "CISCO-TAP2-MIB"
    cTap2MediationTable.EntityData.SegmentPath = "cTap2MediationTable"
    cTap2MediationTable.EntityData.AbsolutePath = "CISCO-TAP2-MIB:CISCO-TAP2-MIB/" + cTap2MediationTable.EntityData.SegmentPath
    cTap2MediationTable.EntityData.CapabilitiesTable = cisco_ios_xe.GetCapabilities()
    cTap2MediationTable.EntityData.NamespaceTable = cisco_ios_xe.GetNamespaces()
    cTap2MediationTable.EntityData.BundleYangModelsLocation = cisco_ios_xe.GetModelsPath()

    cTap2MediationTable.EntityData.Children = types.NewOrderedMap()
    cTap2MediationTable.EntityData.Children.Append("cTap2MediationEntry", types.YChild{"CTap2MediationEntry", nil})
    for i := range cTap2MediationTable.CTap2MediationEntry {
        cTap2MediationTable.EntityData.Children.Append(types.GetSegmentPath(cTap2MediationTable.CTap2MediationEntry[i]), types.YChild{"CTap2MediationEntry", cTap2MediationTable.CTap2MediationEntry[i]})
    }
    cTap2MediationTable.EntityData.Leafs = types.NewOrderedMap()

    cTap2MediationTable.EntityData.YListKeys = []string {}

    return &(cTap2MediationTable.EntityData)
}

// CISCOTAP2MIB_CTap2MediationTable_CTap2MediationEntry
// The entry describes a single session maintained with an
// application on a Mediation Device.
type CISCOTAP2MIB_CTap2MediationTable_CTap2MediationEntry struct {
    EntityData types.CommonEntityData
    YFilter yfilter.YFilter
    YListKey string

    // This attribute is a key. cTap2MediationContentId is a session identifier,
    // from the intercept application's perspective, and a content identifier from
    // the Mediation Device's perspective. The Mediation Device is responsible for
    // making sure these are unique, although the SNMP RowStatus row creation
    // process will help by not allowing it to create conflicting entries. Before
    // creating a new entry, a value for this variable may be obtained by reading
    // cTap2MediationNewIndex to reduce the probability of a value collision. The
    // type is interface{} with range: 1..2147483647.
    CTap2MediationContentId interface{}

    // The type of cTap2MediationDestAddress. The type is InetAddressType.
    CTap2MediationDestAddressType interface{}

    // The IP Address of the Mediation Device's network interface to which to
    // direct intercepted traffic. The type is string with length: 0..255.
    CTap2MediationDestAddress interface{}

    // The port number on the Mediation Device's network interface to which to
    // direct intercepted traffic. The type is interface{} with range: 0..65535.
    CTap2MediationDestPort interface{}

    // The interface on the intercepting device from which to transmit intercepted
    // data. If zero, any interface may be used according to normal IP practice.
    // The type is interface{} with range: 0..2147483647.
    CTap2MediationSrcInterface interface{}

    // The port number on the intercepting device to which the Mediation Devices
    // directs RTCP Receiver Reports and Nacks. This object is only relevant when
    // the value of cTap2MediationTransport is 'rtpNack'.   This port is assigned
    // by the intercepting device, rather than by the Mediation Device or manager
    // application.  The value of this MIB object has no effect before activating
    // the cTap2MediationEntry. The type is interface{} with range: 0..65535.
    CTap2MediationRtcpPort interface{}

    // The Differentiated Services Code Point the intercepting device applies to
    // the IP packets encapsulating the intercepted traffic. The type is
    // interface{} with range: 0..63.
    CTap2MediationDscp interface{}

    // If RTP with Ack/Nack resilience is selected as a transport, the mediation
    // process requires an RTP payload type for data transmissions, and a second
    // RTP payload type for retransmissions.  This is the RTP payload type for
    // transmissions.   This object is only effective when the value of
    // cTap2MediationTransport is 'rtpNack'. The type is interface{} with range:
    // 0..127.
    CTap2MediationDataType interface{}

    // If RTP with Ack/Nack resilience is selected as a transport, the mediation
    // process requires an RTP payload type for data transmissions, and a second
    // RTP payload type for retransmissions.  This is the RTP payload type for
    // retransmissions.   This object is only effective when the value of
    // cTap2MediationTransport is 'rtpNack'. The type is interface{} with range:
    // 0..127.
    CTap2MediationRetransmitType interface{}

    // The time at which this row and all related Stream Table rows should be
    // automatically removed, and the intercept function cease. Since the
    // initiating network manager may be the only device able to manage a specific
    // intercept or know of its existence, this acts as a fail-safe for the
    // failure or removal of the network manager. The object is only effective
    // when the value of cTap2MediationStatus is 'active'. The type is string.
    CTap2MediationTimeout interface{}

    // The protocol used in transferring intercepted data to the Mediation Device.
    // The following protocols may be supported:            udp:     PacketCable
    // udp format            rtpNack: RTP with Nack resilience            tcp:    
    // TCP with head of line blocking            sctp:    SCTP with head of line
    // blocking             rtp:     Realtime Transport Protocol(RTP)             
    // packet format            radius:  Use Radius, PacketCable1.5 Event Message 
    // to transport the intercepted information. The type is
    // CTap2MediationTransport.
    CTap2MediationTransport interface{}

    // This variable controls the generation of any notifications or informs by
    // the MIB agent for this table entry. The type is bool.
    CTap2MediationNotificationEnable interface{}

    // The status of this conceptual row. This object is used to manage creation,
    // modification and deletion of rows in this table.   cTap2MediationTimeout
    // may be modified at any time (even while the row is active). But when the
    // row is active, the other writable objects may not be modified without
    // setting its value to 'notInService'.   The entry may not be deleted or
    // deactivated by setting its value to 'destroy' or 'notInService' if there is
    // any associated entry in cTap2StreamTable. The type is RowStatus.
    CTap2MediationStatus interface{}

    // Radius Authentication Key is the shared secret key between  radius client
    // and server. The type is string with length: 0..64.
    CTap2MediationRadiusKey interface{}
}

func (cTap2MediationEntry *CISCOTAP2MIB_CTap2MediationTable_CTap2MediationEntry) GetEntityData() *types.CommonEntityData {
    cTap2MediationEntry.EntityData.YFilter = cTap2MediationEntry.YFilter
    cTap2MediationEntry.EntityData.YangName = "cTap2MediationEntry"
    cTap2MediationEntry.EntityData.BundleName = "cisco_ios_xe"
    cTap2MediationEntry.EntityData.ParentYangName = "cTap2MediationTable"
    cTap2MediationEntry.EntityData.SegmentPath = "cTap2MediationEntry" + types.AddKeyToken(cTap2MediationEntry.CTap2MediationContentId, "cTap2MediationContentId")
    cTap2MediationEntry.EntityData.AbsolutePath = "CISCO-TAP2-MIB:CISCO-TAP2-MIB/cTap2MediationTable/" + cTap2MediationEntry.EntityData.SegmentPath
    cTap2MediationEntry.EntityData.CapabilitiesTable = cisco_ios_xe.GetCapabilities()
    cTap2MediationEntry.EntityData.NamespaceTable = cisco_ios_xe.GetNamespaces()
    cTap2MediationEntry.EntityData.BundleYangModelsLocation = cisco_ios_xe.GetModelsPath()

    cTap2MediationEntry.EntityData.Children = types.NewOrderedMap()
    cTap2MediationEntry.EntityData.Leafs = types.NewOrderedMap()
    cTap2MediationEntry.EntityData.Leafs.Append("cTap2MediationContentId", types.YLeaf{"CTap2MediationContentId", cTap2MediationEntry.CTap2MediationContentId})
    cTap2MediationEntry.EntityData.Leafs.Append("cTap2MediationDestAddressType", types.YLeaf{"CTap2MediationDestAddressType", cTap2MediationEntry.CTap2MediationDestAddressType})
    cTap2MediationEntry.EntityData.Leafs.Append("cTap2MediationDestAddress", types.YLeaf{"CTap2MediationDestAddress", cTap2MediationEntry.CTap2MediationDestAddress})
    cTap2MediationEntry.EntityData.Leafs.Append("cTap2MediationDestPort", types.YLeaf{"CTap2MediationDestPort", cTap2MediationEntry.CTap2MediationDestPort})
    cTap2MediationEntry.EntityData.Leafs.Append("cTap2MediationSrcInterface", types.YLeaf{"CTap2MediationSrcInterface", cTap2MediationEntry.CTap2MediationSrcInterface})
    cTap2MediationEntry.EntityData.Leafs.Append("cTap2MediationRtcpPort", types.YLeaf{"CTap2MediationRtcpPort", cTap2MediationEntry.CTap2MediationRtcpPort})
    cTap2MediationEntry.EntityData.Leafs.Append("cTap2MediationDscp", types.YLeaf{"CTap2MediationDscp", cTap2MediationEntry.CTap2MediationDscp})
    cTap2MediationEntry.EntityData.Leafs.Append("cTap2MediationDataType", types.YLeaf{"CTap2MediationDataType", cTap2MediationEntry.CTap2MediationDataType})
    cTap2MediationEntry.EntityData.Leafs.Append("cTap2MediationRetransmitType", types.YLeaf{"CTap2MediationRetransmitType", cTap2MediationEntry.CTap2MediationRetransmitType})
    cTap2MediationEntry.EntityData.Leafs.Append("cTap2MediationTimeout", types.YLeaf{"CTap2MediationTimeout", cTap2MediationEntry.CTap2MediationTimeout})
    cTap2MediationEntry.EntityData.Leafs.Append("cTap2MediationTransport", types.YLeaf{"CTap2MediationTransport", cTap2MediationEntry.CTap2MediationTransport})
    cTap2MediationEntry.EntityData.Leafs.Append("cTap2MediationNotificationEnable", types.YLeaf{"CTap2MediationNotificationEnable", cTap2MediationEntry.CTap2MediationNotificationEnable})
    cTap2MediationEntry.EntityData.Leafs.Append("cTap2MediationStatus", types.YLeaf{"CTap2MediationStatus", cTap2MediationEntry.CTap2MediationStatus})
    cTap2MediationEntry.EntityData.Leafs.Append("cTap2MediationRadiusKey", types.YLeaf{"CTap2MediationRadiusKey", cTap2MediationEntry.CTap2MediationRadiusKey})

    cTap2MediationEntry.EntityData.YListKeys = []string {"CTap2MediationContentId"}

    return &(cTap2MediationEntry.EntityData)
}

// CISCOTAP2MIB_CTap2MediationTable_CTap2MediationEntry_CTap2MediationTransport represents                     to transport the intercepted information.
type CISCOTAP2MIB_CTap2MediationTable_CTap2MediationEntry_CTap2MediationTransport string

const (
    CISCOTAP2MIB_CTap2MediationTable_CTap2MediationEntry_CTap2MediationTransport_udp CISCOTAP2MIB_CTap2MediationTable_CTap2MediationEntry_CTap2MediationTransport = "udp"

    CISCOTAP2MIB_CTap2MediationTable_CTap2MediationEntry_CTap2MediationTransport_rtpNack CISCOTAP2MIB_CTap2MediationTable_CTap2MediationEntry_CTap2MediationTransport = "rtpNack"

    CISCOTAP2MIB_CTap2MediationTable_CTap2MediationEntry_CTap2MediationTransport_tcp CISCOTAP2MIB_CTap2MediationTable_CTap2MediationEntry_CTap2MediationTransport = "tcp"

    CISCOTAP2MIB_CTap2MediationTable_CTap2MediationEntry_CTap2MediationTransport_sctp CISCOTAP2MIB_CTap2MediationTable_CTap2MediationEntry_CTap2MediationTransport = "sctp"

    CISCOTAP2MIB_CTap2MediationTable_CTap2MediationEntry_CTap2MediationTransport_rtp CISCOTAP2MIB_CTap2MediationTable_CTap2MediationEntry_CTap2MediationTransport = "rtp"

    CISCOTAP2MIB_CTap2MediationTable_CTap2MediationEntry_CTap2MediationTransport_radius CISCOTAP2MIB_CTap2MediationTable_CTap2MediationEntry_CTap2MediationTransport = "radius"
)

// CISCOTAP2MIB_CTap2StreamTable
// The Intercept Stream Table lists the traffic streams to be
// intercepted. The same data stream may be required by multiple 
// taps, and one might assume that often the intercepted stream 
// is a small subset of the traffic that could be intercepted.
// 
// 
// The Table consists of generic fields that are independent
// of the type of intercept. It contains type of the specific 
// filter which is defined in an extension MIB and counters to 
// account for packets intercepted or dropped by the attached
// filter specification.
// 
// Note that the Mediation Device must make sure there is 
// only one type of specific filter created with the same 
// indices as that of a row in this table, otherwise the 
// later creations will fail. For example, if there is a 
// row in this table with index 1.2, there can be a 
// corresponding row with the same index either in 
// citapStreamTable, c8tapStreamTable or cuctTapStreamTable,
// but not all. 
// 
// 
// The first index indicates which Mediation Device the
// intercepted traffic will be diverted to. The second index
// permits multiple classifiers to be used together. 
// 
// Entries are added to this table via cTap2StreamStatus in
// accordance with the RowStatus convention.
type CISCOTAP2MIB_CTap2StreamTable struct {
    EntityData types.CommonEntityData
    YFilter yfilter.YFilter

    // A stream entry indicates a single data stream to be intercepted to a
    // Mediation Device. Many selected data streams may go to the same application
    // interface, and many application interfaces are supported. The type is slice
    // of CISCOTAP2MIB_CTap2StreamTable_CTap2StreamEntry.
    CTap2StreamEntry []*CISCOTAP2MIB_CTap2StreamTable_CTap2StreamEntry
}

func (cTap2StreamTable *CISCOTAP2MIB_CTap2StreamTable) GetEntityData() *types.CommonEntityData {
    cTap2StreamTable.EntityData.YFilter = cTap2StreamTable.YFilter
    cTap2StreamTable.EntityData.YangName = "cTap2StreamTable"
    cTap2StreamTable.EntityData.BundleName = "cisco_ios_xe"
    cTap2StreamTable.EntityData.ParentYangName = "CISCO-TAP2-MIB"
    cTap2StreamTable.EntityData.SegmentPath = "cTap2StreamTable"
    cTap2StreamTable.EntityData.AbsolutePath = "CISCO-TAP2-MIB:CISCO-TAP2-MIB/" + cTap2StreamTable.EntityData.SegmentPath
    cTap2StreamTable.EntityData.CapabilitiesTable = cisco_ios_xe.GetCapabilities()
    cTap2StreamTable.EntityData.NamespaceTable = cisco_ios_xe.GetNamespaces()
    cTap2StreamTable.EntityData.BundleYangModelsLocation = cisco_ios_xe.GetModelsPath()

    cTap2StreamTable.EntityData.Children = types.NewOrderedMap()
    cTap2StreamTable.EntityData.Children.Append("cTap2StreamEntry", types.YChild{"CTap2StreamEntry", nil})
    for i := range cTap2StreamTable.CTap2StreamEntry {
        cTap2StreamTable.EntityData.Children.Append(types.GetSegmentPath(cTap2StreamTable.CTap2StreamEntry[i]), types.YChild{"CTap2StreamEntry", cTap2StreamTable.CTap2StreamEntry[i]})
    }
    cTap2StreamTable.EntityData.Leafs = types.NewOrderedMap()

    cTap2StreamTable.EntityData.YListKeys = []string {}

    return &(cTap2StreamTable.EntityData)
}

// CISCOTAP2MIB_CTap2StreamTable_CTap2StreamEntry
// A stream entry indicates a single data stream to be
// intercepted to a Mediation Device. Many selected data
// streams may go to the same application interface, and many
// application interfaces are supported.
type CISCOTAP2MIB_CTap2StreamTable_CTap2StreamEntry struct {
    EntityData types.CommonEntityData
    YFilter yfilter.YFilter
    YListKey string

    // This attribute is a key. The type is string with range: 1..2147483647.
    // Refers to
    // cisco_tap2_mib.CISCOTAP2MIB_CTap2MediationTable_CTap2MediationEntry_CTap2MediationContentId
    CTap2MediationContentId interface{}

    // This attribute is a key. The index of the stream itself. The type is
    // interface{} with range: 1..2147483647.
    CTap2StreamIndex interface{}

    // Identifies the type of intercept filter associated to this generic stream.
    // The following types of streams are supported:        ip:             The
    // specific filter is an IP filter                         with same indices
    // as that of this                         table. The exact filter is a row in
    // citapStreamTable of CISCO-IP-TAP-MIB.        mac:            The specific
    // filter is a MAC filter                        with same indices as that of
    // this table.                        The exact filter is a row in            
    // c8tapStreamTable of CISCO-802-TAP-MIB.        userConnecton:  The specific
    // filter is a user connection                        filter with same indices
    // as that of                         this table. The exact filter is a row   
    // in cuctTapStreamTable of                        
    // CISCO-USER-CONNECTION-TAP-MIB.        msPdsn:         The specific filter
    // is a Mobile Sub                        connection filter with same indices
    // as                        that of this table. The exact filter             
    // is a row in ccptapStreamTable of                        
    // CISCO-CDMA-PDSN-TAP-MIB.        mobility:       The specific filter is a
    // Mobile                         Subscriber connection filter with same      
    // indices as that of this table. The exact                        filter is a
    // row in cmtapStreamTable of                         CISCO-MOBILITY-TAP-MIB. 
    // voip:           The specific filter is a VoIP                       
    // Subscriber filter with same                        indices as that of this
    // table. The exact                        filter is a row in
    // cvoiptapStreamTable of                        CISCO-VOIP-TAP-MIB. The type
    // is CTap2StreamType.
    CTap2StreamType interface{}

    // If 'true', the tap should intercept matching traffic. The value for this
    // object should be set to 'true' only after an  additional filter
    // specification has been attached to this  stream. The type is bool.
    CTap2StreamInterceptEnable interface{}

    // The number of packets matching this data stream specification that have
    // been intercepted. The type is interface{} with range: 0..4294967295.
    CTap2StreamInterceptedPackets interface{}

    // The number of packets matching this data stream specification that, having
    // been intercepted, were dropped in the lawful intercept process. The type is
    // interface{} with range: 0..4294967295.
    CTap2StreamInterceptDrops interface{}

    // The status of this conceptual row. This object manages creation,
    // modification, and deletion of rows in this table.
    // cTap2StreamInterceptEnable may be modified any time even the value of this
    // entry rowStatus object is 'active'.  When other rows must be changed,
    // cTap2StreamStatus must be first set to 'notInService'. The type is
    // RowStatus.
    CTap2StreamStatus interface{}

    // The number of packets matching this data stream specification that have
    // been intercepted. This object is a 64-bit version of
    // cTap2StreamInterceptedPackets. The type is interface{} with range:
    // 0..18446744073709551615.
    CTap2StreamInterceptedHCPackets interface{}

    // The number of packets matching this data stream specification that, having
    // been intercepted, were dropped in the lawful intercept process. This object
    // is a 64-bit version of cTap2StreamInterceptDrops. The type is interface{}
    // with range: 0..18446744073709551615.
    CTap2StreamInterceptHCDrops interface{}
}

func (cTap2StreamEntry *CISCOTAP2MIB_CTap2StreamTable_CTap2StreamEntry) GetEntityData() *types.CommonEntityData {
    cTap2StreamEntry.EntityData.YFilter = cTap2StreamEntry.YFilter
    cTap2StreamEntry.EntityData.YangName = "cTap2StreamEntry"
    cTap2StreamEntry.EntityData.BundleName = "cisco_ios_xe"
    cTap2StreamEntry.EntityData.ParentYangName = "cTap2StreamTable"
    cTap2StreamEntry.EntityData.SegmentPath = "cTap2StreamEntry" + types.AddKeyToken(cTap2StreamEntry.CTap2MediationContentId, "cTap2MediationContentId") + types.AddKeyToken(cTap2StreamEntry.CTap2StreamIndex, "cTap2StreamIndex")
    cTap2StreamEntry.EntityData.AbsolutePath = "CISCO-TAP2-MIB:CISCO-TAP2-MIB/cTap2StreamTable/" + cTap2StreamEntry.EntityData.SegmentPath
    cTap2StreamEntry.EntityData.CapabilitiesTable = cisco_ios_xe.GetCapabilities()
    cTap2StreamEntry.EntityData.NamespaceTable = cisco_ios_xe.GetNamespaces()
    cTap2StreamEntry.EntityData.BundleYangModelsLocation = cisco_ios_xe.GetModelsPath()

    cTap2StreamEntry.EntityData.Children = types.NewOrderedMap()
    cTap2StreamEntry.EntityData.Leafs = types.NewOrderedMap()
    cTap2StreamEntry.EntityData.Leafs.Append("cTap2MediationContentId", types.YLeaf{"CTap2MediationContentId", cTap2StreamEntry.CTap2MediationContentId})
    cTap2StreamEntry.EntityData.Leafs.Append("cTap2StreamIndex", types.YLeaf{"CTap2StreamIndex", cTap2StreamEntry.CTap2StreamIndex})
    cTap2StreamEntry.EntityData.Leafs.Append("cTap2StreamType", types.YLeaf{"CTap2StreamType", cTap2StreamEntry.CTap2StreamType})
    cTap2StreamEntry.EntityData.Leafs.Append("cTap2StreamInterceptEnable", types.YLeaf{"CTap2StreamInterceptEnable", cTap2StreamEntry.CTap2StreamInterceptEnable})
    cTap2StreamEntry.EntityData.Leafs.Append("cTap2StreamInterceptedPackets", types.YLeaf{"CTap2StreamInterceptedPackets", cTap2StreamEntry.CTap2StreamInterceptedPackets})
    cTap2StreamEntry.EntityData.Leafs.Append("cTap2StreamInterceptDrops", types.YLeaf{"CTap2StreamInterceptDrops", cTap2StreamEntry.CTap2StreamInterceptDrops})
    cTap2StreamEntry.EntityData.Leafs.Append("cTap2StreamStatus", types.YLeaf{"CTap2StreamStatus", cTap2StreamEntry.CTap2StreamStatus})
    cTap2StreamEntry.EntityData.Leafs.Append("cTap2StreamInterceptedHCPackets", types.YLeaf{"CTap2StreamInterceptedHCPackets", cTap2StreamEntry.CTap2StreamInterceptedHCPackets})
    cTap2StreamEntry.EntityData.Leafs.Append("cTap2StreamInterceptHCDrops", types.YLeaf{"CTap2StreamInterceptHCDrops", cTap2StreamEntry.CTap2StreamInterceptHCDrops})

    cTap2StreamEntry.EntityData.YListKeys = []string {"CTap2MediationContentId", "CTap2StreamIndex"}

    return &(cTap2StreamEntry.EntityData)
}

// CISCOTAP2MIB_CTap2StreamTable_CTap2StreamEntry_CTap2StreamType represents                        CISCO-VOIP-TAP-MIB.
type CISCOTAP2MIB_CTap2StreamTable_CTap2StreamEntry_CTap2StreamType string

const (
    CISCOTAP2MIB_CTap2StreamTable_CTap2StreamEntry_CTap2StreamType_ip CISCOTAP2MIB_CTap2StreamTable_CTap2StreamEntry_CTap2StreamType = "ip"

    CISCOTAP2MIB_CTap2StreamTable_CTap2StreamEntry_CTap2StreamType_mac CISCOTAP2MIB_CTap2StreamTable_CTap2StreamEntry_CTap2StreamType = "mac"

    CISCOTAP2MIB_CTap2StreamTable_CTap2StreamEntry_CTap2StreamType_userConnection CISCOTAP2MIB_CTap2StreamTable_CTap2StreamEntry_CTap2StreamType = "userConnection"

    CISCOTAP2MIB_CTap2StreamTable_CTap2StreamEntry_CTap2StreamType_msPdsn CISCOTAP2MIB_CTap2StreamTable_CTap2StreamEntry_CTap2StreamType = "msPdsn"

    CISCOTAP2MIB_CTap2StreamTable_CTap2StreamEntry_CTap2StreamType_mobility CISCOTAP2MIB_CTap2StreamTable_CTap2StreamEntry_CTap2StreamType = "mobility"

    CISCOTAP2MIB_CTap2StreamTable_CTap2StreamEntry_CTap2StreamType_voip CISCOTAP2MIB_CTap2StreamTable_CTap2StreamEntry_CTap2StreamType = "voip"
)

// CISCOTAP2MIB_CTap2DebugTable
// A table that contains Lawful Intercept debug messages
// generated by the implementing device. This table is used 
// by ciscoTap2MediationDebug and ciscoTap2StreamDebug 
// notifications.
// 
// An entry in this table contains a debug message which is
// regarding either a Mediation Device or a intercept stream 
// created by a Mediation Device. The Mediation device is 
// identified by cTap2DebugMediationId whose value is
// that of cTap2MediationContentId of cTapMediationEntry.
// The stream is identified by cTap2DebugMediationId and
// cTap2DebugStreamId whose values are that of 
// cTap2MediationContentId and cTap2StreamIndex of 
// the corresponding cTap2StreamEntry.
// 
// Note that cTap2DebugStreamId may be zero for an entry,
// in which case the debug message is regarding a Medation
// Device.
// 
// Entries are added to this table via cTap2DebugStatus in
// accordance with the RowStatus convention.
type CISCOTAP2MIB_CTap2DebugTable struct {
    EntityData types.CommonEntityData
    YFilter yfilter.YFilter

    // A list of the debug messages. The type is slice of
    // CISCOTAP2MIB_CTap2DebugTable_CTap2DebugEntry.
    CTap2DebugEntry []*CISCOTAP2MIB_CTap2DebugTable_CTap2DebugEntry
}

func (cTap2DebugTable *CISCOTAP2MIB_CTap2DebugTable) GetEntityData() *types.CommonEntityData {
    cTap2DebugTable.EntityData.YFilter = cTap2DebugTable.YFilter
    cTap2DebugTable.EntityData.YangName = "cTap2DebugTable"
    cTap2DebugTable.EntityData.BundleName = "cisco_ios_xe"
    cTap2DebugTable.EntityData.ParentYangName = "CISCO-TAP2-MIB"
    cTap2DebugTable.EntityData.SegmentPath = "cTap2DebugTable"
    cTap2DebugTable.EntityData.AbsolutePath = "CISCO-TAP2-MIB:CISCO-TAP2-MIB/" + cTap2DebugTable.EntityData.SegmentPath
    cTap2DebugTable.EntityData.CapabilitiesTable = cisco_ios_xe.GetCapabilities()
    cTap2DebugTable.EntityData.NamespaceTable = cisco_ios_xe.GetNamespaces()
    cTap2DebugTable.EntityData.BundleYangModelsLocation = cisco_ios_xe.GetModelsPath()

    cTap2DebugTable.EntityData.Children = types.NewOrderedMap()
    cTap2DebugTable.EntityData.Children.Append("cTap2DebugEntry", types.YChild{"CTap2DebugEntry", nil})
    for i := range cTap2DebugTable.CTap2DebugEntry {
        cTap2DebugTable.EntityData.Children.Append(types.GetSegmentPath(cTap2DebugTable.CTap2DebugEntry[i]), types.YChild{"CTap2DebugEntry", cTap2DebugTable.CTap2DebugEntry[i]})
    }
    cTap2DebugTable.EntityData.Leafs = types.NewOrderedMap()

    cTap2DebugTable.EntityData.YListKeys = []string {}

    return &(cTap2DebugTable.EntityData)
}

// CISCOTAP2MIB_CTap2DebugTable_CTap2DebugEntry
// A list of the debug messages.
type CISCOTAP2MIB_CTap2DebugTable_CTap2DebugEntry struct {
    EntityData types.CommonEntityData
    YFilter yfilter.YFilter
    YListKey string

    // This attribute is a key. Index to the debug table. The type is interface{}
    // with range: 1..2147483647.
    CTap2DebugIndex interface{}

    // The value of this object is that of cTap2MediationContentId identifying an
    // entry in cTap2MediationTable. Note this object may contain a value for
    // which an entry in cTap2MediationTable does not exist. This happens when
    // creation of an entry in cTap2MediationTable fails and this debug message
    // conveys more detailed information regarding the failure. The type is
    // interface{} with range: 0..4294967295.
    CTap2DebugMediationId interface{}

    // The value of this object is that of cTap2StreamIndex of an entry in
    // cTap2StreamTable. This object along with cTap2DebugMediationId identifies
    // an entry in cTap2StreamTable. The value of this object may be zero, in
    // which this debug message is regarding a Mediation Device, but not a
    // particular stream.  Note this object may contain a value for which an 
    // entry in cTap2MediationTable does not exist. This happens  when creation of
    // an entry in cTap2StreamTable fails. The type is interface{} with range:
    // 0..4294967295.
    CTap2DebugStreamId interface{}

    // A text string contains the debug message. The type is string.
    CTap2DebugMessage interface{}

    // The status of this conceptual row. A row in this table is created by the
    // implementing device. A management station cannot modify any of the objects
    // in this row, except deleting the row by setting this object to 'destroy'.
    // The type is RowStatus.
    CTap2DebugStatus interface{}
}

func (cTap2DebugEntry *CISCOTAP2MIB_CTap2DebugTable_CTap2DebugEntry) GetEntityData() *types.CommonEntityData {
    cTap2DebugEntry.EntityData.YFilter = cTap2DebugEntry.YFilter
    cTap2DebugEntry.EntityData.YangName = "cTap2DebugEntry"
    cTap2DebugEntry.EntityData.BundleName = "cisco_ios_xe"
    cTap2DebugEntry.EntityData.ParentYangName = "cTap2DebugTable"
    cTap2DebugEntry.EntityData.SegmentPath = "cTap2DebugEntry" + types.AddKeyToken(cTap2DebugEntry.CTap2DebugIndex, "cTap2DebugIndex")
    cTap2DebugEntry.EntityData.AbsolutePath = "CISCO-TAP2-MIB:CISCO-TAP2-MIB/cTap2DebugTable/" + cTap2DebugEntry.EntityData.SegmentPath
    cTap2DebugEntry.EntityData.CapabilitiesTable = cisco_ios_xe.GetCapabilities()
    cTap2DebugEntry.EntityData.NamespaceTable = cisco_ios_xe.GetNamespaces()
    cTap2DebugEntry.EntityData.BundleYangModelsLocation = cisco_ios_xe.GetModelsPath()

    cTap2DebugEntry.EntityData.Children = types.NewOrderedMap()
    cTap2DebugEntry.EntityData.Leafs = types.NewOrderedMap()
    cTap2DebugEntry.EntityData.Leafs.Append("cTap2DebugIndex", types.YLeaf{"CTap2DebugIndex", cTap2DebugEntry.CTap2DebugIndex})
    cTap2DebugEntry.EntityData.Leafs.Append("cTap2DebugMediationId", types.YLeaf{"CTap2DebugMediationId", cTap2DebugEntry.CTap2DebugMediationId})
    cTap2DebugEntry.EntityData.Leafs.Append("cTap2DebugStreamId", types.YLeaf{"CTap2DebugStreamId", cTap2DebugEntry.CTap2DebugStreamId})
    cTap2DebugEntry.EntityData.Leafs.Append("cTap2DebugMessage", types.YLeaf{"CTap2DebugMessage", cTap2DebugEntry.CTap2DebugMessage})
    cTap2DebugEntry.EntityData.Leafs.Append("cTap2DebugStatus", types.YLeaf{"CTap2DebugStatus", cTap2DebugEntry.CTap2DebugStatus})

    cTap2DebugEntry.EntityData.YListKeys = []string {"CTap2DebugIndex"}

    return &(cTap2DebugEntry.EntityData)
}

// CISCOTAP2MIB_CTap2DebugUserTable
// The User Table lists information of all the users configured
// in the system who are given permission by different Mediation
// Devices to access Lawful Intercept CLIs.
// 
// This table will have dependancy on cTap2MediationTable. When
// entry in cTap2MediationTable is deleted or moved to
// 'notInService', entries corresponding cTap2MediationContentId
// in this table will be deleted.
type CISCOTAP2MIB_CTap2DebugUserTable struct {
    EntityData types.CommonEntityData
    YFilter yfilter.YFilter

    // A conceptual row in the cTap2DebugUserTable. Each row represents name of
    // user on the router to whom Mediation Device with CCCid represented by
    // cTap2MediationContentId has given access to Lawful Intercept commands and
    // cTap2DebugUserTimeout represents the time when the entry will expire. The
    // type is slice of CISCOTAP2MIB_CTap2DebugUserTable_CTap2DebugUserEntry.
    CTap2DebugUserEntry []*CISCOTAP2MIB_CTap2DebugUserTable_CTap2DebugUserEntry
}

func (cTap2DebugUserTable *CISCOTAP2MIB_CTap2DebugUserTable) GetEntityData() *types.CommonEntityData {
    cTap2DebugUserTable.EntityData.YFilter = cTap2DebugUserTable.YFilter
    cTap2DebugUserTable.EntityData.YangName = "cTap2DebugUserTable"
    cTap2DebugUserTable.EntityData.BundleName = "cisco_ios_xe"
    cTap2DebugUserTable.EntityData.ParentYangName = "CISCO-TAP2-MIB"
    cTap2DebugUserTable.EntityData.SegmentPath = "cTap2DebugUserTable"
    cTap2DebugUserTable.EntityData.AbsolutePath = "CISCO-TAP2-MIB:CISCO-TAP2-MIB/" + cTap2DebugUserTable.EntityData.SegmentPath
    cTap2DebugUserTable.EntityData.CapabilitiesTable = cisco_ios_xe.GetCapabilities()
    cTap2DebugUserTable.EntityData.NamespaceTable = cisco_ios_xe.GetNamespaces()
    cTap2DebugUserTable.EntityData.BundleYangModelsLocation = cisco_ios_xe.GetModelsPath()

    cTap2DebugUserTable.EntityData.Children = types.NewOrderedMap()
    cTap2DebugUserTable.EntityData.Children.Append("cTap2DebugUserEntry", types.YChild{"CTap2DebugUserEntry", nil})
    for i := range cTap2DebugUserTable.CTap2DebugUserEntry {
        cTap2DebugUserTable.EntityData.Children.Append(types.GetSegmentPath(cTap2DebugUserTable.CTap2DebugUserEntry[i]), types.YChild{"CTap2DebugUserEntry", cTap2DebugUserTable.CTap2DebugUserEntry[i]})
    }
    cTap2DebugUserTable.EntityData.Leafs = types.NewOrderedMap()

    cTap2DebugUserTable.EntityData.YListKeys = []string {}

    return &(cTap2DebugUserTable.EntityData)
}

// CISCOTAP2MIB_CTap2DebugUserTable_CTap2DebugUserEntry
// A conceptual row in the cTap2DebugUserTable. Each row
// represents name of user on the router to whom Mediation Device
// with CCCid represented by cTap2MediationContentId has given
// access to Lawful Intercept commands and cTap2DebugUserTimeout
// represents the time when the entry will expire.
type CISCOTAP2MIB_CTap2DebugUserTable_CTap2DebugUserEntry struct {
    EntityData types.CommonEntityData
    YFilter yfilter.YFilter
    YListKey string

    // This attribute is a key. The type is string with range: 1..2147483647.
    // Refers to
    // cisco_tap2_mib.CISCOTAP2MIB_CTap2MediationTable_CTap2MediationEntry_CTap2MediationContentId
    CTap2MediationContentId interface{}

    // This attribute is a key. A human readable string representing the name of
    // debug user who will have access to Lawful Intercept commands. The type is
    // string with length: 1..255.
    CTap2DebugUserName interface{}

    // This object specifies the time at which the row will be removed from the
    // table by the system. The value of this object is only effective when the
    // value of corresponding instance of cTap2DebugUserStatus is 'active'. The
    // type is string.
    CTap2DebugUserTimeout interface{}

    // This object specifies the storage type of this conceptual row. If it is set
    // to 'nonVolatile', this entry can be saved into non-volatile memory. The
    // type is StorageType.
    CTap2DebugUserStorageType interface{}

    // The status of this conceptual row. This object manages creation,
    // modification, and deletion of rows in this table. cTap2DebugUserTimeout may
    // be modified any time even when the value of this entry rowStatus object is
    // 'active'. The type is RowStatus.
    CTap2DebugUserStatus interface{}
}

func (cTap2DebugUserEntry *CISCOTAP2MIB_CTap2DebugUserTable_CTap2DebugUserEntry) GetEntityData() *types.CommonEntityData {
    cTap2DebugUserEntry.EntityData.YFilter = cTap2DebugUserEntry.YFilter
    cTap2DebugUserEntry.EntityData.YangName = "cTap2DebugUserEntry"
    cTap2DebugUserEntry.EntityData.BundleName = "cisco_ios_xe"
    cTap2DebugUserEntry.EntityData.ParentYangName = "cTap2DebugUserTable"
    cTap2DebugUserEntry.EntityData.SegmentPath = "cTap2DebugUserEntry" + types.AddKeyToken(cTap2DebugUserEntry.CTap2MediationContentId, "cTap2MediationContentId") + types.AddKeyToken(cTap2DebugUserEntry.CTap2DebugUserName, "cTap2DebugUserName")
    cTap2DebugUserEntry.EntityData.AbsolutePath = "CISCO-TAP2-MIB:CISCO-TAP2-MIB/cTap2DebugUserTable/" + cTap2DebugUserEntry.EntityData.SegmentPath
    cTap2DebugUserEntry.EntityData.CapabilitiesTable = cisco_ios_xe.GetCapabilities()
    cTap2DebugUserEntry.EntityData.NamespaceTable = cisco_ios_xe.GetNamespaces()
    cTap2DebugUserEntry.EntityData.BundleYangModelsLocation = cisco_ios_xe.GetModelsPath()

    cTap2DebugUserEntry.EntityData.Children = types.NewOrderedMap()
    cTap2DebugUserEntry.EntityData.Leafs = types.NewOrderedMap()
    cTap2DebugUserEntry.EntityData.Leafs.Append("cTap2MediationContentId", types.YLeaf{"CTap2MediationContentId", cTap2DebugUserEntry.CTap2MediationContentId})
    cTap2DebugUserEntry.EntityData.Leafs.Append("cTap2DebugUserName", types.YLeaf{"CTap2DebugUserName", cTap2DebugUserEntry.CTap2DebugUserName})
    cTap2DebugUserEntry.EntityData.Leafs.Append("cTap2DebugUserTimeout", types.YLeaf{"CTap2DebugUserTimeout", cTap2DebugUserEntry.CTap2DebugUserTimeout})
    cTap2DebugUserEntry.EntityData.Leafs.Append("cTap2DebugUserStorageType", types.YLeaf{"CTap2DebugUserStorageType", cTap2DebugUserEntry.CTap2DebugUserStorageType})
    cTap2DebugUserEntry.EntityData.Leafs.Append("cTap2DebugUserStatus", types.YLeaf{"CTap2DebugUserStatus", cTap2DebugUserEntry.CTap2DebugUserStatus})

    cTap2DebugUserEntry.EntityData.YListKeys = []string {"CTap2MediationContentId", "CTap2DebugUserName"}

    return &(cTap2DebugUserEntry.EntityData)
}